def put(self, request, menu_id):
menu = Menu.objects.filter(id=menu_id).first()
if not menu:
return json_response(errno=Code.NODATA, errmsg='菜单不存在')
# 获取put请求的参数
put_data = QueryDict(request.body)
# 必须传递instance=menu，绑定表单
form = MenuModelForm(put_data, instance=menu)
if form.is_valid():
# 这样写是拿到新的 menu 对象
obj = form.save()
# 检查修改了的字段是否和权限有关，如果有关就要修改权限
flag = False
# 通过 form.changed_data 拿到被修改的字段列表
if 'name' in form.changed_data:
obj.permission.name = obj.name
flag = True
if 'codename' in form.changed_data:
obj.permission.codename = obj.codename
flag = True
if flag:
obj.permission.save()
return json_response(errmsg='菜单修改成功！')
else:
return render(request,
'myadmin/menu/update_menu.html',
context={'form': form})
def post(self,request):
form=LoginForm(request.POST,request=request)
if form.is_valid():
data='恭喜登录成功！'
return json_response(data=data)
else:
# 定义一个错误信息列表
err_msg_list = []
for item in form.errors.values():
err_msg_list.append(item[0])
err_msg_str = '/'.join(err_msg_list)
return json_response(errno=Code.PARAMERR, errmsg=err_msg_str)
def delete(self, request, menu_id):
menu = Menu.objects.filter(id=menu_id).only('name')
if menu:
menu = menu[0]
if menu.children.filter(is_delete=False).exists():
return json_response(errno=Code.DATAERR, errmsg='父菜单不能被删除')
menu.permission.delete()
menu.delete()
return json_response(errmsg='删除菜单：%s成功' % menu.name)
else:
return json_response(errno=Code.NODATA, errmsg='菜单不存在！')
"""
def get(self, request):
banners = Banner.objects.values(
'image_url',
'news_id').annotate(news_title=F('news__title')).filter(
is_delete=False)[:constants.SHOW_BANNER_COUNT]
data = {'banners': list(banners)}
return json_response(data=data)
def post(self,request):
'''
1、先校验
2、再登陆
:param request:
:return:
'''
form = LoginForm(request.POST,request=request)
if form.is_valid():
return json_response(errmsg='恭喜登陆成功')
else:
# 定义一个错误信息列表
err_msg_list = []
for item in form.errors.values():
err_msg_list.append(item[0])
err_msg_str = '/'.join(err_msg_list)
return json_response(errno=Code.PARAMERR, errmsg=err_msg_str)
def put(self, request, user_id):
# 1.拿到要修改的用户对象
# 2拿到前端传递的数据
# 4.如果成功保存数据
# 5.不存在，返回错误
user = User.objects.filter(id=user_id).first()
if not user:
return json_response(errno=Code.NODATA, errmsg='此用户不存在')
put_data = QueryDict(request.body)
# 创建表单对象、
form = UserModelForm(put_data, instance=user)
if form.is_valid():
form.save()
return json_response(errmsg='用户修改成功')
else:
return render(request, 'myadmin/user/user_detail.html', context={'form': form})
def check_mobile_views(requst, mobile):
"""检查用户名
url:username/(?P<moblie>^(?:+?86)?1(?:3d{3}|5[^4D]d{2}|8d{3}|7(?:[01356789]d{2}|4(?:0d|1[0-2]|9d))|9[189]d{2}|6[567]d{2}|4[579]d{2})d{6}$)/"""
# 去数据库校验数据
data = {'mobile': mobile, # 查用户名
'count': User.objects.filter(mobile=mobile).count() # 用户查询的数量
}
return json_response(data=data)
def delete(self, request, menu_id):
'''
只有写delete方法，delete请求才会过来
注意：这里是真删除！会删除数据库数据，软删除放到修改里面，因为菜单的数据并不是很重要，这是整个菜单管理里面唯一一个真删除
:param request:
:param menu_id:
:return:
'''
menu = Menu.objects.filter(id=menu_id).only('name')
if menu:
menu = menu[0] # 相当于 menu.first()
# 看看是否是父菜单
if menu.children.filter(is_delete=False).exists():
return json_response(errno=Code.DATAERR, errmsg='父菜单不能删除！')
menu.permission.delete()
# 不需要 menu.delete() 这一步是因为permission改为了级联删除，删除了permission， menu也会被删掉
# menu.delete()
return json_response(errmsg='删除菜单：%s成功' % menu.name)
else:
return json_response(errno=Code.NODATA, errmsg='菜单不存在！')
def post(self,request):
# 1数据校验
form=RegisterForm(request.POST)
if form.is_valid():
# 2创建数据
print(form.is_valid())
username=form.cleaned_data.get('username')
password=form.cleaned_data.get('password')
mobile=form.cleaned_data.get('mobile')
#create_user密码自动加密，Django实现
User.objects.create_user(username=username,mobile=mobile,password=password)
return json_response(errmsg='恭喜你注册成功')
else:
# 定义一个错误信息列表
err_msg_list = []
for item in form.errors.values():
err_msg_list.append(item[0])
err_msg_str = '/'.join(err_msg_list)
return json_response(errno=Code.PARAMER, errmsg=err_msg_str)
def post(self, request):
'''
form
:param request:
:return:
'''
form = RegisterForm(request.POST)
if form.is_valid():
# 2.创建数据
username = request.POST.get('username')
password = request.POST.get('password')
mobile = form.cleaned_data.get('mobile')
Users.objects.create_user(username=username, password=password, mobile=mobile)
return json_response(errmsg='恭喜你，注册成功！')
else:
# 定义一个错误信息列表
err_msg_list = []
for item in form.errors.values():
err_msg_list.append(item[0])
err_msg_str = '/'.join(err_msg_list)
return json_response(errno=Code.PARAMERR, errmsg=err_msg_str)
def check_username_views(requst, username):
"""检查用户名
url:username/(?P<username>\w{5,10})/"""
# 去数据库校验数据
# data = {'errno': '0', 'errmsg': 'ok', 'data':
# {'username': username, # 查用户名
# 'count': User.objects.filter(username=username).count()#用户查询的数量
# }}
# return JsonResponse(data=data)
data = {'username': username, # 查用户名
'count': User.objects.filter(username=username).count() # 用户查询的数量
}
return json_response(data=data)
def get(selfr, request):
# 1.拿到所有文档
# 2.分页
# 1.拿到所有文档
docs = Doc.objects.values('file_url', 'file_name', 'title', 'desc',
'image_url').filter(is_delete=False)
# 2.分页
paginator = Paginator(docs, PER_PAGE_DOC_COUNT)
try:
page = paginator.get_page(int(request.GET.get('page')))
except Exception as e:
page = paginator.get_page(1)
data = {'total_page': paginator.num_pages, 'docs': list(page)}
return json_response(data=data)
def post(self, request):
form = MenuModelForm(request.POST)
if form.is_valid():
# 创建菜单
new_menu = form.save()
# 内容对象
content_type = ContentType.objects.filter(app_label='myadmin', model='menu').first()
# 菜单权限对象
permission = Permission.objects.create(name=new_menu.name, content_type=content_type,
codename=new_menu.codename)
new_menu.permission = permission
new_menu.save(update_fields=['permission'])
return json_response(errmsg='菜单添加成功！')
else:
return render(request, 'myadmin/menu/add_menu.html', context={'form': form})
def get(self, request):
# 1、获取参数
try:
tag_id = int(request.GET.get('tag', 0))
except Exception as e:
logger.error('标签错误：\n{}'.format(e))
tag_id = 0
try:
page = int(request.GET.get('page', 0))
except Exception as e:
logger.error('页码错误：\n{}'.format(e))
page = 1
# 使用only返回的是对象，所以传递到前端时需要迭代处理
# news_queryset = News.objects.select_related('tag', 'author').only(
# 'title', 'digest', 'image_url', 'update_time', 'tag__name', 'author__username')
# values 返回字典
# 2、获取查询集，不会去数据库查询数据， 这是一个惰性操作，你不去获取它的值，它不会去操作数据库，filter也不会
# values返回的是字典，only返回的是对象；F方法的效果类似于as的效果select name as tag_name from tb_tag;
news_queryset = News.objects.values(
'id', 'title', 'digest', 'image_url',
'update_time').annotate(tag_name=F('tag__name'),
author=F('author__username'))
# 3、过滤
# if tag_id:
# news = news_queryset.filter(is_delete=False, tag_id=tag_id)
# else:
# news = news_queryset.filter(is_delete=False)
news = news_queryset.filter(
is_delete=False,
tag_id=tag_id) or news_queryset.filter(is_delete=False)
# 4、分页
paginator = Paginator(news, constants.PER_PAGE_NEWS_COUNT)
# 获取页面数据
# 方式一：news_info = paginator.page(page) 但是会报错，get_page可以容错
news_info = paginator.get_page(page)
# 5、返回数据
data = {
'total_pages': paginator.num_pages,
'news': list(news_info) # news_info不是列表，但它可迭代
}
return json_response(data=data)
def check_username_view(request, username):
'''
校验用户名
:param request:
:param username:
:return:
'''
# data = {
# "errno": "0",
# "errmsg": "OK",
# "data": {
# "username": username, # 查询的用户名
# "count": Users.objects.filter(username=username).count() # 用户名查询的数量
# }
# }
data = {
"username": username, # 查询的用户名
"count": Users.objects.filter(username=username).count() # 用户名查询的数量
}
return json_response(data=data)
def put(self, request, menu_id):
menu = Menu.objects.filter(id=menu_id).first()
# 获取put参数
put_data = QueryDict(request.body)
form = MenuModelForm(put_data, instance=menu)
if form.is_valid:
obj = form.save()
flag = False
# 检查修改字段是否与权限有关
if 'name' in form.changed_data:
obj.permission.name = obj.name
flag = True
if 'codename' in form.changed_data:
obj.permission.codename = obj.name
flag = True
if flag:
obj.permission.save()
return json_response(errmsg='菜单修改成功！')
else:
return render(request, 'admin/menu/update_menu.html', context={'form': form})
def check_mobile_view(request, mobile):
'''
校验手机号是否存在
url:/moblie/(?P<moblie>1[3-9]\d{9})/
:param request:
:param mobile:
:return:
'''
# data = {
# "errno": "0",
# "errmsg": "OK",
# "data": {
# "mobile": mobile, # 查询的手机号
# "count": Users.objects.filter(mobile=mobile).count() # 手机号查询的数量
# }
# }
data = {
"mobile": mobile, # 查询的手机号
"count": Users.objects.filter(mobile=mobile).count() # 手机号查询的数量
}
return json_response(data=data)
def get(self, request):
try:
tag_id = int(request.GET.get('tag', 0))
except Exception as e:
logger.error('标签错误：\n{}'.format(e))
tag_id = 0
#page的获取
try:
page = int(request.GET.get('page', 0))
except Exception as e:
logger.error('页码错误：\n{}'.format(e))
page = 1
#3.获取查询集
# 使用only返回的是对象，所以传递到前端时需要迭代处理
# news_queryset = News.objects.select_related('tag', 'author').only(
# 'title', 'digest', 'image_url', 'update_time', 'tag__name', 'author__username')
# values 返回字典
news_queryset = News.objects.values(
'id', 'title', 'digest', 'image_url',
'update_time').annotate(tag_name=F('tag__name'),
author=F('author__username'))
#4过滤
# if tag_id:
# news=news_queryset.filter(is_delete=False,tag_id=tag_id)
# else:
# news=news_queryset.filter(is_delete=False)
news = news_queryset.filter(
is_delete=False,
tag_id=tag_id) or news_queryset.filter(is_delete=False)
#3分页
pageinator = Paginator(news, constants.PER_PAGE_NEWS_COUNT)
# 获取页面数据 get_page可以容错
news_info = pageinator.get_page(page)
#4返回数据
data = {'total_page': pageinator.num_pages, 'news': list(news_info)}
return res_code.json_response(data=data)
def post(self, request, news_id):
# 是否登录
if not request.user.is_authenticated:
return json_response(errno=Code.SESSIONERR,
errmsg=error_map[Code.SESSIONERR])
# 新闻是否存在
if not News.objects.only('id').filter(is_delete=False,
id=news_id).exists():
return json_response(errno=Code.PARAMERR, errmsg='新闻不存在！')
content = request.POST.get('content')
# 内容是否为空
if not content:
return json_response(errno=Code.PARAMERR, errmsg='评论内容不能为空！')
# 父id是否正常
parent_id = request.POST.get('parent_id')
if parent_id:
try:
parent_id = int(parent_id)
if not Comments.objects.only('id').filter(
is_delete=False, id=parent_id,
news_id=news_id).exists():
return json_response(errno=Code.PARAMERR,
errmsg=error_map[Code.PARAMERR])
except Exception as e:
logger.info('前端传递过来的parent_id异常\n{}'.format(e))
return json_response(errno=Code.PARAMERR, errmsg='未知异常')
# 保存到数据库
new_comment = Comments()
new_comment.content = content
new_comment.news_id = news_id
new_comment.author = request.user
new_comment.parent_id = parent_id if parent_id else None
new_comment.save()
return json_response(data=new_comment.to_dict_data())
def post(self, request):
'''
- 发送短信
- 保存这个短信验证码（保存在哪里？）
- 保存发送记录
:param request:
:return:
'''
form = CheckImageForm(request.POST, request=request)
if form.is_valid():
# success
# 获取手机号码
mobile = form.cleaned_data.get('mobile')
# 生成短信验证码
sms_code = ''.join([
random.choice('0123456789')
for _ in range(constants.SMS_CODE_LENGTH)
])
# 发送短信验证码，调用接口
# ..........
# 保存发送记录
# logger.info('发送短信验证码[正常][mobile: %s sms_code: %s]' % (mobile,sms_code))
ccp = CCP()
try:
res = ccp.send_template_sms(
mobile, [sms_code, constants.SMS_CODE_EXPIRES], "1")
if res == 0:
logger.info('发送短信验证码[正常][mobile: %s sms_code: %s]' %
(mobile, sms_code))
else:
logger.error('发送短信验证码[失败][moblie: %s sms_code: %s]' %
(mobile, sms_code))
return json_response(errno=Code.SMSFAIL,
errmsg=error_map[Code.SMSFAIL])
except Exception as e:
logger.error('发送短信验证码[异常][mobile: %s message: %s]' %
(mobile, e))
return json_response(errno=Code.SMSERROR,
errmsg=error_map[Code.SMSERROR])
# 保存这个验证码 这里有个时限的问题
# 两种方案：1、session 2、redis （不保存在MySQL是因为MySQL效率太低）
# 但session的时限是统一设置的，这里如果重新设置时限，会把前面的session覆盖，因此排除session方案，用redis保存验证码
# request.session['sms_code'] = sms_code
# request.session.set_expiry
# 60秒记录
# 5分钟有效
# 创建短信验证码发送记录的key
sms_flag_key = 'sms_flag_{}'.format(mobile)
# 创建短信验证码内容的key
sms_text_key = 'sms_text_{}'.format(mobile)
redis_coon = get_redis_connection(alias='verify_codes')
# 创建一个管道
pl = redis_coon.pipeline()
try:
pl.setex(sms_flag_key, constants.SMS_CODE_INTERVAL, 1)
pl.setex(sms_text_key, constants.SMS_CODE_EXPIRES * 60,
sms_code)
# 让管道通知redis执行命令
pl.execute()
return json_response(errmsg='短信验证码发送成功')
except Exception as e:
logger.error('redis 执行异常, {}'.format(e))
return json_response(errno=Code.UNKOWNERR,
errmsg=error_map[Code.UNKOWNERR])
else:
# fail
# 将表单的报错信息进行拼接
err_msg_list = []
for item in form.errors.values():
# item是一个列表，
err_msg_list.append(item[0])
err_msg_str = '/'.join(err_msg_list)
return json_response(errno=Code.PARAMERR, errmsg=err_msg_str)
def post(self, request):
# 1.校验参数
form = CheckImagForm(request.POST, request=request)
if form.is_valid():
pass
# 2.获取手机
mobile = form.cleaned_data.get('mobile')
# 3.生成手机验证码
sms_code = ''.join([random.choice('0123456789') for _ in range(constants.SMS_CODE_LENGTH)])
print('sms_code%s'%sms_code)
logger.info('发送短信验证码[正常][mobile: %s sms_code: %s]' % (mobile, sms_code))
# 4.发送手机验证码
# ccp = CCP()
# try:
# res = ccp.send_template_sms(mobile, [sms_code, constants.SMS_CODE_EXPIRES], "1")
# if res == 0:
# logger.info('发送短信验证码[正常][mobile: %s sms_code: %s]' % (mobile, sms_code))
# else:
# logger.error('发送短信验证码[失败][moblie: %s sms_code: %s]' % (mobile, sms_code))
# return json_response(errno=Code.SMSFAIL, errmsg=error_map[Code.SMSFAIL])
# except Exception as e:
# logger.error('发送短信验证码[异常][mobile: %s message: %s]' % (mobile, e))
# return json_response(errno=Code.SMSERROR, errmsg=error_map[Code.SMSERROR])
# 5.保存到redis数据库
# 创建短信验证码发送记录
redis_coon=get_redis_connection(alias='verify_code')
sms_flag_key = 'sms_flag_{}'.format(mobile)
# 创建短信验证码内容记录
sms_text_key = 'sms_text_{}'.format(mobile)
pl=redis_coon.pipeline()
try:
pl.setex(sms_flag_key,constants.SMS_CODE_INTERVAL,1)
pl.setex(sms_text_key,constants.SMS_CODE_EXPIRES*60,sms_code)
pl.execute()
return json_response(errmsg="短信验证码发送成功！")
except Exception as e:
logger.error('redis 执行异常：{}'.format(e))
return json_response(errno=Code.UNKOWNERR, errmsg=error_map[Code.UNKOWNERR])
# 4.发送手机验证码
# ccp = CCP()
# try:
# res = ccp.send_template_sms(mobile, [sms_code, constants.SMS_CODE_EXPIRES], "1")
# if res == 0:
# logger.info('发送短信验证码[正常][mobile: %s sms_code: %s]' % (mobile, sms_code))
# else:
# logger.error('发送短信验证码[失败][moblie: %s sms_code: %s]' % (mobile, sms_code))
# return json_response(errno=Code.SMSFAIL, errmsg=error_map[Code.SMSFAIL])
# except Exception as e:
# logger.error('发送短信验证码[异常][mobile: %s message: %s]' % (mobile, e))
# return json_response(errno=Code.SMSERROR, errmsg=error_map[Code.SMSERROR])
# 5.保存到redis数据库
# 创建短信验证码发送记录
# sms_flag_key = 'sms_flag_{}'.format(mobile)
# # 创建短信验证码内容记录
# sms_text_key = 'sms_text_{}'.format(mobile)
# return json_response(errmsg="短信验证码发送成功！")
# redis_conn = get_redis_connection(alias='verify_code')
# # try:
# pl = redis_conn.pipeline()
# pl.setex('sms_%s' % mobile, constants.SMS_CODE_REDIS_EXPIRES, sms_code)
# pl.setex('send_flag_%s' % mobile, constants.SEND_SMS_CODE_INTERVAL, 1)
# pl.execute()
# return json_response(errmsg="短信验证码发送成功！")
# redis_conn.set(sms_flag_key, constants.SMS_CODE_INTERVAL, 1)
# redis_conn.set(sms_text_key, constants.SMS_CODE_EXPIRES * 60, sms_code)
# except Exception as e:
# logger.error('redis 执行异常：{}'.format(e))
#
# return json_response(errno=Code.UNKOWNERR, errmsg=error_map[Code.UNKOWNERR])
# pl = redis_conn.pipeline()
#
# # try:
# pl.setex(sms_flag_key, constants.SMS_CODE_INTERVAL, 1)
# pl.setex(sms_text_key, constants.SMS_CODE_EXPIRES * 60, sms_code)
# # 让管道通知redis执行命令
# pl.execute()
# except Exception as e:
# logger.error('redis 执行异常：{}'.format(e))
#
# return json_response(errno=Code.UNKOWNERR, errmsg=error_map[Code.UNKOWNERR])
else:
# 将表单的报错信息进行拼接
err_msg_list = []
for item in form.errors.get_json_data().values():
err_msg_list.append(item[0].get('message'))
# print(item[0].get('message')) # for test
err_msg_str = '/'.join(err_msg_list) # 拼接错误信息为一个字符串
return json_response(errno=Code.PARAMERR, errmsg=err_msg_str)