def update(self, request, *args, **kwargs):
response = BaseResponse()
try:
course_id = request.data.get('course_id')
policy_id = str(request.data.get("price_policy_id")
) if request.data.get("price_policy_id") else None
# print(policy_id)
# policy_id = 2
key = settings.SHOPPING_CAR_KEY % (request.user.pk, course_id)
# print(key)
if not redis.exists(key):
response.code = 1007
response.error = "课程不存在"
return Response(response.dict)
price_policy_dict = json.loads(
redis.hget(key, 'price_policy_dict').decode('utf-8'))
# print(price_policy_dict)
if policy_id not in price_policy_dict:
response.code = 1008
response.error = "价格周期不存在"
return Response(response.dict)
redis.hset(key, "default_price_policy_id", policy_id)
response.data = "修改成功"
return Response(response.dict)
except Exception as e:
response.code = 1009
response.error = str(e)
print(e)
return Response(response.dict)
def update(self, request, *args, **kwargs):
response = BaseResponse()
try:
course_id = request.data.get('courseid')
policy_id = str(request.data.get('policyid')) if request.data.get(
'policyid') else None
key = settings.LUFFY_SHOPPING_CAR % (
USER_ID,
course_id,
)
if not CONN.exists(key):
response.code = 500
response.error = '课程不存在'
return Response(response.dict)
price_policy_dict = json.loads(
CONN.hget(key, 'price_policy_dict').decode('utf-8'))
if policy_id not in price_policy_dict:
response.code = 502
response.error = '价格策略不存在'
return Response(response.dict)
CONN.hset(key, 'default_price_id', policy_id)
# CONN.expire(key, 20 * 60) # 定时清除redis中的缓存数据
response.data = '修改成功'
except Exception as e:
response.code = 509
response.error = '修改失败'
return Response(response.dict)
def destroy(self, request, *args, **kwargs):
ret = BaseResponse()
course_id = request.data.get('course_id')
price_id = request.data.get('price_id')
key = settings.LUFFY_SHOPPING_CAR % (
1,
course_id,
)
if not CONN.exists(key):
ret.code = 10007
ret.error = '课程不存在'
return Response(ret.dict)
price_policy_dict = json.loads(
CONN.hget(key, 'price_policy_dict').decode('utf-8'))
if price_id not in price_policy_dict:
ret.code = 10008
ret.error = '价格策略不存在'
return Response(ret.dict)
CONN.hset(key, 'default_price_id', price_id)
CONN.expire(key, 20 * 60)
ret.data = '修改成功'
return Response(ret.dict)
def update(self, request, *args, **kwargs):
response = BaseResponse()
try:
courseid = request.data.get('courseid')
price = request.data.get('policyid')
policyid = str(price) if price else None
key = 'shopping_car_%s_%s' % (USER_ID, courseid)
if not CONN.exists(key):
response.code = 10003
response.error = '要修改的课程不存在'
return Response(response.dict)
print(CONN.hget(key, "price_policy_dict"))
price_policy_dict = json.loads(CONN.hget(
key, "price_policy_dict")) # 3.6支持bytes反序列化
if policyid not in price_policy_dict:
response.code = 10004
response.error = '价格策略不存在'
return Response(response.dict)
CONN.hset(key, 'selected_price_id', policyid)
response.code = 10000
response.data = '修改商品信息成功'
except Exception as e:
print(e)
response.code = 100010
response.error = '修改商品数据失败'
return Response(response.dict)
def update(self, request, *args, **kwargs):
"""
修改用户选中的价格策略
:param request:
:param args:
:param kwargs:
:return:
"""
response = BaseResponse()
try:
course_id = request.data.get('courseid')
policy_id = str(request.data.get('policyid')) if request.data.get(
'policyid') else None
key = settings.LUFFY_SHOPPING_CAR % (
USER_ID,
course_id,
)
if not CONN.exists(key):
response.code = 10007
response.error = '课程不存在'
return Response(response.dict)
price_policy_dict = json.loads(
CONN.hget(key, 'price_policy_dict').decode('utf-8'))
if policy_id not in price_policy_dict:
response.code = 10008
response.error = '价格策略不存在'
return Response(response.dict)
CONN.hset(key, 'default_price_id', policy_id)
CONN.expire(key, 10 * 60)
response.data = '修改成功'
except Exception as e:
response.code = 10006
response.error = '修改失败'
return Response(response.dict)
def patch(self,request,*args,**kwargs):
print(request.data)
ret = BaseResponse()
try:
# 获取价格策略ID和课程ID
course_id = str(request.data.get('courseid'))
policy_id = str(request.data.get('policyid'))
# 拼接课程的key
key = settings.SHOPPING_CAR_KEY % (request.auth.user_id, course_id,)
if not self.conn.exists(key):
ret.code = 1001
ret.error = '课程不存在'
return Response(ret.dict)
# reids中获取所有的价格策略
policy_dict = json.loads(str(self.conn.hget(key,'policy'),encoding='utf-8'))
print(policy_dict)
if policy_id not in policy_dict:
ret.code=1002
ret.error = '价格策略不合法'
return Response(ret.dict)
#开始修改课程的默认价格策略
self.conn.hset(key,'default_policy',policy_id)
ret.data = '修改成功'
except Exception as e:
ret.code=1003
ret.error='修改失败'
return Response(ret.dict)
def post(self, request, *args, **kwargs):
"""创建一条购物车信息"""
ret = BaseResponse()
try:
courseId = int(request.data.get('courseId'))
course_obj = Course.objects.get(pk=courseId)
policy_id = int(request.data.get('policy_id'))
redis_key = settings.SHOPPING_CAR_KEY%(request.user.id, courseId)
policy = {}
for item in course_obj.price_policy.all():
policy[item.id] = {'name':item.get_valid_period_display(),'price':item.price}
if policy_id not in policy:
raise PricePolicyInvalid('价格策略不合法')
redis_value = {'title':course_obj.name,
'image':course_obj.course_img,
'policy':json.dumps(policy),
'default_policy': policy_id}
if self.conn.exists(redis_key):
ret.data = '购物车中该套餐已更新成功'
else:
ret.data = '添加到购物车成功'
self.conn.hmset(redis_key, redis_value)
except PricePolicyInvalid as e:
ret.code = 2001
ret.error = e.msg
except ObjectDoesNotExist as e:
ret.code = 2002
ret.error = '课程不存在'
except Exception as e:
ret.code = 2003
ret.error = '获取购物车失败'
return Response(ret.__dict__)
def create(self, request, *args, **kwargs):
"""
加入购物车
:param request:
:param args:
:param kwargs:
:return:
"""
ret = BaseResponse()
# 1.接受用户选中的课程ID和价格策略ID
course_id = request.data.get('course_id')
policy_id = request.data.get('policy_id')
# 2. 判断合法性
# - 课程是否存在？
# - 价格策略是否合法？
# 2.1 课程是否存在？
course_obj = Course.objects.filter(id=course_id).first()
if not course_obj:
ret.code = 500
ret.error = '课程不存在，把手拿上来'
return Response(ret.dict)
# 2.2 价格策略是否合法？
price_policy_list = course_obj.price_policy.all()
price_policy_dict = {}
for item in price_policy_list:
temp = {
'id': item.id,
'price': item.price,
'valid_period': item.valid_period,
'valid_period_display': item.get_valid_period_display()
}
price_policy_dict[item.id] = temp
# {1: {'price': 666666.0, 'valid_period': 180, 'id': 1, 'valid_period_display': '6个月'}, 5: {'price': 6472346.0, 'valid_period': 540, 'id': 5, 'valid_period_display': '18个月'}}
if policy_id not in price_policy_dict:
ret.code = 500
ret.error = '价格策略不存在，把手拿上来'
return Response(ret.dict)
# 3. 把商品和价格策略信息放入购物车 SHOPPING_CAR
# 3.1如果购物车中的商品数量超过了限定，需要限制用户加入
pattern = 'shopping_car_%s_%s' % (USER_ID, '*')
keys = CONN.keys(pattern)
if keys and len(keys) >= 100:
ret.code = 500
ret.error = '东西太多了，先结账把'
return Response(ret.dict)
hash = 'shopping_car_%s_%s' % (USER_ID, course_id)
# 批量生成hash内部的键值对
CONN.hmset(
hash, {
'id': course_id,
'name': course_obj.name,
'img': course_obj.course_img,
'default_price_id': policy_id,
'price_policy_dict': json.dumps(price_policy_dict)
})
# 设置hash数据存在时间
CONN.expire(hash, 20 * 60)
return Response({'code': 10000, 'data': '购买成功'})
def delete(self, request,pk, *args, **kwargs):
"""
删除ansible组
:param request:
:param args:
:param kwargs:
:return:
"""
res = BaseResponse()
try:
ret = models.AnsibleGroup.objects.filter(id=pk).delete()
# print(ret)
if not ret[0]:
res.code = 500
res.error = "删除记录失败"
# 写入到配置文件中
queryset = models.AnsibleGroup.objects.all()
result = FM(queryset).write() # type:dict
# print(result)
if result.get("error"):
res.code = 500
res.error = result.get("error")
return HttpResponse(json.dumps(res.__dict__))
return HttpResponse(json.dumps(res.__dict__))
except Exception as e:
print(e)
res.code = 500
res.error = "删除记录异常"
return HttpResponse(json.dumps(res.__dict__))
def update(self, request, *args, **kwargs):
"""更改
1, 获取课程的ID, 要修改的价格策略的ID
2, 校验合法性(去redis中)
"""
response = BaseResponse()
try:
course_id = request.data.get('courseid')
policy_id = str(request.data.get('policyid')) if request.data.get(
'policyid') else None
# key = 'shopping_car_%s_%s' % (USER_ID, course_id)
key = settings.LUFFY_SHOPPING_CAR % (USER_ID, course_id)
if not CONN.exists(key):
response.code = 10007
response.error = '课程不存在'
return Response(response.dict)
price_policy_dict = json.loads(
CONN.hget(key, 'price_policy_dict').decode('utf-8'))
if policy_id not in price_policy_dict:
response.code = 10008
response.error = '价格策略不存在'
return Response(response.dict)
CONN.hset(key, 'default_price_id', policy_id)
CONN.expire(key, 20 * 60) # 设定时间 消失
response.data = '修改成功'
except Exception as e:
response.code = 10009
response.error = '修改失败'
return Response(response.dict)
def login(self, request, *args, **kwargs):
"""
用户登录认证
:param request:
:param args:
:param kwargs:
:return:
"""
response = BaseResponse()
try:
user = request.data.get("username")
pwd = request.data.get('password')
obj = models.Account.objects.filter(username=user,
password=pwd).first()
if not obj:
response.code = 10002
response.error = '用户名或密码错误'
else:
uid = str(uuid.uuid4())
models.UserToken.objects.update_or_create(
user=obj, defaults={'token': uid})
response.code = 99999
response.data = uid
except Exception as e:
response.code = 10005
response.error = '操作异常'
return Response(request.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是否合法
shoppingcart_key = settings.SHOPPINGCART_KEY%(user_id,course_id)
if not cache.exists(shoppingcart_key):
res.code = 1035
res.error = '课程不存在'
return Response(res.dict)
# 2.2 判断价格策略是否合法
course_info = json.loads(cache.get(shoppingcart_key))
price_policy_dict = course_info['relate_price_policy']
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['choose_price_policy_id'] = price_policy_id
# 4 修改信息后写入redis
cache.set(shoppingcart_key,json.dumps(course_info))
res.data = '更新成功'
except Exception as e:
res.code = 1034
res.error = '更新价格策略失败'
return Response(res.dict)
def update(self, request, *args, **kwargs):
'''
修改购物车的课程
:param request:
:param args:
:param kwargs:
:return:将修改的结果返回
'''
ret = BaseResponse()
try:
course_id = request.data.get("course_id")
price_id = str(request.data.get("price_id")) if request.data.get(
"price_id") else None
key = settings.LUFFYCITY_SHOPPING_CAR % (USER_ID, course_id)
if not CONN.exists(key): # exists判断redis中是否有这个键
ret.code = 404
ret.error = "课程不存在"
price_policy_dict = json.loads(
CONN.hget(key, "price_policy_dict").decode("utf8"))
if price_id not in price_policy_dict:
ret.code = 405
ret.error = "价格策略不存在"
CONN.hset(key, "default_price_dict", price_id)
CONN.expire(key, 5)
ret.data = "购物车课程修改成功"
except Exception as e:
print(e)
ret.code = 500
ret.error = "数据删除失败"
return Response(ret.data)
def post(self, request):
response = BaseResponse()
try:
# 获取前端通过POST请求发送过来的数据
user = request.data.get('username')
pwd = request.data.get('password')
# 查找数据库中是否有此用户
user_obj = User.objects.filter(username=user, password=pwd).first()
if user_obj:
# 如果数据库中有此用户，就做以下内容：
# 1.将此用户名返回给前端
response.user = user_obj.username
# 2.将随机生成一个字符串作为Token值返回给前端
token = get_token(user)
response.user_token = token
# 将随机生成的token保存在数据库中
UserToken.objects.update_or_create(
user=user_obj, defaults={'userToken': token})
else:
response.code = 1001
response.error = '用户名或者密码错误'
except Exception as e:
response.code = 1002
response.error = str(e)
return Response(response.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 = settings.SHOPPINGCAR_REDIS_KEY % (user_id,
course_id)
if not cache.exists(shopping_car_key):
res.code = 1035
res.error = "课程不存在"
return Response(res.dict)
# 2.2 判断价格策略是否合法
course_info = cache.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["default_policy_id"] = price_policy_id
# 4 修改信息后写入redis
cache.hmset(shopping_car_key, course_info)
res.data = "更新成功"
except Exception as e:
res.code = 1034
res.error = "更新价格策略失败"
return Response(res.dict)
def get_data(self):
ret = BaseResponse()
try:
# 从数据库获取数据
queryset = self.queryset.order_by('id')
# 分页
page = PageNumberPagination()
course_list = page.paginate_queryset(queryset, self.request, self)
# 分页之后的结果执行序列化
ser = self.serializer_class(instance=course_list, many=True)
# print(ser.data)
if not ser.data:
ret.code = 500
ret.error = '数据为空'
else:
ret.data = ser.data
except Exception as e:
print(e)
ret.code = 500
ret.error = '获取数据失败'
return ret.dict
def destroy(self,request,*args,**kwargs):
'''
需求：用户选中购物车中的某个商品，点击删除，即删除购物车中此商品信息。
方案：前端将携带着 删除的商品ID 发送到后端；
后端获取到商品ID 和 用户ID 后，通过删除Redis中的键来删除购物车中该商品信息。
code : 1006 --> 用户所选的商品不在购物车中 ; 1007 --> 购物车中的该商品删除失败
'''
# 1. 获取响应数据的实例化对象
response = BaseResponse()
try:
# 2. 获取当前访问用户ID
user_id = request.user.pk
# 3. 获取前端发送过来的商品ID
course_id = kwargs.get('pk')
# 4. 通过获取到的用户ID 和 商品ID 来获取Redis中的键
shopping_car_key = settings.SHOPPING_CAR_KEY.format(user_id,course_id)
# 5. 校验购物车中是否有此键，若没有此键则抛出异常
if not self.conn.exists(shopping_car_key):
raise CourseDoesNotExist
# 6. 校验成功后，通过键删除购物车中的此商品信息
self.conn.delete(shopping_car_key)
# 7. 删除成功后，返回给前端消息
response.data = '购物车中的该商品已删除！'
except CourseDoesNotExist as e:
response.code = 1006
response.error = e.error
except Exception as e:
response.code = 1007
response.error = '购物车中的该商品删除失败！'
return Response(response.dict)
def update(self, request, *args, **kwargs):
"""
修改用户选中的价格策略
1. 获取课程ID、要修改的价格策略ID
2. 校验合法性
"""
response = BaseResponse()
try:
course_id = request.data.get('coursed')
policy_id = str(request.data.get('policyid')) if request.data.get('policyid') else None
key = 'shopping_car_%s_%s' % (USER_ID, course_id)
if not CONN.exists(key):
response.code = 10007
response.error = '该课程不存在'
return Response(response.dict)
price_policy_dict = json.loads(CONN.hget(key, 'price_policy_dict').decode('utf-8'))
if policy_id not in price_policy_dict:
response.code = 10008
response.error = '价格策略不存在'
return Response(response.dict)
CONN.hset(key, 'default_price_id', policy_id)
response.date = '修改成功'
except Exception as e:
response.code = 10009
response.error = '修改失败'
return Response(response.dict)
def patch(self, request, *args, **kwargs):
"""修改结算中心数据"""
user_id = request.user.id
ret = BaseResponse()
course_id = request.data.get('course_id')
coupon_id = request.data.get('coupon_id')
payment_key = settings.PAYMENT_KEY % (user_id, course_id)
payment_global_key = settings.PAYGLOBAL_KEY%(user_id)
# 修改全品类优惠券
if not course_id:
payment_global_dict = json.loads(self.conn.hget(payment_global_key, 'coupon').decode('utf8'))
if str(coupon_id) == '0':
self.conn.hset(payment_global_key, 'default_coupon', 0)
if coupon_id not in payment_global_dict:
ret.error = '没有该优惠券'
ret.code = 4002
return Response(ret.__dict__)
self.conn.hset(payment_global_key, 'default_coupon', coupon_id)
ret.data = '全品类修改成功'
return Response(ret.__dict__)
coupon_dict = json.loads(self.conn.hget(payment_key, 'coupon').decode('utf8'))
if str(coupon_id) == '0':
self.conn.hset(payment_key, 'default_coupon', 0)
if coupon_id not in coupon_dict:
ret.error = '没有该优惠券'
ret.code = 4002
return Response(ret.__dict__)
self.conn.hset(payment_global_key, 'default_coupon', coupon_id)
ret.data = '全品类修改成功'
return Response(ret.__dict__)
def post(self, request):
res = BaseResponse()
try:
# 1 获取前端传过来的course_id 以及price_policy_id user_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是否合法
course_obj = Course.objects.get(pk=course_id)
# 2.2 校验价格策略是否能合法
# 查找课程关联的价格策略
price_policy_list = course_obj.price_policy.all()
price_policy_dict = {}
for price_policy in price_policy_list:
price_policy_dict[price_policy.pk] = {
"prcie": price_policy.price,
"valid_period": price_policy.valid_period,
"valid_period_text":
price_policy.get_valid_period_display(),
"default": price_policy.pk == price_policy_id
}
if price_policy_id not in price_policy_dict:
raise CommonException(1001, "价格策略异常!")
# 3 构建我们想要的数据结构
# 价格策略对象
pp = PricePolicy.objects.get(pk=price_policy_id)
course_info = {
"id": course_id,
"name": course_obj.name,
"course_img": course_obj.course_img,
"relate_price_policy": price_policy_dict,
"default_price": pp.price,
"default_price_period": pp.valid_period,
"default_price_policy_id": pp.pk
}
# 4 写入redis
# 4.1 先拼接购物车的key
shopping_car_key = settings.SHOPPING_CAR_KEY % (user_id, course_id)
# 4.2 写入redis
print("------>")
REDIS_CONN.set(shopping_car_key, json.dumps(course_info))
res.msg = "加入购物车成功!"
except CommonException as e:
res.code = e.code
res.error = e.error
except Exception as e:
res.code = 1030
res.error = "加入购物车失败!"
return Response(res.dict)
def post(self, request, *args, **kwargs):
"""
将课程添加到购物车
:param request:
:param args:
:param kwargs:
:return:
"""
ret = BaseResponse()
try:
# 1. 获取用户提交的课程ID和价格策略ID
course_id = int(request.data.get('courseid'))
policy_id = int(request.data.get('policyid'))
# 2. 获取专题课信息
course = models.Course.objects.get(id=course_id)
# 3. 从数据库获取该课程相关的所有价格策略
price_policy_list = course.price_policy.all()
price_policy_dict = {}
for item in price_policy_list:
price_policy_dict[item.id] = {
"period":item.valid_period,
"period_display":item.get_valid_period_display(),
"price":item.price,
}
# 4. 判断用户提交的价格策略是否在该课程的策略中
if policy_id not in price_policy_dict:
# 价格策略不合法
raise PricePolicyInvalid('价格策略不合法')
# 5. 将购物信息添加到redis中
# self.conn
# car_key = "luffy_shopping_car_%s_%s"
car_key = settings.SHOPPING_CAR_KEY %(request.auth.user_id,course_id,)
car_dict = {
'title':course.name,
'img':course.course_img,
'default_policy':policy_id,
'policy':json.dumps(price_policy_dict)
}
# conn = get_redis_connection("default")
self.conn.hmset(car_key,car_dict)
ret.data = '添加成功'
except PricePolicyInvalid as e:
ret.code = 2001
ret.error = e.msg
except ObjectDoesNotExist as e:
ret.code = 2001
ret.error = '课程不存在'
except Exception as e:
ret.code = 1001
ret.error = '获取购物车失败'
return Response(ret.dict)
def create(self, request, *args, **kwargs):
response = BaseResponse()
try:
user_id = request.user.pk # auth_class中传过来的 token.user, token.token
course_id = request.data.get("course_id")
price_policy_id = request.data.get("price_policy_id")
course_obj = Course.objects.get(pk=course_id) #第一次可能报错
price_policy_list = course_obj.price_policy.all()
price_policy_dict = {}
for price_policy_obj in price_policy_list:
price_policy_dict[price_policy_obj.pk] = {
'price':
price_policy_obj.price,
"valid_period":
price_policy_obj.valid_period,
"valid_period_text":
price_policy_obj.get_valid_period_display(),
}
print(price_policy_id)
print(price_policy_dict)
if price_policy_id not in price_policy_dict: #第二次可能报错
raise PriceDoseNotExist
# redis = get_redis_connection("default")
shopping_car_key = settings.SHOPPING_CAR_KEY % (user_id, course_id)
course_info = {
'name': course_obj.name,
"course_img": course_obj.course_img,
"price_policy_dict": json.dumps(price_policy_dict),
"default_price_policy_id": price_policy_id
}
# print(shopping_car_key)
# print(course_info)
redis.hmset(shopping_car_key, course_info)
print(redis.hgetall('shopping_car_1_1'))
# for key,val in redis.hgetall("shopping_car_1_1").items():
# print(key.decode('utf-8'),':',val.decode('utf-8'))
response.msg = "成功加入购物车"
except ObjectDoesNotExist as e:
response.code = 1002
response.error = "没有该课程"
except PriceDoseNotExist as e:
response.code = 1003
response.error = e.error
except Exception as e:
response.code = 1004
response.error = str(e)
return Response(response.dict)
def create(self, request, *args, **kwargs):
'''
购物车添加课程
:param request:课程id和价格策略id
:param args:
:param kwargs:
:return: 状态码，数据，错误信息
'''
ret = BaseResponse()
try:
course_id = request.data.get("course_id")
policy_id = request.data.get("price_id")
course_obj = models.Course.objects.filter(id=course_id).first()
if not course_obj:
ret.code = 404
ret.error = "课程不存在"
return Response(ret.dict)
price_policy_queryset = course_obj.price_policy.all()
price_policy_dict = {}
for item in price_policy_queryset:
temp = {
"id": item.id,
"price": item.price,
"valid_period": item.valid_period,
"valid_period_display": item.get_valid_period_display()
}
price_policy_dict[item.id] = temp
if policy_id not in price_policy_dict:
ret.code = 404
ret.error = "价格不存在"
return Response(ret, dict)
pattern = settings.LUFFYCITY_SHOPPING_CAR % (USER_ID, "*")
keys = CONN.keys(pattern)
if keys and len(keys) >= 1000:
ret.code = 501
ret.error = "购物车内的商品已达到最大数量！！！"
return Response(ret.data)
key = settings.LUFFYCITY_SHOPPING_CAR % (USER_ID, course_id)
CONN.hset(key, "id", course_id)
CONN.hset(key, "name", course_obj.name)
CONN.hset(key, "img", course_obj.course_img)
CONN.hset(key, "default_price_id", policy_id)
CONN.hset(key, "price_policy_dict", json.dumps(price_policy_dict))
CONN.expire(key, 60 * 60 * 24) # 设置在24小时后在内存中清除这条记录
except Exception as e:
print(e)
ret.code = 505
ret.error = "获取数据失败"
return Response(ret.dict)
def create(self, request, *args, **kwargs):
"""
用户将课程加入购物车
:param request:
:param args:
:param kwargs:
:return:
"""
# 接收后端发送的数据
response = BaseResponse()
ret = json.loads(request.body.decode('utf8'))
# 课程id
id = ret['1']['course_id']
# 价格策略id
price_id = ret['1']['price_id']
# 先找到此课程
verify_course = models.Course.objects.filter(id=id).first()
# 如果存在
if not verify_course:
# 不存在课程返回数据
response.code = 10001
response.error = '课程不存在'
return Response(response.dict)
# 找价格策略
ser_obj = api_serializers.CourseModelSerializer(verify_course)
# 如果存在
if price_id not in ser_obj.data.get('pricepolicy'):
# 价格策略失败返回数据
response.code = 10001
response.error = '价格策略有问题！'
return Response(response.dict)
# 写入购物车
# 给redis起键名/以shoppingcar_用户id_课程id为键名
key = settings.LUFFY_SHOPPING_CAR % (
USER_ID,
id,
)
CONN.hmset(
key, {
'id': id,
'name': verify_course.name,
'img': verify_course.course_img,
'default_price_id': price_id,
'price_policy_dict': json.dumps(
ser_obj.data.get('pricepolicy'))
})
# 成功返回数据
response.data = '加入购物车成功！'
return Response(response.dict)
def create(self, request, *args, **kwargs):
ret = BaseResponse()
# print(request.data)
# user_id = request.data.get('user_id')
course_id = request.data.get('course_id')
price_id = request.data.get('price_id')
course_obj = models.Course.objects.filter(pk=course_id).first()
if not course_obj:
ret.code = 10001
ret.error = '课程不存在'
return Response(ret.dict)
price_policy_queryset = course_obj.price_policy.all()
price_policy_dict = {}
for item in price_policy_queryset:
temp = {
'id': item.id,
'price': item.price,
'valid_period': item.valid_period,
'valid_period_display': item.get_valid_period_display()
}
price_policy_dict[item.id] = temp
if price_id not in price_policy_dict:
ret.code = 10002
ret.error = '价格策略不存在'
return Response(ret.dict)
key = settings.LUFFY_SHOPPING_CAR % (
1,
'*',
)
keys = CONN.keys(key)
if keys and len(keys) >= 1000:
ret.code = 10003
ret.error = '购物车已经满了，请先结算'
return Response(ret.dict)
key = settings.LUFFY_SHOPPING_CAR % (
1,
course_id,
)
CONN.hset(key, 'id', course_id)
CONN.hset(key, 'name', course_obj.name)
CONN.hset(key, 'img', course_obj.course_img)
CONN.hset(key, 'default_price_id', price_id)
CONN.hset(key, 'price_policy_dict', json.dumps(price_policy_dict))
CONN.expire(key, 20 * 60)
ret.code = 10004
ret.data = '购买成功'
return Response(ret.dict)
def list(self, request, *args, **kwargs):
ret = BaseResponse()
# 购物车详细信息
try:
shopping_car_course_list = []
# pattern = 'shopping_car_%s_*'%(USER_ID)
pattern = settings.LUFFY_SHOPPING_CAR % (USER_ID, '*')
user_key_list = CONN.keys(pattern)
print(user_key_list)
for key in user_key_list:
temp = {
'id':
CONN.hget(key, 'id').decode('utf-8'),
'name':
CONN.hget(key, 'name').decode('utf-8'),
'img':
CONN.hget(key, 'img').decode('utf-8'),
'default_price_id':
CONN.hget(key, 'default_price_id').decode('utf-8'),
'price_policy_dict':
json.loads(
CONN.hget(key, 'price_policy_dict').decode('utf-8')),
}
shopping_car_course_list.append(temp)
ret.data = shopping_car_course_list
except Exception as e:
ret.code = 500
ret.error = '获取购物车失败'
return Response(ret.dict)
def destroy(self, request, courseid, *args, **kwargs):
response = BaseResponse()
try:
key = 'shopping_car_%s_%s' % (USER_ID, courseid)
print(CONN.exists(key))
print(CONN.keys())
if not CONN.exists(key):
response.code = 10008
response.error = '商品不存在无法删除'
return Response(response.dict)
CONN.delete(key)
response.data = '删除成功'
except Exception as e:
response.code = 10006
response.error = '删除失败'
return Response(response.dict)
def get(self, request, version):
response = BaseResponse()
try:
if request.query_params.get('a'):
queryset = Course.objects.filter(degree_course__isnull=True)
else:
queryset = Course.objects.all()
p = CoursePagination()
course_list = p.paginate_queryset(queryset=queryset,
request=request,
view=self)
print(course_list)
serializer = CourseSerializer(course_list, many=True)
# serializer.data OrderedDict有序字典列表
print(serializer.data)
response.data = serializer.data
print()
except Exception as e:
response.code = 0
response.error = '获取数据失败'
return Response(response.dict) # vars(object)
def get(self, request, pk, *args, **kwargs):
ret = BaseResponse()
res = {}
try:
courses_obj = models.Course.objects.filter(
pk=pk, degree_course__isnull=False).first()
print(courses_obj)
res['name'] = courses_obj.name
res['brief'] = courses_obj.brief
res['level'] = courses_obj.get_level_display()
res['hours'] = courses_obj.coursedetail.hours
res['why_study'] = courses_obj.coursedetail.why_study
name_list = courses_obj.coursedetail.recommend_courses.all()
list = []
for i in name_list:
print('___>', i.name)
list.append(i.name)
res['name_list'] = list
print(res)
ret.data = res
print(ret.dict)
except Exception as e:
ret.code = 500
ret.error = '获取数据失败'
return Response(ret.dict)
def list(self, request, *args, **kwargs):
response = BaseResponse()
try:
shopping_car_list = []
# 'shopping_car_%s_%s'
pattern = settings.LUFFY_SHOPPING_CAR % (1, '*') # 查询当前用户的所有的课程
shopping_list = CONN.keys(pattern)
for key in shopping_list:
tamp = {
'id':
CONN.hget(key, 'id').decode('utf-8'),
'name':
CONN.hget(key, 'name').decode('utf-8'),
'img':
CONN.hget(key, 'img').decode('utf-8'),
'default_price_id':
CONN.hget(key, 'default_price_id').decode('utf-8'),
'price_policy_dict':
json.loads(
CONN.hget(key, 'price_policy_dict').decode('utf-8')),
}
shopping_car_list.append(tamp)
response.code = 200
response.data = shopping_car_list
# print(shopping_car_list)
except Exception as e:
response.code = 4004
response.error = '查询购物车失败'
return Response(response.dict)
