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)