def list(self, request, *args, **kwargs):
ret = BaseResponse()
shopping_car_course_list = []
# pattern = "shopping_car_%s_*" % (USER_ID,)
pattern = settings.LUFFY_SHOPPING_CAR % (
1,
'*',
)
user_key_list = CONN.keys(pattern)
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
return Response(ret.dict)
def destroy(self, request, *args, **kwargs):
"""
删除购物车中的某个课程
:param request:
:param args:
:param kwargs:
:return:
"""
response = BaseResponse()
try:
# courseid = request.GET.get('courseid')
courseid = request.data.get('courseid')
print(courseid)
# key = "shopping_car_%s_%s" % (USER_ID,courseid)
key = "shopping_car_%s_%s" % (
USER_ID,
courseid,
)
CONN.delete(key)
response.data = '删除成功'
except Exception as e:
response.code = 10006
response.error = '删除失败'
return Response(response.dict)
def update(self, request, *args, **kwargs):
ret = BaseResponse()
course_id = request.data.get('course_id')
key = settings.LUFFY_SHOPPING_CAR % (1, course_id)
CONN.delete(key)
ret.data = '删除成功'
return Response(ret.dict)
def get(self, request, *args, **kwargs):
'''
获取所有专题课信息
:param request:
:param args:
:param kwargs:
:return:
'''
# ret = {'code':1000,'data':None,'error':None}
# 将字典封装成一个类，用ret.属性名去调用，简化代码
ret = BaseResponse()
try:
queryset = models.Course.objects.all()
# 分页
page = PageNumberPagination()
course_list = page.paginate_queryset(queryset, request, self)
# 分页之后的结果序列化
# ser = CourseSerializer(course_list,many=True)
ser = CourseModelSerializer(course_list, many=True)
# ret['data'] = ser.data
ret.data = ser.data
except Exception as e:
# ret['code'] = 500
ret.code = 500
# ret['error'] = '获取数据失败'
ret.error = '获取数据失败'
return Response(ret.dict)
def list(self, request, *args, **kwargs):
response = BaseResponse()
response.data = {}
# account_info
account_info_key_list = self.redis.keys("account_%s_*" %
(request.user.pk))
for account_info_key in account_info_key_list:
account_info = self.redis.hgetall(account_info_key)
for key, val in account_info.items():
if key.decode('utf8') == 'course_coupon':
response.data[account_info_key.decode('utf-8')] = {
key.decode('utf8'): json.loads(val.decode('utf8'))
}
else:
response.data[account_info_key.decode('utf-8')] = {
key.decode('utf8'): val.decode('utf8')
}
# global_coupon
global_coupon = self.redis.hgetall("coupon_global_%s" %
request.user.pk)
new_global_coupon = {}
for key, val in global_coupon.items():
new_global_coupon[key.decode('utf8')] = val.decode('utf-8')
response.data["global_coupon"] = new_global_coupon
return Response(response.dict)
def list(self, request, *args, **kwargs):
'''
获取购物车详情
:param
:param args:
:param kwargs:
:return:包含状态码，数据和错误信息的字典
'''
ret = BaseResponse()
try:
shopping_car_course_list = []
pattern = settings.LUFFYCITY_SHOPPING_CAR % (USER_ID, "*")
user_key_list = CONN.keys(pattern)
for key in user_key_list:
temp = {
"id":
CONN.hget(key, "id").decode("utf8"),
"name":
CONN.hget(key, "name").decode("utf8"),
"img":
CONN.hget(key, "img").decode("utf8"),
"default_price_id":
CONN.hget(key, 'default_price_id').decode('utf-8'),
"price_policy_dict":
json.loads(
CONN.hget(key, "price_policy_dict").decode("utf8"))
}
shopping_car_course_list.append(temp)
ret.data = shopping_car_course_list
except Exception as e:
print(e)
ret.code = 500
ret.error = "获取数据失败"
return Response(ret.dict)
def get(self,request,*args,**kwargs):
#response = {'code':1000,'data':None,'error':None}
ret = BaseResponse()
try:
# 从数据库获取数据
queryset = models.Course.objects.all()
print(queryset)
# 分页
page = PageNumberPagination()
course_list = page.paginate_queryset(queryset,request,self)
print(course_list)
# 分页之后的结果执行序列化
ser = CourseSerializer(instance=course_list,many=True)
print(ser.data)
# response["data"] = ser.data
ret.data = ser.data
print("aaaaa",ret.dict)
except Exception as e:
ret.code = 500
ret.error = '获取数据失败'
return Response(ret.dict)
def get(self, request, version):
response = BaseResponse()
try:
# print(version)
# print(request.version)
# print(request.query_params)
# course_list = Course.objects.all().values('id', 'name')
# return HttpResponse(json.dumps(list(course_list), ensure_ascii=False))
# list(QuerySet)-->list
# JsonResponse non-dict safe=False
# queryset = Course.objects.all().values()
# return JsonResponse(list(queryset), safe=False)
if request.query_params.get('a'):
# 专题课
queryset = Course.objects.filter(degree_course__isnull=True)
else:
# 学位课模块
queryset = Course.objects.all()
# 分页
# p = PageNumberPagination()
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, *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):
print(key)
info = {
"title":self.conn.hget(key,'title').decode('utf-8'),
"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 put(self):
self.parser.parse_args()
orgin_data = request.json
nid = orgin_data.pop("nid")
if nid == "":
return api_abort(errcode=4012)
# 站点名、路径不支持修改
orgin_data.pop("ftp_user", "")
orgin_data.pop("ftp_path", "")
ftp_obj = Ftp.get(nid)
if ftp_obj:
if orgin_data:
self.ftpop.update_ftp(status=orgin_data.get("status"),
ftp_user=ftp_obj.ftp_user,
ftp_passwd=orgin_data.get("ftp_passwd"))
Ftp.update(nid, orgin_data)
ftp_dict = ftp_obj.to_json()
res = BaseResponse()
res.data = ftp_dict
return res.dict
else:
# 未传入修改的值
return api_abort(errcode=4019)
else:
# 记录不存在
return api_abort(errcode=4018)
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 get(self, request, *args, **kwargs):
"""获取结算中心数据"""
ret = BaseResponse()
user_id = request.user.id
key_list = self.conn.keys(settings.PAYMENT_KEY % (user_id, '*'))
course_list = []
for key in key_list:
info = {}
data = self.conn.hgetall(key)
for k, v in data.items():
kk = k.decode('utf8')
if kk == 'coupon':
v = json.loads(v.decode('utf8'))
else:
v = v.decode('utf8')
info[kk] = v
course_list.append(info)
pay_global_key = settings.PAYGLOBAL_KEY % user_id
# global_coupon的值直接使用hgetall(key) 会报错，因为json序列化的时候key必须是str，不能使bytes
ret.data = {
'course_list': course_list,
'global_coupon': {
'coupon': json.loads(self.conn.hget(pay_global_key, 'coupon').decode('utf-8')),
'default_coupon': self.conn.hget(pay_global_key, 'default_coupon').decode('utf-8')
}
}
return Response(ret.__dict__)
def get(self, request, *args, pk, **kwargs):
#第一阶段
# course = models.Course.objects.filter(id = pk).first()
# print(course) #对象，也可以直接用get取
# ser = CourseSerializer(course) #只有单个对象
# return Response(ser.data)
# 第二阶段
# ret = BaseResponse()
# try:
# course_obj = models.Course.objects.filter(id=pk).first()
# ser = CourseSerializer(course_obj)
# ret.data = ser.data
# except Exception:
# ret.data = 500
# ret.error = "获取数据失败"
# return Response(ret.dict)
#第三阶段
ret = BaseResponse()
try:
course_obj = models.Course.objects.get(id=pk)
print(course_obj)
ser = CourseModelSerializer(course_obj)
print(ser)
ret.data = ser.data
except Exception:
ret.code = 500
ret.error = "获取数据失败"
return Response(ret.data)
def get(self, request, *args, **kwargs):
ret = BaseResponse()
try:
# 从数据库获取数据
# 防止出现UnorderedObjectListWarning: Pagination may yield...
queryset = models.DegreeCourse.objects.all()
print(queryset)
# 分页
page = PageNumberPagination()
course_list = page.paginate_queryset(queryset, request, self)
# 分页之后的结果执行序列化
ser = DegreeCourseTeachersModelSerializer(instance=course_list, many=True)
print(ser.data)
ret.data = ser.data
except Exception as e:
print(e)
ret.code = 500
ret.error = '获取数据失败'
return Response(ret.dict)
def get(self, request, *args, **kwargs):
res = BaseResponse()
order_list = Order.objects.filter(
account=request.user).order_by("-date")
data = []
for order in order_list:
data.append({
"order_number":
order.order_number,
"date":
order.date.strftime("%Y-%m-%d %H:%M:%S"),
"status":
order.get_status_display(),
"actual_amount":
order.actual_amount,
"orderdetail_list": [{
"original_price":
obj.original_price,
"price":
obj.price,
"course_name":
obj.content_object.name,
"valid_period_display":
obj.valid_period_display,
} for obj in order.orderdetail_set.all()]
})
res.data = data
return Response(res.dict)
def post(self):
rets = self.ftpop.check()
if rets:
api_abort(httpcode=400, errcode=4025, key=rets)
self.parser.parse_args()
orgin_data = request.json
ftp_user = orgin_data.get("ftp_user")
if ftp_user == "":
return api_abort(errcode=4012)
orgin_data["ftp_passwd"] = orgin_data.get(
"ftp_passwd") or getRandomString()
orgin_data["ftp_path"] = orgin_data.get(
"ftp_path") or f'{www_path}/{ftp_user}'
orgin_data["note"] = orgin_data.get("note") or ftp_user
parms = {"ftp_user": ftp_user}
check(Ftp, extra=parms, obj_path=orgin_data["ftp_path"])
create_dict = {
"ftp_user": ftp_user,
"ftp_passwd": orgin_data.get("ftp_passwd"),
"ftp_path": orgin_data.get("ftp_path")
}
# 创建FTP站点
self.ftpop.create_ftp(**create_dict)
ftpobj = Ftp(**orgin_data)
ftpobj.add()
res = BaseResponse()
res.data = ftpobj.to_json()
return res.dict
def get(self, request):
res = BaseResponse()
try:
# 1 取到user_id
user_id = request.user.id
# 2 拼接购物车的key
shopping_car_key = settings.SHOPPING_CAR_KEY % (user_id, "*")
print("shopping_car_key", shopping_car_key)
# shopping_car_1_*
# shopping_car_1_asdgnlaksdj
# 3 去redis读取该用户的所有加入购物车的课程
# 3.1 先去模糊匹配出所有符合要求的key
all_keys = REDIS_CONN.keys(shopping_car_key)
print("all_keys", all_keys)
# 3.2 循环所有的keys 得到每个可以
shopping_car_list = []
for key in all_keys:
print("key", key)
course_info = json.loads(REDIS_CONN.get(key))
shopping_car_list.append(course_info)
res.data = {
"shopping_car_list": shopping_car_list,
"total": len(shopping_car_list)
}
except Exception as e:
res.code = 1033
res.error = "获取购物车失败"
print("res.dict", res.dict)
return Response(res.dict)
def post(self):
rets = self.mysqlop.check()
if rets:
api_abort(httpcode=400, errcode=4025, key=rets)
self.parser.parse_args()
orgin_data = request.json
mysql_user = orgin_data.get("mysql_user")
if mysql_user == "":
return api_abort(errcode=4012)
orgin_data["mysql_name"] = orgin_data.get("mysql_name") or mysql_user
orgin_data["mysql_passwd"] = orgin_data.get("mysql_passwd") or getRandomString()
orgin_data["accept"] = orgin_data.get("accept") or "localhost"
orgin_data["note"] = orgin_data.get("note") or mysql_user
accept = orgin_data.get("accept")
extra = {"mysql_user": mysql_user}
check(Mysql, extra=extra, accept=accept)
extra = {"mysql_name": orgin_data.get("mysql_name")}
check(Mysql, extra=extra)
create_dict = {
"mysql_user": mysql_user,
"mysql_passwd": orgin_data.get("mysql_passwd"),
"mysql_name": orgin_data.get("mysql_name"),
"accept": accept
}
# 创建mysql数据库
result = self.mysqlop.create_mysql(**create_dict)
mysqlobj = Mysql(**orgin_data)
mysqlobj.add()
res = BaseResponse()
res.errmsg = result
res.data = mysqlobj.to_json()
return res.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 destroy(self, request, *args, **kwargs):
'''
删除购物车中的物品
:param request:
:param args:
:param kwargs:
:return:
'''
response = BaseResponse()
try:
courseid = request.GET.get('courseid')
key = settings.LUFFY_SHOPPING_CAR % (
USER_ID,
courseid,
)
CONN.delete(key)
request.datd = '删除成功'
except Exception as e:
response.code = 104
response.error = '删除失败'
return Response(response.dict)
def get(self, request, *args, **kwargs):
res = BaseResponse()
try:
# 1 取到user_id
user_id = request.user.id
# 2 拼接购物车的key
account_key = settings.ACCOUNT_KEY % (user_id, "*")
# shopping_car_1_*
# shopping_car_1_asdgnlaksdj
# 3 去redis读取该用户的所有加入购物车的课程
# 3.1 先去模糊匹配出所有符合要求的key
all_keys = REDIS_CONN.scan_iter(account_key)
# 3.2 循环所有的keys 得到每个可以
account_course_list = []
for key in all_keys:
account_course = json.loads(REDIS_CONN.get(key))
account_course_list.append(account_course)
global_coupons = json.loads(
REDIS_CONN.get("global_coupon_%s" % request.user.pk))
total_price = REDIS_CONN.get("total_price")
res.data = {
"account_course_list": account_course_list,
"total": len(account_course_list),
"global_coupons": global_coupons,
"total_price": total_price
}
except Exception as e:
res.code = 1033
res.error = "获取购物车失败"
return Response(res.dict)
def list(self, request, *args, **kwargs):
response = BaseResponse()
try:
shopping_car_key = settings.SHOPPING_CAR_KEY % (request.user.pk,
'*')
shopping_car_list = redis.keys(shopping_car_key)
# print('hahahah',shopping_car_list)
shopping_car_course_list = []
for key in shopping_car_list:
tem = {
# "id": redis.hget(key, 'id'),
"name":
redis.hget(key, 'name').decode('utf-8'),
'course_img':
redis.hget(key, 'course_img').decode('utf-8'),
'price_policy_dict':
json.loads(
redis.hget(key, 'price_policy_dict').decode('utf-8')),
"default_price_policy_id":
redis.hget(key, "default_price_policy_id").decode('utf-8')
}
shopping_car_course_list.append(tem)
response.data = shopping_car_course_list
except Exception as e:
response.code = 1005
response.error = '数据调取失败'
print(response.dict)
return Response(response.dict)
def put(self):
self.parser.parse_args()
orgin_data = request.json
nid = orgin_data.pop("nid")
if nid == "":
return api_abort(errcode=4012)
mysql_obj = Mysql.get(nid)
if mysql_obj:
if orgin_data:
accept = orgin_data.get("accept")
check(Mysql, accept=accept)
update_dict = {
"mysql_user": mysql_obj.mysql_user,
"old_passwd": mysql_obj.mysql_passwd,
"mysql_passwd": orgin_data.get("mysql_passwd"),
"mysql_name": mysql_obj.mysql_name,
"accept": accept,
"old_accept": mysql_obj.accept
}
# 更新数据库
result = self.mysqlop.update_mysql(**update_dict)
Mysql.update(nid, orgin_data)
ftp_dict = mysql_obj.to_json()
res = BaseResponse()
res.data = ftp_dict
res.errmsg = result
return res.dict
else:
# 未传入修改的值
return api_abort(errcode=4019)
else:
# 记录不存在
return api_abort(errcode=4018)
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 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 destroy(self, request, *args, **kwargs):
"""
删除购物车中的某个课程
:param request:
:param args:
:param kwargs:
:return:
"""
response = BaseResponse()
try:
#首先得到一个课程id
course_id = request.GET.get('course_id')
# key = "shopping_car_%s_%s" % (USER_ID,courseid)
key = settings.LUFFY_SHOPPING_CAR % (
USER_ID,
course_id,
)
CONN.delete(key)
# 在Redis中将带有这个课程id的hash删除
response.data = '删除成功'
except Exception as e:
response.code = 10006
response.error = '删除失败'
return Response(response.dict)
def get(self):
info = request.args.get("info")
data = {}
if info == "loadavg":
loadavg = os.getloadavg()
data['one'] = float(loadavg[0])
data['five'] = float(loadavg[1])
data['fifteen'] = float(loadavg[2])
elif info == "sysinfo":
data['cputype'] = execShell(
"cat /proc/cpuinfo |grep 'model name'").split(':')[-1].strip()
data['cpunum'] = psutil.cpu_count()
meminfo = psutil.virtual_memory()
data['memtotal'] = f"{int(meminfo.total / 1024 / 1024)} MB"
data['memfree'] = f"{int(meminfo.free / 1024 / 1024)} MB"
data['mempercent'] = f"{meminfo.percent}%"
elif info == "diskinfo":
dainfo = psutil.disk_usage('/')
data['datotal'] = f"{int(dainfo.total / 1024 / 1024 / 1024)}G"
data['dafree'] = f"{int(dainfo.free / 1024 / 1024 / 1024)}G"
data['dapercent'] = f"{dainfo.percent}%"
elif info == "netinfo":
def get_key():
key_info = psutil.net_io_counters(pernic=True).keys() # 获取网卡名称
recv = {}
sent = {}
for key in key_info:
recv.setdefault(
key,
psutil.net_io_counters(
pernic=True).get(key).bytes_recv) # 各网卡接收的字节数
sent.setdefault(
key,
psutil.net_io_counters(
pernic=True).get(key).bytes_sent) # 各网卡发送的字节数
return key_info, recv, sent
key_info, old_recv, old_sent = get_key()
time.sleep(1)
key_info, now_recv, now_sent = get_key()
net_in = {}
net_out = {}
for key in key_info:
net_in.setdefault(
key,
f"{format((now_recv.get(key) - old_recv.get(key)) / 1024, '0.2f')} Kb/s"
) # 每秒接收速率
net_out.setdefault(
key,
f"{format((now_sent.get(key) - old_sent.get(key)) / 1024, '0.2f')} Kb/s"
) # 每秒发送速率
data['net_in'] = net_in
data['net_out'] = net_out
res = BaseResponse()
res.data = data
return res.dict
def get(self, request, *args, **kwargs):
ret = BaseResponse()
try:
courses_list = models.Course.objects.filter(
degree_course__isnull=False).values('name')
ret.data = courses_list
except Exception as e:
ret.code = 500
ret.error = '获取数据失败'
return Response(ret.dict)
def get(self, request, *args, **kwargs):
ret = BaseResponse()
try:
course_list = models.Course.objects.get(id=1)
ser = CourseOutlineSerializer(course_list)
ret.data = ser.data
except Exception as e:
ret.code = 500
ret.error = "获取数据失败"
return Response(ret.dict)
