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 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 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):
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 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 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 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 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 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 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 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):
"""
生成折线图
: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 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):
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, *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 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 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 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
# 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()
}
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 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 post(self, request):
res = BaseResponse()
username = request.data.get("username", "")
pwd = request.data.get("pwd", "")
user_obj = Account.objects.filter(username=username,
pwd=pwd).first() # 查询用户表拿到用户对象
if not user_obj:
res.code = 1030
res.error = "用户名或密码错误"
return Response(res.dict)
# 用户登录成功生成一个token写入redis
# 写入redis token(唯一): user_id
conn = redis.Redis(connection_pool=POOL)
try:
token = uuid.uuid4() # 生成随机字符串,类型是:<class 'uuid.UUID'>
conn.set(str(token), user_obj.id, ex=1200) # ex：过期时间120秒
res.data = token
except Exception as e:
print(e)
res.code = 1031
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.校验数据合法性
key = SETTLEMENT_KEY % (user_id, course_id)
# 2.1 校验course_id是否合法
if course_id:
if not CONN.exists(key):
# 不存在这个key
res.code = 1060
res.error = "课程id不合法"
return Response(res.data)
# 2.2 校验course_coupon_id 是否合法
if course_coupon_id:
course_coupon_dict = json.loads(
CONN.hget(key, "course_coupon_dict"))
if str(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)
CONN.hset(global_coupon_key, "default_global_coupon_id",
global_coupon_id)
# 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('pwd', '')
user_obj = Account.objects.filter(username=username, pwd=pwd).first()
if not user_obj:
res.code = 1030
res.error = '用户名和密码错误'
return Response(res.dict)
# 用户登录成功生成一个token写入reids
# 写入 redis token: user_id
conn = redis.Redis(connection_pool=POOL)
try:
token = uuid.uuid4()
# conn.set(str(token), user_obj, ex=123)
# 我们测试的时候，先将延时取消掉
conn.set(str(token), user_obj.id)
res.data = token
except Exception as e:
res.code = 1031
res.error = '创建令牌失败'
return Response(res.dict)
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 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 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 str(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)
CONN.hset(global_coupon_key, "default_global_coupon_id",
global_coupon_id)
# 3，修改redis中数据
CONN.hset(key, "default_coupon_id", course_coupon_id)
res.data = "更新成功"
return Response(res.dict)
def post(self, request):
res = BaseResponse()
# 用序列化器做校验
res_url, res_name, aweme_type = get_video_url(
request.data.get('video_url_share'))
# 视频类型
if aweme_type == 4:
video_url, video_url_web, video_name = res_url[0], res_url[
1], res_name
if not video_url_web:
res.code = 1020
res.error = "链接无效"
else:
res.data = {
'video_url_web': video_url_web,
'video_name': video_name,
'aweme_type': aweme_type,
}
logger.info(f'{video_url} {video_name}')
return Response(res.dict)
# 图集类型
elif aweme_type == 2:
image_url_list, image_name_list = res_url, res_name
if not image_url_list:
res.code = 1020
res.error = "链接无效"
else:
res.data = {
'image_url_list': image_url_list,
'image_name_list': image_name_list,
'aweme_type': aweme_type,
}
return Response(res.dict)
else:
res.code = 1020
res.error = "链接无效"
return Response(res.dict)
def put(self, request):
# 更新购物车：前端需要提供course_id、price_policy_id
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
# 2.校验数据的合法性
# 2.1 course_id是否合法
key = SHOPPINGCAR_KEY % (user_id, course_id)
if not CONN.exists(key): # exists检查名字是否存在
res.code = 1043
res.error = "课程id不合法"
return Response(res.dict)
# 2.2 price_policy_id是否合法
price_policy_dict = json.loads(CONN.hget(key, "price_policy_dict"))
if str(price_policy_id) not in price_policy_dict:
res.code = 1044
res.error = "价格策略不合法"
return Response(res.dict)
# 3.更新redis中的default_price_policy_id字段
CONN.hset(key, "default_price_policy_id", price_policy_id)
res.data = "更新成功"
return Response(res.dict)
