def put(self, request, doc_id):
doc = Docs.objects.filter(is_delete=False, id=doc_id).first()
if not doc:
return res_json(errno=Code.NODATA, errmsg='需要更新的文档不存在')
json_data = request.body
if not json_data:
return res_json(errno=Code.PARAMERR,
errmsg=error_map[Code.PARAMERR])
# 将json转化为dict
dict_data = json.loads(json_data.decode('utf8'))
form = forms.DocsPubForm(data=dict_data)
if form.is_valid():
doc.title = form.cleaned_data.get('title')
doc.desc = form.cleaned_data.get('desc')
doc.file_url = form.cleaned_data.get('file_url')
doc.image_url = form.cleaned_data.get('image_url')
doc.save()
return res_json(errmsg='文档更新成功')
else:
# 定义一个错误信息列表
err_msg_list = []
for item in form.errors.get_json_data().values():
err_msg_list.append(item[0].get('message'))
err_msg_str = '/'.join(err_msg_list) # 拼接错误信息为一个字符串
return res_json(errno=Code.PARAMERR, errmsg=err_msg_str)
def put(self, request, news_id):
"""
更新文章
:param request:
:param news_id:
:return:
"""
news = models.News.objects.filter(is_delete=False, id=news_id).first()
if not news:
return res_json(errno=Code.NODATA, errmsg='需要更新的文章不存在')
json_data = request.body
if not json_data:
return res_json(errno=Code.PARAMERR,
errmsg=error_map[Code.PARAMERR])
# 将json转化为dict
dict_data = json.loads(json_data.decode('utf8'))
form = forms.NewsPubForm(data=dict_data)
if form.is_valid():
news.title = form.cleaned_data.get('title')
news.digest = form.cleaned_data.get('digest')
news.content = form.cleaned_data.get('content')
news.image_url = form.cleaned_data.get('image_url')
news.tag = form.cleaned_data.get('tag')
news.save()
return res_json(errmsg='文章更新成功')
else:
# 定义一个错误信息列表
err_msg_list = []
for item in form.errors.get_json_data().values():
err_msg_list.append(item[0].get('message'))
err_msg_str = '/'.join(err_msg_list) # 拼接错误信息为一个字符串
return res_json(errno=Code.PARAMERR, errmsg=err_msg_str)
def post(self, request):
# request.FILES.get('image_file') 获取图片对象
image_file = request.FILES.get('image_file')
if not image_file:
logger.info('从前端获取图片失败')
return res_json(errno=Code.NODATA, errmsg='从前端获取图片失败')
# 文件类型有content_type这个属性
if image_file.content_type not in ('image/jpeg', 'image/png',
'image/gif'):
return res_json(errno=Code.DATAERR, errmsg='不能上传非图片文件')
# image_file.name 文件名
try:
image_ext_name = image_file.name.split('.')[-1]
except Exception as e:
logger.info('图片拓展名异常：{}'.format(e))
image_ext_name = 'jpg'
try:
# 前端传的是文件 需要通过upload_by_buffer() 方法，
upload_res = FDFS_Client.upload_by_buffer(
image_file.read(), file_ext_name=image_ext_name)
except Exception as e:
logger.error('图片上传出现异常：{}'.format(e))
return res_json(errno=Code.UNKOWNERR, errmsg='图片上传异常')
else:
# 此处有个点Upload successed.
if upload_res.get('Status') != 'Upload successed.':
logger.info('图片上传到FastDFS服务器失败')
return res_json(Code.UNKOWNERR, errmsg='图片上传到服务器失败')
else:
image_name = upload_res.get('Remote file_id')
image_url = FDFS_URL + image_name
return res_json(data={'image_url': image_url}, errmsg='图片上传成功')
def put(self, request, course_id):
course = Course.objects.filter(is_delete=False, id=course_id).first()
if not course:
return res_json(errno=Code.NODATA, errmsg='需要更新的课程不存在')
json_data = request.body
if not json_data:
return res_json(errno=Code.PARAMERR,
errmsg=error_map[Code.PARAMERR])
# 将json转化为dict
dict_data = json.loads(json_data.decode('utf8'))
form = forms.CoursesPubForm(data=dict_data)
if form.is_valid():
for attr, value in form.cleaned_data.items():
setattr(course, attr, value)
course.save()
return res_json(errmsg='课程更新成功')
else:
# 定义一个错误信息列表
err_msg_list = []
for item in form.errors.get_json_data().values():
err_msg_list.append(item[0].get('message'))
err_msg_str = '/'.join(err_msg_list) # 拼接错误信息为一个字符串
return res_json(errno=Code.PARAMERR, errmsg=err_msg_str)
def post(self, request):
text_file = request.FILES.get('text_file')
if not text_file:
logger.info('从前端获取文件失败')
return res_json(errno=Code.NODATA, errmsg='从前端获取文件失败')
if text_file.content_type not in ('application/octet-stream',
'application/pdf', 'application/zip',
'text/plain', 'application/x-rar'):
return res_json(errno=Code.DATAERR, errmsg='不能上传非文本文件')
try:
text_ext_name = text_file.name.split('.')[-1]
except Exception as e:
logger.info('文件拓展名异常：{}'.format(e))
text_ext_name = 'pdf'
try:
upload_res = FDFS_Client.upload_by_buffer(
text_file.read(), file_ext_name=text_ext_name)
except Exception as e:
logger.error('文件上传出现异常：{}'.format(e))
return res_json(errno=Code.UNKOWNERR, errmsg='文件上传异常')
else:
if upload_res.get('Status') != 'Upload successed.':
logger.info('文件上传到FastDFS服务器失败')
return res_json(Code.UNKOWNERR, errmsg='文件上传到服务器失败')
else:
text_name = upload_res.get('Remote file_id')
text_url = FDFS_URL + text_name
return res_json(data={'text_file': text_url}, errmsg='文件上传成功')
def delete(self, request, tag_id):
tag = models.Tag.objects.only('id').filter(id=tag_id).first()
if tag:
tag.delete()
return res_json(errmsg="标签更新成功")
else:
return res_json(errno=Code.PARAMERR, errmsg="需要删除的标签不存在")
def delete(self, request, banner_id):
banner = models.Banner.objects.only('id').filter(id=banner_id).first()
if banner:
banner.is_delete = True
banner.save(update_fields=['is_delete'])
return res_json(errmsg="轮播图删除成功")
else:
return res_json(errno=Code.PARAMERR, errmsg="需要删除的轮播图不存在")
def delete(self, request, course_id):
course = Course.objects.filter(is_delete=False, id=course_id).first()
if course:
course.is_delete = True
course.save(update_fields=['is_delete'])
return res_json(errmsg="课程删除成功")
else:
return res_json(errno=Code.PARAMERR, errmsg="需要删除的课程不存在")
def delete(self, request, doc_id):
doc = Docs.objects.filter(is_delete=False, id=doc_id).first()
if doc:
doc.is_delete = True
doc.save(update_fields=['is_delete'])
return res_json(errmsg="文档删除成功")
else:
return res_json(errno=Code.PARAMERR, errmsg="需要删除的文档不存在")
def delete(self, request, hotnews_id):
hotnews = models.HotNews.objects.only('id').filter(
id=hotnews_id).first()
if hotnews:
hotnews.is_delete = True
hotnews.save(update_fields=['is_delete'])
return res_json(errmsg="热门文章删除成功")
else:
return res_json(errno=Code.PARAMERR, errmsg="需要删除的热门文章不存在")
def delete(self, request, news_id):
"""
1.校验文章是否存在
2.删除数据
3.返回前端 True/False
:param request:
:param news_id:
:return:
"""
news = models.News.objects.only('id').filter(id=news_id).first()
if news:
news.is_delete = True
news.save(update_fields=['is_delete'])
return res_json(errmsg="文章删除成功")
else:
return res_json(errno=Code.PARAMERR, errmsg="需要删除的文章不存在")
def get(self, request, tag_id):
newses = models.News.objects.values('id',
'title').filter(is_delete=False,
tag_id=tag_id)
news_list = [i for i in newses]
return res_json(data={'news': news_list})
def put(self, request, banner_id):
banner = models.Banner.objects.only('id').filter(id=banner_id).first()
if not banner:
return res_json(errno=Code.PARAMERR, errmsg="需要更新的轮播图不存在")
json_data = request.body
if not json_data:
return res_json(errno=Code.PARAMERR,
errmsg=error_map[Code.PARAMERR])
# 将json转化为dict
dict_data = json.loads(json_data.decode('utf8'))
try:
priority = int(dict_data.get('priority'))
priority_list = [i for i, _ in models.Banner.PRI_CHOICES]
if priority not in priority_list:
return res_json(errno=Code.PARAMERR, errmsg='轮播图的优先级设置错误')
except Exception as e:
logger.info('轮播图优先级异常：\n{}'.format(e))
return res_json(errno=Code.PARAMERR, errmsg='轮播图的优先级设置错误')
image_url = dict_data.get('image_url')
if not image_url:
return res_json(errno=Code.PARAMERR, errmsg='轮播图url为空')
if banner.priority == priority and banner.image_url == image_url:
return res_json(errno=Code.PARAMERR, errmsg="轮播图的参数未改变")
banner.priority = priority
banner.image_url = image_url
banner.save(update_fields=['priority', 'image_url'])
return res_json(errmsg="轮播图更新成功")
def post(self, request):
js_str = request.body
if not js_str:
return params_status
tag_name = json.loads(js_str)
name = tag_name.get('name')
if name:
name = name.strip()
# 深度学习 深度学习 元组 旧 obj False
tag = models.Tag.objects.get_or_create(name=name)
if tag[-1]:
return res_json(errno=Code.OK)
else:
return res_json(errno=Code.DATAEXIST, errmsg='名字重复')
# return (res_json(errno=Code.OK) if tag[-1] else res_json(errno=Code.DATAEXIST, errmsg='名字重复'))
else:
return res_json(errno=Code.NODATA, errmsg=error_map[Code.NODATA])
def post(self, request):
js_str = request.body
if not js_str:
return res_json(errno=Code.PARAMERR, errmsg='参数错误')
dict_data = json.loads(js_str.decode())
# 数据验证 使用form 表单验证
form = LoginForm(data=dict_data, request=request)
if form.is_valid():
# 表单验证成工处理
return res_json(errno=Code.OK)
else:
# 表单验证失败处理
msg_list = []
for i in form.errors.get_json_data().values():
msg_list.append(i[0].get('message'))
msg_str = '/'.join(msg_list)
return res_json(errno=Code.PARAMERR, errmsg=msg_str)
def post(self, request):
json_data = request.body
if not json_data:
return res_json(errno=Code.PARAMERR,
errmsg=error_map[Code.PARAMERR])
dict_data = json.loads(json_data.decode('utf8'))
form = forms.CoursesPubForm(data=dict_data)
if form.is_valid():
courses_instance = form.save()
return res_json(errmsg='课程发布成功')
else:
# 定义一个错误信息列表
err_msg_list = []
for item in form.errors.get_json_data().values():
err_msg_list.append(item[0].get('message'))
err_msg_str = '/'.join(err_msg_list) # 拼接错误信息为一个字符串
return res_json(errno=Code.PARAMERR, errmsg=err_msg_str)
def post(self, request):
'''
"password": sPassword,
"mobile": sMobile,
"sms_code": sSmsCode
:param request:
:return:
'''
res_error = res_json(errno=Code.PARAMERR, errmsg='参数错误')
data = request.body
if not data:
return res_json(errno=Code.PARAMERR,errmsg=error_map[Code.PARAMERR])
data = json.loads(data)
psd = data['password']
mobile = data['mobile']
sms_num = data['sms_code']
if not all([psd, mobile, sms_num]):
return res_error
# 数据清洗 判断格式
if not re.match(r'^[a-zA-Z0-9]{6,20}$', psd):
return res_error
if not re.match(r'^1[3-9]\d{9}$', mobile):
return res_error
# 处理验证码
redis_conn = get_redis_connection('verify_codes')
sms_code = redis_conn.get('sms_{}'.format(mobile))
redis_conn.delete(sms_code)
redis_conn.delete('sms_flag_' + mobile)
sms_code = sms_code.decode()
if sms_num != sms_code:
return HttpResponseForbidden('验证码错误')
try:
user = Users.objects.get(mobile=mobile)
except Exception as e:
logger.error(e)
return HttpResponseForbidden('参数错误')
else:
user.set_password(psd)
user.save()
return res_json(errmsg='密码已更新，请回去登录')
def put(self, request, hotnews_id):
json_data = request.body
if not json_data:
return res_json(errno=Code.PARAMERR,
errmsg=error_map[Code.PARAMERR])
# 将json转化为dict
dict_data = json.loads(json_data.decode('utf8'))
try:
priority = int(dict_data.get('priority'))
priority_list = [i for i, _ in models.HotNews.PRI_CHOICES]
if priority not in priority_list:
return res_json(errno=Code.PARAMERR, errmsg='热门文章的优先级设置错误')
except Exception as e:
logger.info('热门文章优先级异常：\n{}'.format(e))
return res_json(errno=Code.PARAMERR, errmsg='热门文章的优先级设置错误')
hotnews = models.HotNews.objects.only('id').filter(
id=hotnews_id).first()
if not hotnews:
return res_json(errno=Code.PARAMERR, errmsg="需要更新的热门文章不存在")
if hotnews.priority == priority:
return res_json(errno=Code.PARAMERR, errmsg="热门文章的优先级未改变")
hotnews.priority = priority
hotnews.save(update_fields=['priority'])
return res_json(errmsg="热门文章更新成功")
def post(self, request):
json_data = request.body
if not json_data:
return res_json(errno=Code.PARAMERR,
errmsg=error_map[Code.PARAMERR])
# 将json转化为dict
dict_data = json.loads(json_data.decode('utf8'))
try:
news_id = int(dict_data.get('news_id'))
except Exception as e:
logger.info('前端传过来的文章id参数异常：\n{}'.format(e))
return res_json(errno=Code.PARAMERR, errmsg='参数错误')
if not models.News.objects.filter(id=news_id).exists():
return res_json(errno=Code.PARAMERR, errmsg='文章不存在')
try:
priority = int(dict_data.get('priority'))
priority_list = [i for i, _ in models.HotNews.PRI_CHOICES]
if priority not in priority_list:
return res_json(errno=Code.PARAMERR, errmsg='热门文章的优先级设置错误')
except Exception as e:
logger.info('热门文章优先级异常：\n{}'.format(e))
return res_json(errno=Code.PARAMERR, errmsg='热门文章的优先级设置错误')
# 创建热门新闻
hotnews_tuple = models.HotNews.objects.get_or_create(news_id=news_id)
hotnews, is_created = hotnews_tuple
hotnews.priority = priority # 修改优先级
hotnews.save(update_fields=['priority'])
return res_json(errmsg="热门文章创建成功")
def post(self, request):
json_data = request.body
if not json_data:
return res_json(errno=Code.PARAMERR,
errmsg=error_map[Code.PARAMERR])
# 将json转化为dict
dict_data = json.loads(json_data.decode('utf8'))
form = forms.DocsPubForm(data=dict_data)
if form.is_valid():
docs_instance = form.save(commit=False)
docs_instance.author_id = request.user.id
docs_instance.save()
return res_json(errmsg='文档创建成功')
else:
# 定义一个错误信息列表
err_msg_list = []
for item in form.errors.get_json_data().values():
err_msg_list.append(item[0].get('message'))
err_msg_str = '/'.join(err_msg_list) # 拼接错误信息为一个字符串
return res_json(errno=Code.PARAMERR, errmsg=err_msg_str)
def put(self, request, tag_id):
json_data = request.body
if not json_data:
return params_status
# 将json转化为dict
dict_data = json.loads(json_data.decode('utf8'))
tag_name = dict_data.get('name')
tag = models.Tag.objects.only('id').filter(id=tag_id).first()
if tag:
if tag_name and tag_name.strip():
# 有查询集有数据就返回True ,否则返回False
if not models.Tag.objects.only('id').filter(
name=tag_name).exists():
tag.name = tag_name
tag.save(update_fields=['name'])
return res_json(errmsg="标签更新成功")
else:
return res_json(errno=Code.DATAEXIST, errmsg="标签名已存在")
else:
return res_json(errno=Code.PARAMERR, errmsg="标签名为空")
else:
return res_json(errno=Code.PARAMERR, errmsg="需要更新的标签不存在")
def post(self, request):
json_data = request.body
if not json_data:
return res_json(errno=Code.PARAMERR,
errmsg=error_map[Code.PARAMERR])
# 将json转化为dict
dict_data = json.loads(json_data.decode('utf8'))
try:
news_id = int(dict_data.get('news_id'))
except Exception as e:
logger.info('前端传过来的文章id参数异常：\n{}'.format(e))
return res_json(errno=Code.PARAMERR, errmsg='参数错误')
if not models.News.objects.filter(id=news_id).exists():
return res_json(errno=Code.PARAMERR, errmsg='文章不存在')
try:
priority = int(dict_data.get('priority'))
priority_list = [i for i, _ in models.Banner.PRI_CHOICES]
if priority not in priority_list:
return res_json(errno=Code.PARAMERR, errmsg='轮播图的优先级设置错误')
except Exception as e:
logger.info('轮播图优先级异常：\n{}'.format(e))
return res_json(errno=Code.PARAMERR, errmsg='轮播图的优先级设置错误')
# 获取轮播图url
image_url = dict_data.get('image_url')
if not image_url:
return res_json(errno=Code.PARAMERR, errmsg='轮播图url为空')
# 创建轮播图
banners_tuple = models.Banner.objects.get_or_create(news_id=news_id)
banner, is_created = banners_tuple
banner.priority = priority
banner.image_url = image_url
banner.save(update_fields=['priority', 'image_url'])
return res_json(errmsg="轮播图创建成功")
def get(self, request, username):
data = {
'username': username,
'count': Users.objects.filter(username=username).count()
}
return res_json(data=data)
def post(self, request):
"""
"username": sUsername,
"password": sPassword,
"password_repeat": sPasswordRepeat,
"mobile": sMobile,
"sms_code": sSmsCode
:param request:
:return:
"""
data_dict = request.body
data_dict = json.loads(data_dict)
username = data_dict.get('username')
password = data_dict.get('password')
password2 = data_dict.get('password_repeat')
mobile = data_dict.get('mobile')
sms_code = data_dict.get('sms_code')
# 1.非空
if not all([username, password, password2, mobile, sms_code]):
return HttpResponseForbidden('填写数据不完整')
# 2.用户名
if not re.match('^[\u4e00-\u9fa5\w]{5,20}$', username):
return HttpResponseForbidden('用户名为5-20个字符')
if Users.objects.filter(username=username).count() > 0:
return HttpResponseForbidden('用户名已经存在')
# 密码
if not re.match('^[0-9A-Za-z]{6,20}$', password):
return HttpResponseForbidden('密码为6-20个字符')
# 确认密码
if password != password2:
return HttpResponseForbidden('两个密码不一致')
# 手机号
if not re.match('^1[3456789]\d{9}$', mobile):
return HttpResponseForbidden('手机号错误')
if Users.objects.filter(mobile=mobile).count() > 0:
return HttpResponseForbidden('手机号存在')
# 短信验证码
# 1.读取redis中的短信验证码
redis_cli = get_redis_connection('verify_codes')
sms_code_redis = redis_cli.get('sms_{}'.format(mobile))
# 2.判断是否过期
if sms_code_redis is None:
return HttpResponseForbidden('短信验证码已经过期')
# 3.删除短信验证码，不可以使用第二次
redis_cli.delete('sms_' + mobile)
redis_cli.delete('send_flag_' + mobile)
# 4.判断是否正确
if sms_code_redis.decode() != sms_code:
return HttpResponseForbidden('短信验证码错误')
# 处理
# 1.创建用户对象
user = Users.objects.create_user(
username=username,
password=password,
mobile=mobile
)
# 2.状态保持
login(request, user)
# 向cookie中写用户名，用于客户端显示
response = res_json(errmsg='恭喜你，注册成功！')
return response
def post(self, request):
json_str = request.body
if not json_str:
return res_json(errno=Code.PARAMERR, errmsg='参数错误')
dict_data = json.loads(json_str)
image_code_client = dict_data.get('text')
uuid = dict_data.get('image_code_id')
mobile = dict_data.get('mobile')
# 校验参数
if not all([image_code_client, uuid, mobile]):
return res_json(errno=Code.PARAMERR, errmsg='参数错误')
# 创建连接到redis的对象
redis_conn = get_redis_connection('verify_codes')
# 提取数据库的图形验证码
image_code_server = redis_conn.get('img_%s' % uuid)
if image_code_server is None:
# 图形验证码过期或者不存在
return res_json(errno=Code.PARAMERR, errmsg='参数错误')
# 删除图形验证码，避免恶意测试图形验证码
try:
redis_conn.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
# 对比图形验证码
image_code_server = image_code_server.decode() # bytes转字符串
if image_code_client.lower() != image_code_server.lower(): # 转小写后比较
return res_json(errno=Code.PARAMERR, errmsg='输入图形验证码有误')
# 生成短信验证码：生成6位数验证码
sms_code = '%06d' % random.randint(0, 999999)
logger.info(sms_code)
# 限定频繁发送验证码
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
return res_json(errno=Code.DATAEXIST, errmsg='发送短信过于频繁')
redis_conn.setex('sms_%s' % mobile, 60, sms_code)
# 重新写入send_flag
redis_conn.setex('send_flag_%s' % mobile, 60, 1)
# 执行请求
# 发送短信
logger.info('短信验证码: {}'.format(sms_code))
logging.info('发送短信正常[mobile:%s sms_num:%s]' % (mobile, sms_code))
# 发送短信验证码
# ccp = CCP()
# ccp.send_template_sms(mobile, [sms_code, 5], 1)
send_sms_code.delay(mobile, sms_code)
# 响应结果
return res_json(errmsg='短信验证码发送成功')
#
# class SMSCodeView(GenericAPIView):
# """
# 短信验证码
# """
# serializer_class = serializers.CheckImageCodeSerialzier
#
# def get(self, request, mobile):
# """
# 创建短信验证码
# """
# # 判断图片验证码, 判断是否在60s内
# serializer = self.get_serializer(data=request.query_params)
# # 校验
# serializer.is_valid(raise_exception=True)
#
# # 生成短信验证码
# sms_code = "%06d" % random.randint(0, 999999)
# print("短信验证码内容是：%s" % sms_code)
#
# # 保存短信验证码与发送记录
# redis_conn = get_redis_connection('verify_codes')
# 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()
#
# # 发送短信验证码
# send_sms_code(mobile, sms_code)
#
# return Response({"message": "OK"}, status.HTTP_200_OK)
#
#
# class SMSCodeByTokenView(APIView):
# """根据access_token发送短信"""
#
# def get(self, request):
# # 获取并校验 access_token
# access_token = request.query_params.get('access_token')
# if not access_token:
# return Response({"message": "缺少access token"}, status=status.HTTP_400_BAD_REQUEST)
#
# # 从access_token中取出手机号
# mobile = Users.check_send_sms_code_token(access_token)
# if mobile is None:
# return Response({"message": "无效的access token"}, status=status.HTTP_400_BAD_REQUEST)
#
# # 判断手机号发送的次数
# redis_conn = get_redis_connection('verify_codes')
# send_flag = redis_conn.get('send_flag_%s' % mobile)
# if send_flag:
# return Response({"message": "发送短信次数过于频"}, status=status.HTTP_429_TOO_MANY_REQUESTS)
#
# # 生成短信验证码
# sms_code = '%06d' % random.randint(0, 999999)
# print('短信验证码{}'.format(sms_code))
#
# # 使用redis的pipeline管道一次执行多个命令
# 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()
#
# # 发送短信
# # ccp = CCP()
# # time = str(constants.SMS_CODE_REDIS_EXPIRES / 60)
# # ccp.send_template_sms(mobile, [sms_code, time], constants.SMS_CODE_TEMP_ID)
# # 使用celery发布异步任务
# send_sms_code(mobile, sms_code)
#
# # 返回
# return Response({'message': 'OK'})
from django.http import Http404, JsonResponse
from django.shortcuts import render
from django.views import View
from TZ_Django_test.settings.dev import FDFS_URL
from TZ_Django_test.utils.fastdfs.fdfs import FDFS_Client
from TZ_Django_test.utils.res_code import Code, error_map, res_json
from TZ_Django_test.utils.secrets import qiniu_secret_info
from admin import forms
from admin.scripts import get_page_data
from courses.models import Course, Teacher, CourseCategory
from docs.models import Docs
from news import models
from users.models import Users
params_status = res_json(errno=Code.PARAMERR, errmsg=error_map[Code.PARAMERR])
logger = logging.getLogger()
class IndexView(View):
"""
"""
def get(self, request):
return render(request, 'admin/index/index.html')
class TagsManageView(View):
def get(self, request):
tags = models.Tag.objects.values(
'id', 'name').annotate(num_news=Count('news')).filter(
is_delete=False).order_by('num_news')
def get(self, request, mobile):
data = {
'mobile': mobile,
'count': Users.objects.filter(mobile=mobile).count()
}
return res_json(data=data, )
