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 get(self, request):
"""
根据单位表，自动生成领导班子统计信息表
:param request:
:return:
"""
ret = BaseResponse()
try:
department_obj = Department.objects.values() # 获取单位表所有对象
BzTjInfo.objects.all().delete() # 首先清空领导班子统计信息表
for each_obj in department_obj:
print(each_obj)
BzTjInfo.objects.create(
id=each_obj['id'],
department_id=each_obj['department'],
number_id=each_obj['number'],
type=each_obj['category'],
cePing=1
)
except Exception as e:
ret.code = 202
ret.error = '数据生成失败'
return JsonResponse(ret.dict)
ret.code = 201
ret.error = '数据生成成功'
return JsonResponse(ret.dict)
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 post(self, request):
ret = BaseResponse()
# 获取用户名和密码
username = request.data.get('username')
if not username:
ret.code = 1010
ret.error = '用户名不能为空'
pwd = request.data.get('pwd')
if not pwd:
ret.code = 1011
ret.error = '密码不能为空'
return Response(ret.dict)
# 判断是否有这个用户对象
try:
# 从数据库拿出账户密码进行对比
user_obj = Account.objects.filter(username=username,
pwd=pwd).first()
if not user_obj:
ret.code = 1012
ret.error = '用户名或密码错误'
return Response(ret.dict)
# 生成token
user_obj.token = uuid.uuid4()
user_obj.save()
ret.data = '登录成功！'
except Exception as e:
print(e)
ret.code = 1013
ret.error = '登录失败'
return Response(ret.dict)
def post(self, request):
r = BaseResponse()
data = request.data
username = data.get('username')
password = data.get('password')
if not username or not password:
r.code = 1001
r.errors = '用户名或密码为空'
return Response(r.dic)
user = UserInfo.objects.filter(username=username,
password=password).first()
if not user:
r.code = 1002
r.errors = '用户名或密码为错误'
return Response(r.dic)
self.init_permission(user)
token = uuid.uuid4()
CONN.set(str(token), user.id, ex=36000)
r.data = {
'access_token':
token,
"user":
dict(id=user.id,
username=username,
shop_cart_num=user.shop_cart_num,
balance=user.balance)
}
return Response(r.dic)
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 post(self, request):
res = BaseResponse()
username = request.data.get('username', '')
pwd = request.data.get('password', '')
pwd_salt = 'luffy_password' + pwd
pwd = hashlib.md5(pwd_salt.encode()).hexdigest()
user_obj = Account.objects.filter(username=username, pwd=pwd).first()
if not user_obj:
res.code = 1030
res.error = '用户名或密码错误'
# 用户登陆成功生成一个token写入redis
# 写入 redis token:user_id
conn = redis.Redis(connection_pool=Pool)
try:
token = str(uuid.uuid4())
# conn.set(token, user_obj.id, ex=30)
conn.set(token, user_obj.id)
res.data = token
print('登录成功')
print(token)
print(res.dict)
except Exception as e:
res.code = 1031
res.error = '创建令牌失败'
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 post(self, request):
"""
生成折线图
:param request:
:return:
"""
ret = BaseResponse()
recieve = request.data
data = []
try:
result = recieve['result'] # 结果
category = recieve['category'] # 分类
department = recieve['department'] # 单位
index = recieve['index'] # 指标
if category == 'xueyuan':
lst = []
for i in index:
index_name = xygbIndexWeight.objects.filter(
code='00{}'.format(i[5:])).values_list('index',
flat=True)[0]
lst.append(str(index_name))
elif category == 'jiguan':
lst = []
for i in index:
index_name = jggbIndexWeight.objects.filter(
code='00{}'.format(i[5:])).values_list('index',
flat=True)[0]
lst.append(index_name)
elif category == 'zhishudanwei':
lst = []
for i in index:
index_name = zsdwgbIndexWeight.objects.filter(
code='00{}'.format(i[5:])).values_list('index',
flat=True)[0]
lst.append(index_name)
for i in result:
score = []
for index_id in index:
if i.get(index_id, None):
score.append(i[index_id])
data.append({'label': i['beiceping_id__name'], 'data': score})
options = {
'type': 'line',
'title': {
'text': department
},
'bgColor': '#fbfbfb',
'labels': lst,
'datasets': data
}
ret.code = 201
ret.data = '数据加载成功'
ret.info = options
except Exception as e:
ret.code = 202
ret.error = '数据加载失败'
return Response(ret.dict)
return Response(ret.dict)
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 put(self, request):
user = request.user
user_id = user.id
# user_id = 1 # 写死了
course_id = request.data.get('course_id', '')
price_policy_id = request.data.get('price_policy_id', '')
res = BaseResponse()
name = SHOPPING_CAR % (user_id, course_id)
if not course_id or not price_policy_id:
res.code = 1020
res.errors = '购物车请求参数不合法'
return Response(res.dic)
if not CONN.exists(name):
res.code = 1025
res.errors = '购物车课程id不合法'
return Response(res.dic)
course_info = CONN.hgetall(name)
price_policy_dic = course_info.get('price_policy_dic')
price_policy_dic = json.loads(price_policy_dic, encoding='utf-8')
if str(price_policy_id) not in price_policy_dic:
res.code = 1021
res.errors = '价格策略id不合法'
return Response(res.dic)
course_info['price_policy_default_id'] = price_policy_id
try:
CONN.hmset(name, course_info)
res.data = '更新购物车成功'
return Response(res.dic)
except Exception as e:
res.code = 1022
res.errors = '加入购物车失败'
return Response(res.dic)
def get(self, request):
"""
返回班子信息
:param request:
:return:
"""
ret = BaseResponse()
data = {}
try:
data['tableName'] = [
{'index': 'department_id', 'name': '被测评单位'},
{'index': 'number_id', 'name': '单位名'},
{'index': 'type', 'name': '类别'},
{'index': 'cePing', 'name': '是否测评'},
]
obj = BzTjInfo.objects.values()
data['obj'] = list(obj)
except Exception as e:
ret.code = 0
ret.error = '加载失败'
return JsonResponse(ret.dict)
ret.code = 1
ret.data = '加载成功'
ret.info = data
return JsonResponse(ret.dict)
def put(self, request):
res = BaseResponse()
try:
# 负责处理第三方订单
# 获取数据
self.get_data(request)
# 校验数据合法性
self.check_data()
# 校验成功,修改订单状态
self.update_order()
# 添加用户课程购买的记录
self.update_study_course()
res.data = '订单付款成功'
return Response(res.dic)
except KeyError as e:
print(e)
res.code = 1040
res.errors = '订单参数不合法'
return Response(res.dic)
except Exception as e:
print(e)
res.code = 1045
res.errors = '订单未知错误'
return Response(res.dic)
def post(self, request):
"""
导出数据
表头还是数据库的英文表头，没有变成中文
:param request:
:return:
前台需要传给后台三个参数：
1.文件名
2.如果是导出数据库的就传数据表名
3.如果是自定义数据，就将数据传过来
"""
ret = BaseResponse()
recept = request.data
try:
data = recept['data'] # 自定义数据
filename = recept['filename'] # 文件名
table = recept['table'] # 数据表名
path = get_desktop_path() + r'\{}'.format(filename)
if table != '':
table = globals()[table] # 可以将字符串转换成类名
if table == '':
exportdata(path, 0, data)
if data == '':
exportdata(path, table, 0)
except Exception as e:
ret.code = 211
ret.error = '数据导出失败'
return Response(ret.dict)
ret.code = 210
ret.data = '数据导出成功'
return Response(ret.dict)
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)
def post(self, request):
ret = BaseResponse()
user = request.user
user_id = user.id
course_id = request.data.get('course_id', '')
price_policy_id = request.data.get('price_policy_id', '')
if not course_id or not price_policy_id:
ret.code = 1020
ret.errors = '购物车请求参数不合法'
return Response(ret.dic)
course = Course.objects.filter(pk=course_id).first()
if not course:
ret.code = 1025
ret.errors = '购物车课程id不合法'
return Response(ret.dic)
if StudyCourse.objects.filter(account=user, course=course).exists():
ret.code = 1024
ret.errors = '课程已购买,请勿重复加入购物车'
return Response(ret.dic)
price_policy_qs = course.price_policy.all()
price_policy_dic = {}
for obj in price_policy_qs:
price_policy_dic[obj.id] = dict(
id=obj.id,
price=obj.price,
valid_period_display=obj.get_valid_period_display(),
valid_period=obj.valid_period)
if price_policy_id not in price_policy_dic:
ret.code = 1021
ret.errors = '购物车价格策略id不合法'
return Response(ret.dic)
price_policy_dic = json.dumps(price_policy_dic, ensure_ascii=False)
key = SHOPPING_CAR % (user_id, course_id)
value = dict(course_id=course_id,
title=course.title,
course_img=str(course.course_img),
price_policy_dic=price_policy_dic,
price_policy_default_id=price_policy_id)
try:
if not CONN.exists(key):
UserInfo.objects.filter(pk=user_id).update(
shop_cart_num=F('shop_cart_num') + 1)
CONN.hmset(key, value)
ret.data = '加入购物车成功'
return Response(ret.dic)
except Exception as e:
ret.code = 1022
ret.errors = '加入购物车失败'
return Response(ret.dic)
def post(self, request):
"""
登录接口
:param request:
:return:
"""
ret = BaseResponse()
data = {}
username = request.data.get('username')
pwd = request.data.get('password')
role = request.data.get('role') # 超级管理员或者二级管理员
hash_pwd = hashlib.md5(pwd.encode()).hexdigest()
try:
user_obj = User.objects.filter(username=username, password=hash_pwd).first()
if not user_obj:
ret.code = 101
ret.error = '用户名或密码错误'
return JsonResponse(ret.dict)
elif user_obj:
if str(user_obj.roles) == role:
data['role'] = role
data['dep'] = str(user_obj.department)
# 登录成功
# 将权限信息写入到session
# 1.查当前登录用户拥有的权限
permission_list = User.objects.filter(username=username).values_list('roles__permissions__url').distinct()
# 2.将权限信息写入到session
request.session[settings.PERMISSION_SESSION_KEY] = list(permission_list)
request.session['cepingId'] = username
request.session['role'] = role # 增加这个是为了只对二级管理员处理
if role == '二级管理员':
request.session['department'] = str(user_obj.department)
data['username'] = username
# 生成token
# user_obj.token = uuid.uuid4()
# user_obj.save()
ret.code = 103
ret.info = data
ret.data = '登录成功'
else:
ret.code = 110
ret.data = '请选择正确的身份权限'
return JsonResponse(ret.dict)
except Exception as e:
ret.code = 102
ret.error = '登录失败'
return JsonResponse(ret.dict)
return JsonResponse(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 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 post(self, request):
res = BaseResponse()
# 1,获取前端传过来的数据以及user_id
course_id = request.data.get('course_id', '')
price_policy_id = request.data.get("price_policy_id", '')
print(course_id, price_policy_id)
user_id = request.user.pk
# 2,校验数据的合法性
# 2.1 校验课程id合法性
course_obj = Course.objects.filter(id=course_id).first()
# print('课程id：',course_id)
if not course_obj:
res.code = 1040
res.error = '课程ID不合法'
return Response(res.dict)
# 2.2 校验价格策略id是否合法
price_policy_queryset = course_obj.price_policy.all()
print("ppq:", price_policy_queryset)
price_policy_dict = {}
for price_policy in price_policy_queryset:
price_policy_dict[price_policy.id] = {
'price': price_policy.price,
'valid_period': price_policy.valid_period,
'valid_period_display': price_policy.get_valid_period_display,
}
print(price_policy_dict)
if price_policy_id not in price_policy_dict:
res.code = 1041
res.error = '价格策略id不合法'
return Response(res.dict)
# 3，构建redisKey
key = SHOPPINGCAR_KEY % (user_id, course_id)
# 4，构建数据结果
course_info = {
'id': course_obj.id,
'title': course_obj.title,
'course_img': str(course_obj.course_img),
'price_policy_dict': json.dumps(price_policy_dict,
ensure_ascii=False),
'default_price_policy_id': price_policy_id,
}
# 5，写入redis
CONN.hmset(key, course_info)
res.data = '加入购物车成功'
return Response(res.dict)
def get(self, request):
"""
修改班子统计信息表中的是否测评
:param request:
:return:
"""
ret = BaseResponse()
try:
cePing = request.GET.get('cePing') # 接收前台传过来的是否测评
number = request.GET.get('number') # 接收前台传过来单位代码
BzTjInfo.objects.filter(number_id=number).update(cePing=cePing)
except Exception as e:
ret.code = 0
ret.error = '修改失败'
return JsonResponse(ret.dict)
ret.code = 1
ret.error = '修改成功'
return JsonResponse(ret.dict)
def post(self, request):
"""
学院班子结果表
:param request:
:return:
"""
ret = BaseResponse()
try:
with transaction.atomic():
xybzResult.objects.all().delete()
xybzresult()
except Exception as e:
ret.code = 204
ret.error = '数据计算失败'
return Response(ret.dict)
ret.code = 203
ret.data = '数据计算成功'
return Response(ret.dict)
def post(self, request):
res = BaseResponse()
# 1.获取前端传递的数据及user_id
course_id = request.data.get("course_id", "")
price_policy_id = request.data.get("price_policy_id", "")
user_id = request.user.pk # LoginAuth返回的user_obj即为request.user
# 2.校验数据的合法性
# 2.1.校验课程id合法性
course_obj = Course.objects.filter(id=course_id).first()
if not course_obj:
res.code = 1040
res.error = "课程id不合法"
return Response(res.dict)
# 2.2 校验价格策略id是否合法
price_policy_queryset = course_obj.price_policy.all()
price_policy_dict = {}
for price_policy in price_policy_queryset:
price_policy_dict[price_policy.id] = {
"price": price_policy.price, # 价格
"valid_period": price_policy.valid_period, # 周期
"valid_period_display":
price_policy.get_valid_period_display() # 周期中文
}
print("价格策略", price_policy_id, price_policy_dict)
if price_policy_id not in price_policy_dict:
res.code = 1041
res.error = "价格策略id不合法"
return Response(res.dict)
# 3.构建redis Key
key = SHOPPINGCAR_KEY % (user_id, course_id)
# 4.构建redis数据结构
course_info = {
"id": course_obj.id,
"title": course_obj.title,
"course_img": str(course_obj.course_img), # 解决字典类型不一致的问题
# 所有放入redis的字典最好做一下json.dumps，防止出现格式问题或中文乱码
"price_policy_dict": json.dumps(price_policy_dict,
ensure_ascii=False),
"default_price_policy_id": price_policy_id
}
# 5.写入redis
CONN.hmset(key, course_info)
res.data = "加入购物车成功"
return Response(res.dict)
def post(self, request, pk):
res = BaseResponse()
correction_file = request.FILES.get('correction_file')
if not correction_file:
res.code = 1010
res.errors = "上传批改结果为空"
return Response(res.dic)
obj = HomeworkRecord.objects.filter(pk=pk).first()
form = HomeworkRecordForm(request.data, request.FILES,
instance=obj) # 注意获取数据的方式
if form.is_valid():
form.save()
HomeworkRecord.objects.filter(pk=pk).update(homework_status=3)
res.data = dict(homework_record_id=pk)
return Response(res.dic)
else:
res.code = 1011
res.errors = '上传失败,请重新上传'
return Response(res.dic)
def post(self, request, *args, **kwargs):
res = BaseResponse()
# 1 获取数据
user = request.user
course_id_list = request.data.get('course_id_list')
try:
# 清空操作
# 找到所有的account_user_id_*,全部清空
# del_list = REDIS_CONN.keys(ACCOUNT_KEY % (user.pk, "*"))
# REDIS_CONN.delete(*del_list)
# 2 循环课程列表为每个课程建立数据结构
for course_id in course_id_list:
account_key = ACCOUNT_KEY % (user.pk, course_id)
account_dict = {}
shopping_car_key = SHOPPING_CAR_KEY % (user.pk, course_id)
# 判断课程是否存在购物车中
if not REDIS_CONN.exists(shopping_car_key):
raise CommonException('购物车中该课程不存在', 1040)
# 将课程信息加入到结算字典中
course_info = REDIS_CONN.hgetall(shopping_car_key)
account_dict['course_info'] = course_info
# 将课程优惠卷加入到每一个课程结算字典中
# 查询与当前用户拥有没使用的，在有效期且与课程相关的优惠卷
account_dict['course_coupons'] = self.get_coupon_dict(
request, course_id)
# 存储结算信息
REDIS_CONN.set(account_key, json.dumps(account_dict))
# 存储通用优惠卷，加入到redis中
REDIS_CONN.set('global_coupon_%s' % user.pk,
json.dumps(self.get_coupon_dict(request)))
res.code = 1044
res.data = '成功'
# print(json.loads(REDIS_CONN.get(account_key)))
except CommonException as e:
res.code = e.code
res.error = e.msg
except Exception as e:
res.code = 500
res.error = str(e)
return Response(res.dict)
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 get(self, request, *args, **kwargs):
res = BaseResponse()
try:
course_id = request.GET.get('courseId')
class_id = request.GET.get('classId')
teacher_obj = tea_model.TeacherInfo.objects.filter(
course=course_id,
teachers__stu_class=class_id).values('id', 'last_name',
'first_name').first()
if not teacher_obj:
res.msg = "未能查询到代课老师"
res.code = -1
return Response(res.get_dict)
res.data = teacher_obj
res.code = 200
except Exception as e:
res.code = -1
res.msg = '获取代课老师信息失败'
return Response(res.get_dict)
def post(self, request):
r = BaseResponse()
username = request.data.get('username')
password = request.data.get('password')
if username is None or password is None:
r.code = 1005
r.errors = '注册的用户名或密码为空'
return Response(r.dic)
if UserInfo.objects.filter(username=username).exists():
r.code = 1006
r.errors = '注册用户已存在'
return Response(r.dic)
user = UserInfo.objects.create(username=username, password=password)
user.roles.set(*["3"]) # 通过该接口默认分配学生角色
r.data = {
'user':
dict(id=user.id,
username=username,
shop_cart_num=user.shop_cart_num)
}
return Response(r.dic)
def delete(self, request):
res = BaseResponse()
try:
# 获取前端传过来的course_id
course_id = request.data.get('course_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 = 1039
res.error = '删除的课程不存在'
return Response(res.dict)
# 删除redis中的数据
REDIS_CONN.delete(shopping_car_key)
res.data = '删除成功'
except Exception as e:
print(e)
res.code = 1037
res.error = '删除失败'
return Response(res.dict)
def get(self, request):
"""
账户信息
:param request:
:return:
"""
ret = BaseResponse()
data = {}
try:
super_ad = list(User.objects.filter(roles_id=1).values('username'))
lower_ad = list(User.objects.filter(roles_id=2).values('username', 'department__department'))
data['super'] = super_ad
data['lower'] = lower_ad
ret.code = 201
ret.data = '数据加载成功'
ret.info = data
except Exception as e:
ret.code = 202
ret.data = '数据加载失败'
return JsonResponse(ret.dict)
return JsonResponse(ret.dict)
