def destroy(self, request, *args, **kwargs):
start_time = time.time()
ruleId = kwargs['pk']
logger.info('删除规则的id: %s' % (ruleId))
res = BaseResponse()
Cassandra_obj = CassandraRule()
try:
Cassandra_obj.delete_data(ruleId)
except OperationalError as e:
res.code = 1906
res.msg = '数据库连接失败'
logger.debug('删除规则数据时数据库连接失败')
except Exception as e:
res.code = 1909
res.msg = '规则删除失败: %s' % ruleId
logger.debug('规则%s删除失败:%s' % (ruleId,e))
else:
res.data = ruleId
res.code = 0
res.msg = '规则删除成功: %s' % ruleId
logger.info('规则删除成功: %s' % ruleId)
site_rule_key = '%s_%s_%s' % ("*","*", ruleId)
try:
self.redis.find_delete_key(site_rule_key)
except ConnectionError as e:
logger.debug('redis连接失败,数据从缓存中删除: %s' % ruleId)
finally:
logger.info('destroy QualityRule----time:%.5fs' % (time.time() - start_time))
return Response(res.dict, status=status.HTTP_200_OK)
def close_log(request):
"""
关闭实时日志
:param request:
:return:
"""
res = BaseResponse() # 初始化返回值
if request.method == "POST":
ip = request.POST.get('ip')
dir = request.POST.get('dir')
# 日志文件
file_name = request.POST.get('file_name')
log_file = os.path.join(settings.LOG_BASE_DIR, dir, file_name)
# print("关闭日志%s" % log_file)
cmd = "kill -9 `ps -aux|grep -v grep|grep %s|awk '{print $2}'`" % file_name
print("关闭日志，命令：", cmd)
result = ssh3(ip, cmd)
# print("result", result,type(result))
if not result or result['status'] != 0:
res.code = 500
res.error = "错误，主机: {}，关闭实时日志: {} 失败！".format(ip, log_file)
return HttpResponse(json.dumps(res.__dict__))
else:
res.code = 500
res.error = "非法请求"
return HttpResponse(json.dumps(res.__dict__))
def destroy(self, request, *args, **kwargs):
start_time = time.time()
task_id = kwargs['pk']
logger.info('删除任务id: %s' % task_id)
res = BaseResponse()
Cassandra_obj = Cassandratask()
try:
Cassandra_obj.delete_data(task_id)
except OperationalError as e:
res.code = 1906
res.msg = '数据库连接失败'
logger.debug('数据库连接失败')
except Exception as e:
res.code = 1909
res.msg = '任务删除失败: %s' % task_id
logger.debug('任务%s删除失败:%s' % (task_id, e))
else:
res.data = task_id
res.code = 0
res.msg = '任务删除成功: %s' % task_id
logger.info('任务删除成功: %s' % task_id)
try:
self.redis.delete_redis(task_id)
except ConnectionError as e:
logger.debug('redis连接失败,任务未从缓存中删去: %s' % taskId)
finally:
logger.info('destroy QualityTask----time:%.5fs' %
(time.time() - start_time))
return Response(res.dict, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
"""
用于用户认证相关接口
:param request:
:param args:
:param kwargs:
:return:
"""
print(request.data)
# ret = {"code":100,'data':None}
ret = BaseResponse()
try:
user = request.data.get('user')
pwd = request.data.get('pwd')
obj = models.UserInfo.objects.filter(user=user, pwd=pwd).first()
# obj = models.UserInfo.objects.get(user=user,pwd=pwd)
if not user: # 简单逻辑往上放
ret.code = 400
ret.error = "错误的用户名或密码"
return Response(ret)
token = str(uuid.uuid4())
models.Token.objects.update_or_create(
user=obj, defaults={"token": token}) # defaults字段用于更新
ret.token = token
except Exception as e:
ret.code = 1002
ret.msg = e
# obj = Response('...')
# obj['Access-Control-Allow-Origin'] = "*"
return Response(ret.dict)
def destroy(self, request, *args, **kwargs):
start_time = time.time()
conditionId = kwargs['pk']
logger.info('删除条件数据id: %s' % conditionId)
res = BaseResponse()
Cassandra_obj = CassandraCondition()
try:
Cassandra_obj.delete_data(conditionId)
except OperationalError as e:
res.code = 1906
res.msg = '数据库连接失败'
logger.debug('删除条件时数据库连接失败')
except Exception as e:
res.code = 1909
res.msg = '删除条件数据失败: %s' % conditionId
logger.debug('删除条件数据%s失败：%s' % (conditionId,e))
else:
res.data = conditionId
res.code = 0
res.msg = '删除条件成功: %s' % (conditionId)
logger.info('删除条件成功 :%s' % (conditionId))
try:
self.redis.delete_redis(conditionId)
except ConnectionError as e:
logger.debug('redis连接失败,条件从缓存中删除失败: %s' % conditionId)
finally:
logger.info('destroy Condition----time:%.5fs' % (time.time() - start_time))
return Response(res.dict, status=status.HTTP_200_OK)
def delete(self, request, *args, **kwargs):
"""删除课程"""
res_obj = BaseResponse()
user_id = request.user.id
course_id = request.data.get('course_id')
if not course_id:
res_obj.code = 2003
res_obj.msg = '无效的参数'
logger.warning('delete shopping cart with no course_id.')
return Response(res_obj.dict)
shopping_cart_value = CACHE.get(f'SHOPPING_CART_{user_id}')
if shopping_cart_value:
shopping_cart_list = json.loads(shopping_cart_value)
else:
shopping_cart_list = []
if not shopping_cart_list:
logger.debug('put shopping cart when shopping_cart_list is Null.')
res_obj.code = 2004
res_obj.msg = '无效的参数'
return Response(res_obj.dict)
shopping_cart_num = len(shopping_cart_list)
for i in range(shopping_cart_num):
if shopping_cart_list[i]['id'] == course_id:
shopping_cart_list.pop(i)
res_obj.msg = '更新购物车成功'
CACHE.set(f'SHOPPING_CART_{user_id}', json.dumps(shopping_cart_list))
return Response(res_obj.dict)
else:
res_obj.code = 2005
res_obj.msg = '无效的参数'
logger.warning('delete shopping cart api with invalid course_id.')
return Response(res_obj.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 post(self, request, *args, **kwargs):
res_obj = BaseResponse()
"""加入购物车操作"""
# 1. 获取数据
course_id = request.data.get('course_id')
price_policy_id = request.data.get('price_policy_id')
user_id = request.user.id
# 2. 校验数据的合法性
# 2.1 验证课程id是否合法
course_obj = models.Course.objects.filter(id=course_id).first()
if not course_obj:
res_obj.code = 2001
res_obj.msg = '课程id无效'
return Response(res_obj.dict)
# 2.2 验证价格策略id是否合法
price_obj = course_obj.price_policy.all().filter(id=price_policy_id).first()
if not price_obj:
res_obj.code = 2002
res_obj.msg = '价格策略无效'
return Response(res_obj.dict)
# 3. 获取当前课程的所有价格策略
price_policy_dict = {}
price_policy_queryset = course_obj.price_policy.all()
for item in price_policy_queryset:
price_policy_dict[item.id] = {
'valid_period': item.valid_period,
'valid_period_text': item.get_valid_period_display(),
'selected': True if item.id == price_policy_id else False,
'price': item.price
}
# 4. 获取当前购物车的课程信息
course_info = {
"id": course_id,
"name": course_obj.name,
"course_img": course_obj.course_img,
"relate_price_policy": price_policy_dict,
"default_price": price_obj.price,
"default_price_period": price_obj.valid_period,
"default_price_policy_id": price_obj.pk
}
# 获取缓存中 购物车列表
shopping_cart_info = CACHE.get(f'SHOPPING_CART_{user_id}')
if shopping_cart_info:
shopping_cart_list = json.loads(shopping_cart_info)
else:
shopping_cart_list = []
logger.debug(shopping_cart_list)
print('-' * 120)
shopping_cart_list.append(course_info)
# 5. 存入redis
# 以SHOPPING_CART_{user_id}为key存储当前用户的购物车数据
CACHE.set(f'SHOPPING_CART_{user_id}', json.dumps(shopping_cart_list))
logger.debug(f'set cache for user_id：{user_id}')
res_obj.msg = '加入购物车成功'
return Response(res_obj.dict)
def patch(self,request,*args,**kwargs):
ret = BaseResponse()
try:
# 1. 用户提交要修改的优惠券
course = request.data.get('courseid')
course_id = str(course) if course else course
coupon_id = str(request.data.get('couponid'))
# payment_global_coupon_1
redis_global_coupon_key = settings.PAYMENT_COUPON_KEY %(request.auth.user_id,)
# 修改全站优惠券
if not course_id:
if coupon_id == "0":
# 不使用优惠券,请求数据：{"couponid":0}
self.conn.hset(redis_global_coupon_key,'default_coupon',coupon_id)
ret.data = "修改成功"
return Response(ret.dict)
# 使用优惠券,请求数据：{"couponid":2}
coupon_dict = json.loads(self.conn.hget(redis_global_coupon_key,'coupon').decode('utf-8'))
# 判断用户选择得优惠券是否合法
if coupon_id not in coupon_dict:
ret.code = 1001
ret.error = "全站优惠券不存在"
return Response(ret.dict)
# 选择的优惠券合法
self.conn.hset(redis_global_coupon_key, 'default_coupon', coupon_id)
ret.data = "修改成功"
return Response(ret.dict)
# 修改课程优惠券
# luffy_payment_1_1
redis_payment_key = settings.PAYMENT_KEY % (request.auth.user_id, course_id,)
# 不使用优惠券
if coupon_id == "0":
self.conn.hset(redis_payment_key,'default_coupon',coupon_id)
ret.data = "修改成功"
return Response(ret.dict)
# 使用优惠券
coupon_dict = json.loads(self.conn.hget(redis_payment_key,'coupon').decode('utf-8'))
if coupon_id not in coupon_dict:
ret.code = 1010
ret.error = "课程优惠券不存在"
return Response(ret.dict)
self.conn.hset(redis_payment_key,'default_coupon',coupon_id)
except Exception as e:
ret.code = 1111
ret.error = "修改失败"
return Response(ret.dict)
def create(self, request, *args, **kwargs):
""" 添加购物车 """
reply = BaseResponse()
try:
# 1. 获取用户id
user_pk = request.user.pk
# 2. 获取课程id和对应的价格策略id
course_id = request.data["course_id"]
price_policy_id = request.data["price_policy_id"]
# 3.校验课程数据合法性
course_obj = models.Course.objects.get(pk=course_id)
# 4. 校验课程关联的价格策略
price_policy_list = course_obj.price_policy.all()
# 构建价格策略字典
price_policy_dict = {}
for price_policy in price_policy_list:
price_policy_dict[price_policy.pk] = {
"price": price_policy.price,
"valid_period": price_policy.valid_period,
"valid_period_text":
price_policy.get_valid_period_display()
}
if price_policy_id not in price_policy_dict:
raise PriceDoesNotExist
# 5.redis中存储数据
# 得到redis中存储的key
shopping_car_key = "shopping_car_%s_%s" % (user_pk, course_id)
# 构造value
course_info = {
"name": course_obj.name,
"course_img": course_obj.course_img,
"relate_price_policy": json.dumps(price_policy_dict),
"default_price_policy_id": price_policy_id
}
reply.data = "更新购物车成功" if self.redis.exists(
shopping_car_key) else "加入购物车成功"
self.redis.hmset(shopping_car_key, course_info)
except ObjectDoesNotExist as e:
reply.code = "1002"
reply.error = "课程不存在！！！"
except PriceDoesNotExist as e:
reply.code = "1003"
reply.error = e.error
except Exception as e:
reply.code = "1004"
reply.error = str(e)
return Response(reply.dict)
def post(self, request, *args, **kwargs):
"""
购物车添加一条数据
:param request:
:param args:
:param kwargs:
:return:
"""
results = BaseResponse()
try:
# 1.获取用户提交的 课程ID 和 价格策略ID
course_id = int(
request.data.get('course_id')) # 有可能传来是 str 类型，不管什么类型，都转换成int
policy_id = int(request.data.get('policy_id'))
# 2.获取课程信息
course_obj = models.Course.objects.get(
id=course_id) # 课程对象。 如果取不到或取多个就报错 ObjectDoesNotExist
# 3.获取该课程的所有的价格策略
price_policy_list = course_obj.price_policy.all()
price_policy_dict = {}
for item in price_policy_list:
price_policy_dict[item.id] = {
"period_display": item.get_valid_period_display(),
"period": item.valid_period,
"price": item.price
}
# 4.检测 用户提交的价格策略id 是否存在(合法) 该课程是否有此 价格策略
if policy_id not in price_policy_dict: # 价格策略不合法， 抛出自定义异常
raise PricePolicyInvalid("价格策略不合法")
# 5.将购物信息添加到 redis 中
user_id = request.user.id # 用户认证过后用 user_id = request.user.id 来获取
redis_car_key = "shopping_car_{0}_{1}".format(
user_id, course_id) # redis 中存的key
# redis_car_key = settings.SHOPPING_CART_KEY.format(user_id, course_id) # 可以配置到 settings.py 里面
self.conn.hmset(
redis_car_key, {
"title": course_obj.name,
"img": course_obj.course_img,
"policy": json.dumps(price_policy_dict),
"default_policy": policy_id
})
results.data = "添加成功"
except ObjectDoesNotExist as e:
results.code = 3001
results.error = "课程不存在"
except PricePolicyInvalid as e:
results.code = 2001
results.error = e.error
except Exception as e:
results.code = 1001
results.error = "添加失败"
return Response(results.dict)
def post(self, request, *args, **kwargs):
"""
支付成功后，支付宝回调的notify地址
:param request:
:param args:
:param kwargs:
:return:
"""
ret = BaseResponse()
try:
from urllib.parse import parse_qs
# request.body => 字节类型
# request.body.decode('utf-8') => 字符串类型
"""
{"k1":["v1"],"k2":["v1"]}
k1=[v1]&k2=[v2]
"""
body_str = request._request.body.decode('utf-8')
post_data = parse_qs(body_str)
# {k1:[v1,],k2:[v2,]}
# {k1:v1}
post_dict = {}
for k, v in post_data.items():
post_dict[k] = v[0]
print(post_dict)
"""
{'gmt_create': '2017-11-24 14:53:41', 'charset': 'utf-8', 'gmt_payment': '2017-11-24 14:53:48', 'notify_time': '2017-11-24 14:57:05', 'subject': '充气式韩红', 'sign': 'YwkPI9BObXZyhq4LM8//MixPdsVDcZu4BGPjB0qnq2zQj0SutGVU0guneuONfBoTsj4XUMRlQsPTHvETerjvrudGdsFoA9ZxIp/FsZDNgqn9i20IPaNTXOtQGhy5QUetMO11Lo10lnK15VYhraHkQTohho2R4q2U6xR/N4SB1OovKlUQ5arbiknUxR+3cXmRi090db9aWSq4+wLuqhpVOhnDTY83yKD9Ky8KDC9dQDgh4p0Ut6c+PpD2sbabooJBrDnOHqmE02TIRiipULVrRcAAtB72NBgVBebd4VTtxSZTxGvlnS/VCRbpN8lSr5p1Ou72I2nFhfrCuqmGRILwqw==', 'buyer_id': '2088102174924590', 'invoice_amount': '666.00', 'version': '1.0', 'notify_id': '11aab5323df78d1b3dba3e5aaf7636dkjy', 'fund_bill_list': '[{"amount":"666.00","fundChannel":"ALIPAYACCOUNT"}]', 'notify_type': 'trade_status_sync', 'out_trade_no': 'x21511506412.4733646', 'total_amount': '666.00', 'trade_status': 'TRADE_SUCCESS', 'trade_no': '2017112421001004590200343962', 'auth_app_id': '2016082500309412', 'receipt_amount': '666.00', 'point_amount': '0.00', 'app_id': '2016082500309412', 'buyer_pay_amount': '666.00', 'sign_type': 'RSA2', 'seller_id': '2088102172939262'}
{'stade_status': "trade_success",'order':'x2123123123123'}
"""
sign = post_dict.pop('sign', None)
pay = aliPay()
status = pay.verify(post_dict, sign)
if status:
stade_status = post_dict['stade_status']
out_trade_no = post_dict['out_trade_no'] # 订单号
trade_no = post_dict['trade_no'] # 支付宝流水账号
if status == 'TRADE_SUCCESS':
# 更新订单并写入第三个流水
models.Order.objects.filter(order_number=out_trade_no,
status=1).update(
status=0,
payment_number=trade_no)
ret.code = 1000
except Exception as e:
ret.code = 4000
ret.message = str(e)
return Response(ret)
def get(self, request):
res = BaseResponse()
name = "ShoppingCar_for_userId_%s" % request.user.pk
data = conn.hvals(name)
res.code = 1000
res.data = data
return Response(res.dict)
def delete(self, request, *args, **kwargs):
"""
删除购物车中的数据
:param request:
:param args:
:param kwargs:
:return:
"""
result = BaseResponse()
try:
course_id_list = request.data.get('course_id')
user_id = request.user.id # 用户认证过后用 user_id = request.user.id 来获取
# key_list = []
# for course_id in course_id_list:
# redis_car_key = settings.SHOPPING_CART_KEY.format(user_id, course_id)
# key_list.append(redis_car_key)
key_list = [
settings.SHOPPING_CART_KEY.format(user_id, course_id)
for course_id in course_id_list
] # 同上注释掉的
self.conn.delete(*key_list) # 删除
except Exception as e:
result.code = 1001
result.error = "删除失败"
return Response(result.dict)
def get(self,request, *args, **kwargs):
"""
查看购物车中所有的商品
:param request:
:param args:
:param kwargs:
:return:
"""
ret = BaseResponse()
try:
key_match = settings.SHOPPING_CAR_KEY %(request.auth.user_id,"*")
course_list = []
for key in self.conn.scan_iter(key_match,count=10):
info = {
"title":self.conn.hget(key,'title').decode('utf-8'), # 不用getall的原因是每个字段不同
"img":self.conn.hget(key,'img').decode('utf-8'),
"policy":json.loads(self.conn.hget(key,'policy').decode('utf-8')),
"default_policy":self.conn.hget(key,'default_policy').decode('utf-8')
}
course_list.append(info)
ret.data = course_list
except Exception as e:
ret.code = 1002
ret.error = "获取失败"
return Response(ret.dict)
def list(self, request, *args, **kwargs):
res = BaseResponse()
Cassandra_obj = Cassandratask()
try:
data = Cassandra_obj.list()
except OperationalError as e:
res.code = 1906
res.msg = '数据库连接失败'
logger.debug('数据库连接失败')
return Response(res.dict, status=status.HTTP_200_OK)
except Exception as e:
res.code = 1909
res.msg = '数据获取失败'
logger.debug('数据获取失败:%s' % e)
return Response(res.dict, status=status.HTTP_200_OK)
else:
return Response(data, status=status.HTTP_200_OK)
def delete(self, request):
res = BaseResponse()
course_ids = request.data.get("course_list", "")
print(course_ids)
name = "ShoppingCar_for_userId_%s" % request.user.pk
try:
for course_id in course_ids:
if not Course.objects.filter(id=course_id):
res.code = 1040
res.error = "课程id（%d）不存在" % course_id
return Response(res.dict)
conn.hdel(name, "course_id_%d" % course_id)
res.code = 1000
res.data = {"商品删除成功"}
except Exception as e:
res.code = 1037
res.error = "删除失败,reason:" + str(e)
return Response(res.dict)
def get(self, request):
res = BaseResponse()
name1 = "Settlement_for_userId_%d" % request.user.pk
name2 = "Coupons_for_userId_%d" % request.user.pk
data1 = conn.hvals(name1)
data2 = conn.hgetall(name2)
res.code = 1000
res.data = {"settlement": data1, "coupons": data2}
return Response(res.dict)
def retrieve(self, request, *args, **kwargs):
ret = BaseResponse()
try:
pk = kwargs.get('pk')
obj = CourseDetail.objects.filter(id=pk).first()
ser = CourseDetailViewSetSerializers(instance=obj, many=False)
ret.data = ser.data
except Exception as e:
ret.code = 1001
ret.error = '未获取到资源'
return Response(ret.dict)
def patch(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 = str(request.data.get('policyid'))
# 2. 拼接课程的key
key = settings.SHOPPING_CAR_KEY % (
request.auth.user_id,
course_id,
)
if not self.conn.exists(key):
ret.code = 1002
ret.error = "购物车中不存在此课程"
return Response(ret.dict)
# 3. redis中获取所有的价格策略
policy_dict = json.loads(
str(self.conn.hget(key, 'policy'), encoding='utf-8'))
if policy_id not in policy_dict:
ret.code = 1003
ret.error = "价格策略不合法"
return Response(ret.dict)
# 4. 在购物车中修改该课程的默认价格策略
self.conn.hset(key, 'default_policy', policy_id)
ret.data = "修改成功"
except Exception as e:
ret.code = 1004
ret.error = "修改失败"
return Response(ret.dict)
def create(self, request, *args, **kwargs):
start_time = time.time()
_data = request.data
logger.info('创建规则表数据: %s' %(_data) )
res = BaseResponse()
Cassandra_obj = CassandraRule()
try:
data = self._format_data(_data)
ruleId = str(uuid.uuid1()).split('-')[0]
siteId = _data.get('siteId')
data.update({'rule_id': ruleId, 'site_id':siteId})
if not data['condition'] or not siteId :
raise FieldNullException('条件/站点ID 字段的值不能为空')
else:
Cassandra_obj.create_data(data)
except TypeError as e:
res.code = 1904
res.msg = '数据的key有误'
logger.debug('数据的key有误')
except FieldNullException as e:
res.code = 1905
res.msg = '条件/站点ID字段不能为空'
logger.debug('规则数据%s的条件/站点ID字段不能为空: %s' % ruleId)
except OperationalError as e:
res.code = 1906
res.msg = '数据库连接失败'
logger.debug('数据库连接失败')
except IntegrityError as e:
if e.args[0] == 1062:
res.code = 1907
res.msg = '规则ID重复'
logger.debug('规则ID重复')
except ValueError as e:
res.code = 1908
res.msg = '参数错误：%s' % ruleId
logger.debug('创建规则表数据的参数错误')
except Exception as e:
res.code = 1909
res.msg = '规则表创建失败:%s' % ruleId
logger.debug('规则表%s创建失败:%s' % (ruleId,e))
else:
res.data = ruleId
res.code = 0
res.msg = '规则表创建成功: %s' % ruleId
logger.info('规则表创建成功: %s' % ruleId)
# 将数据存到redis缓存中
attribute = data['attribute']
site_rule_key = '%s_%s_%s' % (siteId,attribute,ruleId)
try:
self.redis.join_redis(site_rule_key, data)
except ConnectionError as e:
logger.debug('redis连接失败,规则未加入到缓存中: %s' % ruleId)
finally:
logger.info('create QualityRule----time:%.5fs' % (time.time() - start_time))
return Response(res.dict, status=status.HTTP_200_OK)
def post(self, request):
res = BaseResponse()
user_id = request.user.pk
course_id = request.data.get("course_id", "")
course_obj = Course.objects.filter(pk=course_id).first()
if not course_obj:
res.code = 1040
res.error = "课程id不存在"
return Response(res.dict)
else:
name = "ShoppingCar_for_userId_%s" % user_id
Value = {
"course_id":
course_id,
"course_img":
str(course_obj.course_img),
"PricePolicy": [{
"id":
police_obj.id,
"is_promotion":
police_obj.is_promotion,
"promotion_price":
police_obj.promotion_price,
"price":
police_obj.price,
"valid_period":
"永久有效" if police_obj.is_valid_forever else
police_obj.get_valid_period_display()
} for police_obj in course_obj.price_policy.all()]
}
try:
conn.hmset(name, {"course_id_%s" % course_id: Value})
res.code = 1000
res.data = {"加入购物车成功"}
except Exception as e:
res.code = 1035
res.error = "加入购物车失败,reason:" + str(e)
return Response(res.dict)
def create(self, request, *args, **kwargs):
task_start_time = time.time()
_data = request.data
logger.info('质检任务: %s' % (_data))
res = BaseResponse()
Cassandra_obj = Cassandratask()
try:
data = self._format_data(_data)
taskId = str(uuid.uuid1()).split('-')[0]
data.update({'task_id': taskId})
if not data['start_time'] and not data[
'transaction_id'] or not data['site_id']:
raise FieldNullException('时间/站点ID 字段的值不能为空')
else:
Cassandra_obj.create_data(data)
except TypeError as e:
res.code = 1904
res.msg = '数据的key有误'
logger.debug('数据的key有误')
except FieldNullException as e:
res.code = 1905
res.msg = '时间/站点ID 字段不能为空'
logger.debug('任务%s的时间/站点ID 字段字段不能为空: %s' % taskId)
except OperationalError as e:
res.code = 1906
res.msg = '数据库连接失败'
logger.debug('数据库连接失败')
except IntegrityError as e:
if e.args[0] == 1062:
res.code = 1907
res.msg = '任务ID重复'
logger.debug('任务ID重复')
except ValueError as e:
res.code = 1908
res.msg = '参数错误'
logger.debug('创建任务数据的参数错误')
except Exception as e:
res.code = 1909
res.msg = '任务创建失败:%s' % taskId
logger.debug('%s任务创建失败:%s' % (taskId, e))
else:
res.data = taskId
res.code = 0
res.msg = '任务创建成功: %s' % taskId
logger.info('任务创建成功: %s' % taskId)
try:
self.redis.join_redis(taskId, data)
except ConnectionError as e:
logger.debug('redis连接失败,任务未加入到缓存中: %s' % taskId)
finally:
logger.info('create QualityTask----time:%.5fs' %
(time.time() - task_start_time))
return Response(res.dict, status=status.HTTP_200_OK)
def get_dir_json(request):
"""
目录列表json，供前端ajax调用
:param request:
:return:
"""
res = BaseResponse() # 初始化返回值
if request.method == "POST":
ip = request.POST.get('ip')
dir = request.POST.get('dir')
key = request.POST.get('key')
if key:
log_list = get_search_log_list(ip, dir,key)
# 分页a标签的herf前缀
herf_prefix = "?ip={}&dir={}&search={}".format(ip, dir, key)
else:
log_list = get_log_list(ip, dir)
# 分页a标签的herf前缀
herf_prefix = "?ip={}&dir={}".format(ip, dir)
# print("log_list", log_list)
if log_list is False:
res.code = 500
res.error = "获取目录列表失败"
elif log_list == []:
res.code = 500
res.error = "目录列表为空"
elif log_list == {}:
res.code = 500
res.error = "搜索结果为空"
else:
res.data = log_list
res.url = "/view_dir/%s" % (herf_prefix)
else:
res.code = 500
res.error = "非法请求"
return HttpResponse(json.dumps(res.__dict__))
def login(self, request, *args, **kwargs):
"""用户登陆认证"""
response = BaseResponse()
try:
username = request.data.get('username')
pwd = request.data.get('password')
# 验证用户和密码
user = authenticate(username=username, password=pwd)
# obj = User.objects.filter(username=user).first()
# obj = User.objects.get(username=user)
# uclass = UserInfo.objects.get(user=obj)
# print(type(uclass)) 输出结果如下，所以此步 定义为uclass
# <class 'rbac.models.UserInfo'>
if not user:
# 判断查询结果
response.code = 1002
response.error = '用户名或密码错误'
else:
login(request, user)
uclass = UserInfo.objects.get(user=user)
obj = UserInfo.objects.filter(user_id=uclass.user_id).first()
# 查询当前用户的所有角色
role = obj.roles.all()
permission_list = []
for i in role:
# 查看当前用户所有角色的所有权限
per = i.permissions.all()
for j in per:
permission_list.append(j.url)
response.code = 1000
# 用户所具备的权限列表写入session
request.session['url'] = permission_list
init_permission(request, obj)
except Exception as e:
response.code = 10005
response.error = '操作异常'
return Response(response.dict)
def get(self, request, *args, **kwargs):
ret = BaseResponse()
try:
# payment_1_*
redis_payment_key = settings.PAYMENT_KEY % (
request.auth.user_id,
"*",
)
# payment_coupon_1
redis_global_coupon_key = settings.PAYMENT_COUPON_KEY % (
request.auth.user_id, )
# 1. 获取绑定课程信息
course_list = []
for key in self.conn.scan_iter(redis_payment_key):
print(key)
info = {}
data = self.conn.hgetall(key)
print(data)
for k, v in data.items():
kk = k.decode('utf-8')
if kk == "coupon":
info[kk] = json.loads(v.decode('utf-8'))
else:
info[kk] = v.decode('utf-8')
course_list.append(info)
# 2.全站优惠券
global_coupon_dict = {
'coupon':
json.loads(
self.conn.hget(redis_global_coupon_key,
'coupon').decode('utf-8')),
'default_coupon':
self.conn.hget(redis_global_coupon_key,
'default_coupon').decode('utf-8')
}
ret.data = {
"course_list": course_list,
"global_coupon_dict": global_coupon_dict
}
except Exception as e:
ret.code = 1001
ret.error = "获取失败"
return Response(ret.dict)
def post(self, request):
reply = BaseResponse()
try:
name = request.data.get("username")
pwd = request.data.get("pwd")
user_obj = models.Userinfo.objects.filter(name=name,
pwd=pwd).first()
if user_obj:
random_str = uuid.uuid4()
models.UserToken.objects.update_or_create(
user=user_obj, defaults={"token": random_str})
reply.user = user_obj.name
reply.token = random_str
else:
reply.code = 1001
reply.error = "用户名或者密码错误"
except Exception as e:
reply.code = 1002
reply.error = str(e)
return Response(reply.dict)
def put(self, request, *args, **kwargs):
"""更新课程的价格策略"""
res_obj = BaseResponse()
# 1. 获取课程的id和价格策略的id
user_id = request.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:
res_obj.code = 2003
res_obj.msg = '无效的参数'
logger.debug('put shopping cart with no course_id or price_policy_id.')
return Response(res_obj.dict)
shopping_cart_value = CACHE.get(f'SHOPPING_CART_{user_id}')
if shopping_cart_value:
shopping_cart_list = json.loads(shopping_cart_value)
else:
shopping_cart_list = []
if not shopping_cart_list:
logger.debug('put shopping cart when shopping_cart_list is Null.')
res_obj.code = 2004
res_obj.msg = '无效的参数'
return Response(res_obj.dict)
for item in shopping_cart_list:
if course_id == item['id'] and str(price_policy_id) in item['relate_price_policy']:
price_policy_obj = models.PricePolicy.objects.filter(id=price_policy_id).first()
item['default_price_policy_id'] = price_policy_id
item['default_price_period'] = price_policy_obj.valid_period
item['default_price'] = price_policy_obj.price
res_obj.msg = '修改购物车成功'
CACHE.set(f'SHOPPING_CART_{user_id}', json.dumps(shopping_cart_list))
return Response(res_obj.dict)
else:
res_obj.code = 2005
res_obj.msg = '无效的参数'
logger.warning('put shopping cart api with invalid course_id or price_policy_id.')
return Response(res_obj.dict)
def patch(self, request, *args, **kwargs):
"""
更新价格策略
:param request:
:param args:
:param kwargs:
:return:
"""
results = BaseResponse()
try:
course_id = request.data.get('course_id')
user_id = request.user.id # 用户认证过后用 user_id = request.user.id 来获取
policy_id = str(request.data.get('policy_id'))
redis_car_key = settings.SHOPPING_CART_KEY.format(
user_id, course_id)
if not self.conn.exists(redis_car_key): # 判断 key 是否存在。 不存在
results.code = 2001
results.error = "购物车不存在此课程"
return Response(results.dict)
# 课程存在，判断价格策略是否存在
policy_dict = json.loads(
str(self.conn.hget(redis_car_key, 'policy'),
encoding='utf-8')) # 所有的价格策略
if policy_id not in policy_dict: # 价格策略不存在
raise PricePolicyInvalid("该课程不存在此价格策略")
# 修改 默认价格策略
self.conn.hset(redis_car_key, "default_policy", policy_id)
results.data = "修改成功"
except PricePolicyInvalid as e:
results.code = 2002
results.error = e.error
except Exception as e:
results.code = 1001
results.error = "更新失败"
return Response(results.dict)
def create(self, request, *args, **kwargs):
start_time = time.time()
_data = request.data
logging.info('创建条件数据：%s'% (_data))
res = BaseResponse()
Cassandra_obj = CassandraCondition()
try:
data = self._format_data(_data)
conditionId = str(uuid.uuid1()).split('-')[0]
data.update({'condition_id': conditionId})
if not data['operator']:
raise FieldNullException('算子字段的值不能为空')
else:
Cassandra_obj.create_data(data)
except TypeError as e:
res.code = 1904
res.msg = '数据的key有误'
logger.debug('数据的key有误')
except FieldNullException as e:
res.code = 1905
res.msg = '算子字段不能为空'
logger.debug('条件数据%s的算子字段不能为空: %s' % conditionId)
except OperationalError as e:
res.code = 1906
res.msg = '数据库连接失败'
logger.debug('数据库连接失败')
except IntegrityError as e:
if e.args[0] == 1062:
res.code = 1907
res.msg = 'ID重复'
logger.debug('ID重复')
except ValueError as e:
res.code = 1908
res.msg = '参数错误: %s' % conditionId
logger.debug('创建条件数据的参数错误: %s' % conditionId)
except Exception as e:
res.code = 1909
res.msg = '条件数据创建失败: %s' % conditionId
logger.debug('条件%s数据数据创建失败: %s' % (conditionId,e))
else:
res.data = conditionId
res.code = 0
res.msg = '%s: 条件数据创建成功' % conditionId
logger.info('条件数据创建成功: %s' % conditionId)
# 将数据存到redis缓存中
try:
self.redis.join_redis(conditionId, data)
except ConnectionError as e:
logger.debug('redis连接失败,数据未加入到缓存中: %s' % conditionId)
finally:
logger.info('create Condition----time:%.5fs' % (time.time() - start_time))
return Response(res.dict, status=status.HTTP_200_OK)
