def put(self, request):
"""
编辑是否为年终考核优秀
:param request:
:return:
"""
ret = BaseResponse()
try:
beiceping = request.GET.get('beiceping') # 被测评单位
is_excellent = request.GET.get('status') # 是否优秀标志：0/1
Excellent = Bzresult.objects.filter(
beiceping=beiceping).values('Excellent')[0]
if Excellent['Excellent']:
if int(is_excellent):
ret.code = 209
ret.data = '状态未改变'
return Response(ret.dict)
else:
Bzresult.objects.filter(beiceping=beiceping).update(
Excellent=is_excellent)
else:
if int(is_excellent):
Bzresult.objects.filter(beiceping=beiceping).update(
Excellent=is_excellent)
else:
ret.code = 209
ret.data = '状态未改变'
return Response(ret.dict)
ret.code = 305
ret.data = '修改成功'
except Exception as e:
ret.code = 306
ret.error = '修改失败'
return Response(ret.dict)
return Response(ret.dict)
def list(self, request, *args, **kwargs):
message = BaseResponse()
try:
teacher_id = request.GET.get('teacher_id', '11')
teacher_info = tea_models.TeacherInfo.objects.filter(id=teacher_id).values('identity__title', 'school',
'teachers__stu_class__grade',
'teachers__stu_class').first()
is_psychology_teacher = request.session['teacher_info'].get('is_psychology_teacher')
grade = teacher_info.get('teachers__stu_class__grade')
if not is_psychology_teacher:
stu_class = sch_models.StuClass.objects.filter(grade=grade, id=teacher_info.get('teachers__stu_class'),
school=teacher_info.get('school'))
else:
stu_class = sch_models.StuClass.objects.filter(school=teacher_info.get('school'))
data_list = []
for item in stu_class:
class_name = '%s%s' % (item.grade.get_grade_name_display(), item.name)
student_queryset = stu_models.StudentInfo.objects.filter(stu_class=item, school=teacher_info.get('school')).values('id', 'full_name')
if student_queryset:
student_dict = {class_name: []}
for student in student_queryset:
student_dict[class_name].append(student)
data_list.append(student_dict)
message.state = True
message.data = data_list
except Exception as e:
print(e)
message.msg = '获取学生列表失败'
return Response(message.__dict__)
def get(self, request):
"""查询菜单"""
if request.user.id is not None:
menu_data = self.get_all_menus(request)
return BaseResponse(menu_data, status=OK)
else:
return BaseResponse("请登录后访问", status=FORBIDDEN)
def get(self, request):
res = BaseResponse()
try:
# 1获取user_id
user_id = request.user.id
# print(user_id)
# 2拼接用户的购物车的key key支持模糊匹配
shopping_car_key = SHOPPING_CAR_KEY % (user_id, '*')
# 3去redis读取该用户的所有加入购物车的内容
# 3.1先去模糊匹配出所有匹配的key
all_keys = REDIS_CONN.scan_iter(shopping_car_key)
# print([i for i in all_keys]) # 迭代器的惰性机制，只能从头读到尾，而且只能读一次
# 3.2循环所有的keys 得到每个key
shopping_car_list = []
for key in all_keys:
course_info = REDIS_CONN.hgetall(key)
course_info['price_policy_dict'] = json.loads(
course_info['price_policy_dict'])
shopping_car_list.append(course_info)
# 返回
res.data = shopping_car_list
except Exception as e:
print(e)
res.code = 1033
res.error = '获取购物车失败'
return Response(res.dict)
def get(self, request):
"""
点击被测评人中的修改
:param request:
:return:
"""
ret = BaseResponse()
try:
# 单位
department = Department.objects.values('department')
for each in department:
each['value'] = each['department']
# 职务
zhiwu = Zhiwu.objects.filter(id__in=[2, 3, 4, 5]).values('name')
for each in zhiwu:
each['value'] = each['name']
# 职级
rank = Rank.objects.values('rank', 'number')
condition = {
'department': department,
'zhiwu': zhiwu,
'rank': rank
}
ret.info = condition
return Response(ret.dict)
except Exception as e:
pass
def post(self, request, *args, **kwargs):
'''
更新班级名称以及对应的班主任
:param request:
:param args:
:param kwargs:
:return:
'''
ret = BaseResponse()
try:
data = json.loads(request.body.decode('utf-8'))
teacher_id = data.get('teacherId')
class_name = data.get('className')
class_id = data.get('classId', 0)
# 修改编辑名称操作
class_obj = sc_models.StuClass.objects.filter(id=class_id).only('name').first()
if class_name != class_obj.name:
sc_models.StuClass.objects.filter(id=class_id).update(name=class_name)
if teacher_id:
class_tutor_obj = tea_models.ClassToTeacher.objects.filter(stu_class_id=class_id, relate=1)
if class_tutor_obj:
class_tutor_obj.update(teacher_id=teacher_id)
else:
tea_models.ClassToTeacher.objects.create(teacher_id=teacher_id, stu_class_id=class_id)
ret.msg = '修改成功'
ret.state = True
except Exception as e:
print(e)
ret.msg = '修改失败'
return JsonResponse(ret.get_dict)
def get(self, request):
user_id = request.user.id
res = BaseResponse()
settlement_key = SETTLEMENT % (str(user_id), '*')
global_coupon_key = GLOBAL_COUPON % str(user_id)
settlement_names = CONN.scan_iter(settlement_key)
all_ret = []
ret = []
for name in settlement_names:
dic = CONN.hgetall(name)
if hasattr(dic, 'course_coupon_dic'):
dic['course_coupon_dic'] = json.loads(dic['course_coupon_dic'],
encoding='utf8')
ret.append(dic)
all_ret.append(ret)
global_dic = CONN.hgetall(global_coupon_key)
for key, value in global_dic.items():
if key != 'default_global_coupon_id':
global_dic[key] = json.loads(value, encoding='utf8')
all_ret.append(global_dic)
res.data = all_ret
return Response(res.dic)
def get(self, request):
# 需要用户认证
user = models.UserInfo.objects.filter(pk=1).first()
res = BaseResponse()
menu = self.get_menu(user)
res.data = menu
return Response(res.dic)
def get(self, request):
"""
点击考核结果查询，点击班子按钮，会将各种查询条件反馈到前台
:param request:
:return:
"""
ret = BaseResponse()
condition = {} # 存储各种条件
name = [{
'name': '被测评单位',
'index': 'beiceping_id__department'
}, {
'name': '人数',
'index': 'count'
}, {
'name': '得分',
'index': 'score'
}]
department = request.GET.get('department')
try:
if department == 'xueyuan':
dep = Department.objects.filter(category='学院').values(
'department') # 单位名
index = xybzIndexWeight.objects.filter(
index__isnull=False,
weight__isnull=False).values('index') # 学院班子指标
for i in range(0, len(index)):
name.append({
'name': '{}'.format(index[i]['index']),
'index': 'index{}'.format(i + 1)
})
elif department == 'zhishudanwei':
dep = Department.objects.filter(category='直属单位').values(
'department') # 单位名
index = zsdwbzIndexWeight.objects.filter(
index__isnull=False,
weight__isnull=False).values('index') # 直属单位班子指标
index19 = BzCpWeight.objects.filter(code='001').values_list(
'name', flat=True)[0] # 校领导权重
index20 = BzCpWeight.objects.filter(code='002').values_list(
'name', flat=True)[0] # 党政负责人权重
index21 = BzCpWeight.objects.filter(code='003').values_list(
'name', flat=True)[0] # 单位职工师生代表权重
for i in range(0, len(index)):
name.append({
'name': '{}'.format(index[i]['index']),
'index': 'index{}'.format(i + 1)
})
name.append({'name': '{}'.format(index19), 'index': 'index19'})
name.append({'name': '{}'.format(index20), 'index': 'index20'})
name.append({'name': '{}'.format(index21), 'index': 'index21'})
for i in range(0, len(index)):
index[i]['id'] = 'index{}'.format(i + 1)
condition['dep'] = dep
condition['index'] = index
condition['table_name'] = name
ret.info = condition
except Exception as e:
pass
return Response(ret.dict)
def get(self, request, *args, **kwargs):
res = BaseResponse()
try:
# 1获取user_id
user_id = request.user.id
print('user', user_id)
# 2拼接用户要结算的购物车的key key支持模糊匹配
account_key = ACCOUNT_KEY % (user_id, '*')
# 3去redis读取该用户的所有加入购物车的内容
# 3.1先去模糊匹配出所有匹配的key
all_keys = REDIS_CONN.keys(account_key)
# 3.2循环所有的keys 得到每个key
account_list = {}
for key in all_keys:
course_info = REDIS_CONN.get(key)
account_list['course_info'] = json.loads(course_info)
account_list['course_info']['course_info'][
'price_policy_dict'] = json.loads(
account_list['course_info']['course_info']
['price_policy_dict'])
account_list['global_coupon_%s' % user_id] = json.loads(
REDIS_CONN.get('global_coupon_%s' % user_id))
# 返回
res.data = account_list
except Exception as e:
print(e)
res.code = 1033
res.error = '获取购物车失败'
return Response(res.dict)
def set_password(self, request, pk=None):
perms = UserInfoView.get_permission_from_role(request)
user = UserProfile.objects.get(id=pk)
if 'admin' in perms or 'user_all' in perms or request.user.is_superuser:
new_password1 = request.data['new_password1']
new_password2 = request.data['new_password2']
if new_password1 == new_password2:
user.set_password(new_password2)
user.save()
return BaseResponse('密码修改成功!')
else:
return BaseResponse('新密码两次输入不一致!',
status=status.HTTP_400_BAD_REQUEST)
else:
old_password = request.data['old_password']
if check_password(old_password, user.password):
new_password1 = request.data['new_password1']
new_password2 = request.data['new_password2']
if new_password1 == new_password2:
user.set_password(new_password2)
user.save()
return BaseResponse('密码修改成功!')
else:
return BaseResponse('新密码两次输入不一致!',
status=status.HTTP_400_BAD_REQUEST)
else:
return BaseResponse('旧密码错误!',
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
"""新增文章"""
request_data = request.data
# 生成文章id(uuid)
user_id = request_data.get("user_id")
article_id = shortuuid.uuid()
article_name = request_data.get("content").split("\n")[0]
article_name = re.compile(r'<[^>]+>', re.S).sub('', article_name)
author = request_data.get("author")
origin = "enlighten"
content = request_data.get("content")
title_index = re.search("\n", content).span()[1]
content_no_title = content[title_index:]
publish_time = int(time.time())
article_list_dict = {
"article_id": article_id,
"article_name": article_name,
"author": author,
"origin": origin,
"publish_time": publish_time,
}
article_detail_dict = {
"article_id": article_id,
"article_name": article_name,
"author": author,
"category": "原创", # TODO 暂定原创，后续添加文章发布的分类可选功能。
"content": content_no_title,
"publish_time": publish_time,
}
# 显式地开启一个事务
with transaction.atomic():
# 创建事务保存点
save_id = transaction.savepoint()
try:
# UserPublish更新该用户的发布文章列表
pub_res = UserPublish.objects.get(user_id=user_id)
# 如果 pub_res有,说明该用户至少发布过一篇文章,此时更新 UserPublish
article_id_list = pub_res.article_id
article_id_list.append(article_id)
UserPublish.objects.filter(user_id=user_id).update(article_id=article_id_list)
# 文章表加一条记录
ArticleList.objects.create(**article_list_dict)
ArticleDetail.objects.create(**article_detail_dict)
except UserPublish.DoesNotExist:
# 该用户未发表过任何文章,UserPublish表增加一条记录
UserPublish.objects.create(user_id=user_id, article_id=[article_id])
# 文章表加一条记录
ArticleList.objects.create(**article_list_dict)
ArticleDetail.objects.create(**article_detail_dict)
except Exception as e:
logger.info(e)
# 点赞失败回滚到保存点
transaction.savepoint_rollback(save_id)
return BaseResponse(status=status.HTTP_500_INTERNAL_SERVER_ERROR,
**BusStatusCode.INTERNAL_SERVER_ERROR_5001,
)
# 点赞成功,提交从保存点到当前状态的所有数据库事务操作
transaction.savepoint_commit(save_id)
return BaseResponse(detail="文章发布成功", data={"article_id": article_id})
def get(self, request, *args, **kwargs):
"""获取分类文章"""
response = super().get(self, request, *args, **kwargs)
if response.status_code == status.HTTP_200_OK:
return BaseResponse(data=response.data['results'])
elif response.status_code == status.HTTP_404_NOT_FOUND:
return BaseResponse(**BusStatusCode.BAD_REQUEST_4004)
else:
return BaseResponse(**BusStatusCode.INTERNAL_SERVER_ERROR_5002)
def post(self, request, *args, **kwargs):
username = request.data.get('username')
password = request.data.get('password')
user = authenticate(username=username, password=password)
if user:
payload = jwt_payload_handler(user)
return BaseResponse({'token': jwt.encode(payload, SECRET_KEY)},
status=OK)
else:
return BaseResponse('用户名或密码！', status=BAD)
def post(self, request):
"""
班子考核结果报表
:param request:
:return:
"""
ret = BaseResponse()
data = request.data
try:
year = data['year'] # 年份(前台默认传过来当前年份)
beiceping = data['beiceping'] # 单位
if not year:
year = datetime.datetime.now().year # 当前年份
if beiceping:
obj = Bzresult.objects.filter(year=year,
beiceping=beiceping).values()
else:
obj = Bzresult.objects.filter(
year=year).values().order_by('rankingOfAll')
if not obj:
ret.code = 208
ret.data = '没有对应内容'
return Response(ret.dict)
ret.code = 201
ret.data = '数据加载成功'
ret.info = obj
except Exception as e:
ret.code = 202
ret.error = '数据加载失败'
return Response(ret.dict)
return Response(ret.dict)
def put(self, request):
res = BaseResponse()
try:
# 1 获取前端传来的course_id以及price_policy_id
course_id = request.data.get('course_id', '')
price_policy_id = request.data.get('price_policy_id', '')
user_id = request.user.id
# 2 校验数据的合法性
# 2.1 校验course_id的合法性
shopping_car_key = SHOPPING_CAR_KEY % (user_id, course_id)
if not REDIS_CONN.exists(shopping_car_key):
res.code = 1035
res.error = '课程不存在'
return Response(res.dict)
# 2.2 判断价格是否合法
course_info = REDIS_CONN.hgetall(shopping_car_key)
price_policy_dict = json.loads(course_info['price_policy_dict'])
if str(price_policy_id) not in price_policy_dict:
res.code = 1036
res.error = '所选价格不存在'
return Response(res.dict)
# 3 修改redis中的default_policy_id
course_info['price_policy_id'] = price_policy_id
# 4 修改信息后写入redis
REDIS_CONN.hmset(shopping_car_key, course_info)
res.data = '修改成功'
except Exception as e:
print(e)
res.code = '1034'
res.error = '更新价格策略失败'
return Response(res.dict)
def put(self, request):
# course_id course_coupon_id global_coupon_id
res = BaseResponse()
# 1,获取前端传过来的数据
course_id = request.data.get('course_id', '')
course_coupon_id = request.data.get('course_coupon_id', "")
global_coupon_id = request.data.get('global_coupon_id', "")
user_id = request.user.pk
# 2，校验数据合法性
# 2.1 校验 course_id
key = SETTLEMENT_KEY % (user_id, course_id)
if course_id:
if not CONN.exists(key):
res.code = 1060
res.error = '课程ID不合法'
return Response(res.dict)
# 2.2 校验 course_coupon_id
if course_coupon_id:
course_coupon_dict = json.loads(
CONN.hget(key, 'course_coupon_dict'))
if course_coupon_id not in course_coupon_dict:
res.code = 1061
res.error = '课程优惠券ID不合法'
return Response(res.dict)
# 2.3 校验global_coupon_id
if global_coupon_id:
global_coupon_key = GLOBAL_COUPON_KEY % user_id
if not CONN.exists(global_coupon_key):
res.code = 1062
res.error = '全局优惠券ID不合法'
return Response(res.dict)
# 3，修改redis中数据
CONN.hset(key, 'default_coupon_id', course_coupon_id)
res.data = '更新成功'
return Response(res.dict)
def get(self, request):
# 进来要做用户认证,现在写死了
user = models.UserInfo.objects.filter(pk=1).first()
# 获取用户的角色的二级菜单权限
# permission = models.Permission.objects.filter(role__userinfo=user,firstmenu__isnull=False).values("id","title")
res = BaseResponse()
all_permission_dic = self.get_all_permission()
res.data = dict(all_permission=[])
for key, value in all_permission_dic.items():
res.data["all_permission"].append(value)
return Response(res.dic)
def get(self, request, pk, is_uid):
res = BaseResponse()
if is_uid:
user = models.UserInfo.objects.filter(pk=pk).first()
has_permission = self.has_permission(user)
res.data = has_permission
else:
role = models.Role.objects.filter(pk=pk).first()
has_permission = self.has_permission_1(role)
res.data = has_permission
return Response(res.dic)
def get(self, request):
"""获取手机号数量"""
# 这里判断手机号数量只是为了给前台用户提示
phone = request.GET.get('phone')
if not re.match("^1[3-9]\d{9}$", phone):
raise exceptions.ValidationError(**BusStatusCode.BAD_REQUEST_4002)
count = UserProfile.objects.filter(mobile=phone).count()
if count > 0:
return BaseResponse(status=status.HTTP_400_BAD_REQUEST, **BusStatusCode.BAD_REQUEST_4012)
else:
return BaseResponse(detail="手机号可以注册")
def search_entity_by_subpath(self, node, relations):
"""模式2：实体关系路径递增查询"""
res = BaseResponse()
if not node or len(relations) == 0:
logger.info('node relations is empty')
res.error = 'node relations is empty'
else:
for relation in relations:
pass
return simplejson.dumps(res.dict)
def post(self, request):
"""用户注册"""
# 1.获取参数并校验
# 2.保存注册用户信息
# 3.返回应答,注册成功
serializer = UserRegisterSerializer(data=request.data)
if serializer.is_valid(raise_exception=True):
jwt_response = serializer.save()
return BaseResponse(detail="注册成功", data=jwt_response)
else:
return BaseResponse(detail="注册失败", status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
res = BaseResponse()
# 用序列化器做校验
ser_obj = RegisterSerializer(data=request.data)
if ser_obj.is_valid():
ser_obj.save()
res.data = ser_obj.data
else:
res.code = 1020
res.error = ser_obj.errors
return Response(res.dict)
def post(self, request, pk):
res = BaseResponse()
# 获取前端传过来的数据和user_id
course_list = request.data.get('course_list', '')
user_id = request.user
# 校验数据合法性
for course_id in course_list:
# 2.1 判断course_id是否在购物车中
shopping_car_key = SHOPINGCAR_KEY % (user_id, course_id)
if not conn.exists(shopping_car_key):
res.code = 1050
res.error = '课程id不合法'
return Response(res.dict)
def get(self, request):
res = BaseResponse()
# 1. 拼接redis的key
user_id = request.user
shopping_car_key = SHOPINGCAR_KEY % (user_id, '*')
# 2. 去redis读取数据
# 3. 构建前端的数据结构
all_keys = conn.scan_iter(shopping_car_key)
ret = []
for key in all_keys:
ret.append(conn.hgetall(key))
res.data = ret
return Response(res.data)
def post(self, request):
res = BaseResponse()
# 用序列化器做校验
video_url_web, video_name = get_video_url(
request.data.get('video_url_share'))
if not video_url_web:
res.code = 1020
res.error = "链接无效"
else:
res.data = {
'video_url_web': video_url_web,
'video_name': video_name,
}
return Response(res.dict)
def get(self, request):
res = BaseResponse()
# 1,拼接redis key
user_id = request.user.pk
shopping_car_key = SHOPPINGCAR_KEY % (user_id, "*")
# 2,去redis中读取数据
# 2.1 匹配所有的keys
# 3，构建数据结构展示
all_keys = CONN.scan_iter(shopping_car_key)
ret = []
for key in all_keys:
ret.append(CONN.hgetall(key))
res.data = ret
return Response(res.dict)
def post(self, request):
res = BaseResponse() # 实例化response
# 用序列化器做校验
ser_obj = RegisterSerializer(data=request.data)
if ser_obj.is_valid():
# 检验通过
ser_obj.save()
res.data = ser_obj.data
else:
# 检验失败
res.code = 1020
res.error = ser_obj.errors
print('1111', res.data, res.dict)
return Response(res.dict)
def delete(self, request):
res = BaseResponse()
try:
user = request.user
user_id = user.id
# user_id = 1 # 写死了
course_list = request.data.get('course_list', '')
pipe = CONN.pipeline(transaction=True)
pipe.multi()
if not course_list:
res.code = 1020
res.errors = '购物车请求参数不合法'
return Response(res.dic)
for course_id in course_list:
print(type(course_id), course_id)
name = SHOPPING_CAR % (user_id, str(course_id))
if not CONN.exists(name):
res.code = 1025
res.errors = '购物车课程id不合法'
return Response(res.dic)
pipe.delete(name)
pipe.execute()
if course_list:
UserInfo.objects.filter(pk=user_id).update(
shop_cart_num=F('shop_cart_num') - 1)
return Response(res.dic)
except Exception as e:
print(e)
res.code = 1022
res.errors = '删除购物车失败'
return Response(res.dic)
def patch(self, request, *args, **kwargs):
'''
更新课程表对应的时间
:param request:
:param args:
:param kwargs:
:return:
'''
res = BaseResponse()
try:
data = json.loads(request.body.decode('utf-8'))
start_time = data.get('time')
# 原来的时间
source_time = data.get('sourceTime', '')
school_id = kwargs.get('school_id')
query = sc_models.SchoolTimeRange.objects
is_exist = query.filter(start_time=start_time, school_id=school_id).first()
if is_exist:
res.code = -1
res.msg = '该时间段已经存在，请重新编辑'
return JsonResponse(res.get_dict)
if not source_time:
# 没有原来设置的时间添加操作
query.create(start_time=start_time, school_id=school_id)
else:
# 如果有原来设置的时间更新操作
query.filter(start_time=source_time, school_id=school_id).update(start_time=start_time)
res.state = True
res.code = 200
except:
res.code = -1
res.msg = '编辑时间失败请重新编辑'
return JsonResponse(res.get_dict)
