def post(self, request, category_id):
"""记录分类商品访问量"""
try:
category = models.GoodsCategory.objects.get(id=category_id)
except models.GoodsCategory.DoesNotExist:
return http.HttpResponseForbidden('缺少必传参数')
# 获取今天的日期
t = timezone.localtime()
today_str = '%d-%02d-%02d' % (t.year, t.month, t.day)
today_date = datetime.datetime.strptime(today_str, '%Y-%m-%d')
try:
# 查询今天该类别的商品的访问量
counts_data = category.goodsvisitcount_set.get(date=today_date)
except models.GoodsVisitCount.DoesNotExist:
# 如果该类别的商品在今天没有过访问记录，就新建一个访问记录
counts_data = models.GoodsVisitCount()
try:
counts_data.category = category
counts_data.count += 1
counts_data.save()
except Exception as e:
logger.error(e)
return http.HttpResponseServerError('服务器异常')
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': 'OK'})
def setex(self, key, time, value):
# setting expired
try:
return self.__redis.setex(key, time, value)
except Exception as e:
logger.error("redis setex:%s failed!" % e)
return ""
def _daemonize(self):
try:
pid = os.fork() # 第一次fork，生成子进程，脱离父进程
if pid > 0:
sys.exit(0) # 退出主进程
except OSError as e:
logger.error('fork #1 failed: %d (%s)\n' % (e.errno, e.strerror))
sys.exit(1)
os.chdir("/") # 修改工作目录
os.setsid() # 设置新的会话连接
os.umask(0) # 重新设置文件创建权限
try:
pid = os.fork() # 第二次fork，禁止进程打开终端
if pid > 0:
sys.exit(0)
except OSError as e:
logger.error('fork #2 failed: %d (%s)\n' % (e.errno, e.strerror))
sys.exit(1)
# 重定向文件描述符
sys.stdout.flush()
sys.stderr.flush()
si = open(self.stdin, 'r')
so = open(self.stdout, 'a+')
se = open(self.stderr, 'a+')
os.dup2(si.fileno(), sys.stdin.fileno())
os.dup2(so.fileno(), sys.stdout.fileno())
os.dup2(se.fileno(), sys.stderr.fileno())
# 注册退出函数，根据文件pid判断是否存在进程
atexit.register(self.delpid)
pid = str(os.getpid())
open(self.pidfile, 'w+').write('%s\n' % pid)
def collect(self):
try:
power_request = requests.get(f"http://{url}/{pv_path}",
timeout=timeout).json()
self.__stored_data['power_request'] = power_request
except Exception:
logger.error("Exception during PVs' data request")
power_request = self.__stored_data.get('power_request', {})
power_data, timestamp = self.get_data_and_timestamp(power_request)
site = power_data.get('Site', {})
inverters = power_data.get('Inverters', {})
for id_, inverter in inverters.items():
yield self.__inverter_output(id_, inverter, timestamp, prefix)
yield self.__overall_pvs(site, timestamp, prefix)
yield self.__overall_grid(site, timestamp, prefix)
yield self.__overall_accumulator(site, timestamp, prefix)
yield self.__E_Year(site, timestamp, prefix)
yield self.__E_Day(site, timestamp, prefix)
try:
sensors_request = requests.get(f"http://{url}/{sensors_path}",
timeout=timeout).json()
self.__stored_data['sensors_request'] = sensors_request
except Exception:
logger.error("Exception during sensors' data request")
sensors_request = self.__stored_data.get('sensors_request', {})
sensor_data, timestamp = self.get_data_and_timestamp(sensors_request)
yield self.__temperature_top(sensor_data, timestamp, prefix)
yield self.__temperature_bottom(sensor_data, timestamp, prefix)
yield self.__watts_per_sqm(sensor_data, timestamp, prefix)
yield self.__wind_speed(sensor_data, timestamp, prefix)
def stop(self):
# 从pid文件中获取pid
try:
pf = open(self.pidfile, 'r')
pid = int(pf.read().strip())
pf.close()
except IOError:
pid = None
if not pid: # 重启不报错
message = 'pidfile %s does not exist. Daemon not running!\n'
logger.error(message % self.pidfile)
return
# 杀死进程
try:
while 1:
os.kill(pid, SIGTERM)
time.sleep(0.1)
except OSError as err:
err = str(err)
if err.find('No such process') > 0:
if os.path.exists(self.pidfile):
os.remove(self.pidfile)
else:
sys.exit(str(err))
def post(self, request):
old_password = request.POST.get('old_password')
new_password = request.POST.get('new_password')
new_password2 = request.POST.get('new_password2')
# if not all([old_password, new_password, new_password2]):
# return http.HttpResponseForbidden('缺少必要参数')
try:
request.user.check_password(old_password)
except Exception as e:
logger.error(e)
return render(request, 'user_center_pass.html', {'origin_pwd_errmsg': '原始密码错误'})
if not re.match(r'^[0-9A-Za-z]{8,20}$', new_password2):
return http.HttpResponseForbidden('密码最少8位，最长20位')
if new_password2 != new_password:
return http.HttpResponseForbidden('两次输入的密码不一致')
try:
request.user.set_password(new_password)
request.user.save()
except Exception as e:
logger.error(e)
return render(request, 'user_center_pass.html', {'change_pwd_errmsg': '修改密码失败'})
logout(request)
response = redirect(reverse('users:login'))
response.delete_cookie('username')
return response
def insert_data(data, url):
try:
conn = pymysql.connect(url,
user=rds_user_name,
passwd=rds_password,
db=db_name,
connect_timeout=5)
rows = []
for entry in data:
row = ()
values = []
for attribute, value in entry.items():
values.append(value)
row = tuple(values)
rows.append(row)
cursor = conn.cursor()
query = "INSERT INTO airquality (date, time,co, tin_oxide, metanic_hydro, benzene_conc, titania, nox," \
"tungsten_oxide_nox,average_no2, tungsten_oxide_no2, indium_oxide, temp, relative_humidity," \
"absolute_humidity) VALUES " + ",".join(
"(%s, %s, %s,%s, %s, %s,%s, %s, %s,%s, %s, %s,%s, %s, %s)" for _ in rows)
flattened_values = [item for sublist in rows for item in sublist]
cursor.execute(query, flattened_values)
conn.commit()
except Exception as e:
logger.error(
"ERROR: Unexpected error: Could not connect to MySql instance.")
logger.error(e)
sys.exit()
logger.info("SUCCESS: Connection to RDS mysql instance succeeded")
def __init__(self, db=1, host=HOST, port=PORT, redis_password=REDIS_PASSWORD, max_connections=MAX_CONNECTIONS):
try:
pool = redis.ConnectionPool(host=host, port=port, db=db, password=redis_password,
max_connections=max_connections, decode_responses=True)
self.__redis = redis.StrictRedis(connection_pool=pool)
except Exception as e:
logger.error("redis 连接失败：%s" % e)
def post(self,request):
data = json.loads(request.body.decode())
receiver=data.get('receiver')
province_id=data.get('province_id')
city_id=data.get('city_id')
district_id=data.get('district_id')
place=data.get('place')
mobile=data.get('mobile')
tel=data.get('tel')
email=data.get('email')
user = request.user
if not all([receiver, province_id, city_id, district_id, place, mobile]):
return HttpResponseBadRequest('缺少必传参数')
if not re.match(r'^1[3-9]\d{9}$', mobile):
return HttpResponseBadRequest('参数mobile有误')
if tel:
if not re.match(r'^(0[0-9]{2,3}-)?([2-9][0-9]{6,7})+(-[0-9]{1,4})?$', tel):
return HttpResponseBadRequest('参数tel有误')
if email:
if not re.match(r'^[a-z0-9][\w\\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
return HttpResponseBadRequest('参数email有误')
try:
address = Address.objects.create(
user=request.user,
title=receiver,
receiver=receiver,
province_id=province_id,
city_id=city_id,
district_id=district_id,
place=place,
mobile=mobile,
tel=tel,
email=email
)
# 设置默认地址
if not request.user.default_address:
request.user.default_address = address
request.user.save()
except Exception as e:
logger.error(e)
return JsonResponse({'code': 400, 'errmsg': '新增地址失败'})
# 新增地址成功，将新增的地址响应给前端实现局部刷新
address_dict = {
"id": address.id,
"title": address.title,
"receiver": address.receiver,
"province": address.province.name,
"city": address.city.name,
"district": address.district.name,
"place": address.place,
"mobile": address.mobile,
"tel": address.tel,
"email": address.email
}
# 响应保存结果
return JsonResponse({'code': 0, 'errmsg': '新增地址成功', 'address': address_dict})
def send_sms_code(self, mobile, sms_code):
"""
异步发送短信
:param self:
:param mobile:
:param sms_code:
:return:
"""
try:
# 调用CCP() 发送短信，并传递相关参数
result = CCP().send_template_sms(mobile,
[sms_code, const.IMAGE_COOE_REDIS_EXPIRES // 60], 1)
except Exception as e:
# 如果发送过程出错，打印错误日志
logger.error(e)
# 有异常自动重试三次
raise self.retry(exc=e, max_retries=3)
# 如果发送成功，rend_ret 为0
if result != 0:
raise self.retry(exc=Exception('发送短信失败', max_retries=3))
return result
def get(self, request):
order_id = request.GET.get('order_id')
try:
OrderInfo.objects.get(order_id=order_id, user=request.user)
except OrderInfo.DoesNotExist:
return http.HttpResponseForbidden('订单不存在')
try:
uncomment_goods = OrderGoods.objects.filter(order_id=order_id, is_commented=False)
except Exception as e:
logger.error(e)
return http.HttpResponseServerError('订单商品出错')
uncomment_goods_list = []
for goods in uncomment_goods:
uncomment_goods_list.append({
'order_id': goods.order.order_id,
'sku_id': goods.sku.id,
'name': goods.sku.name,
'price': str(goods.price),
'default_image_url': goods.sku.default_image.url,
'comment': goods.comment,
'score': goods.score,
'is_anonymous': str(goods.is_anonymous),
})
context = {
'uncomment_goods_list': uncomment_goods_list
}
return render(request, 'goods_judge.html', context)
def delete(self, requset, address_id):
try:
address = Address.objects.get(id=address_id)
address.is_deleted = True
except Exception as e:
logger.error(e)
return http.JsonResponse({'code': RETCODE.DBERR, 'errmsg': '删除地址失败'})
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '删除地址成功'})
def put(self, request, address_id):
try:
address = Address.objects.get(id=address_id)
request.user.default_address = address
request.user.save()
except Exception as e:
logger.error(e)
return http.JsonResponse({'code': RETCODE.DBERR, 'errmsg': '设置默认地址失败'})
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '设置默认地址成功'})
def get(self, request):
"""oauth2.0认证"""
# 接收Authorization Code
code = request.GET.get('code')
if not code:
return http.HttpResponseForbidden('缺少code')
# 创建工具对象
oauth = OAuthQQ(client_id=settings.QQ_CLIENT_ID,
client_secret=settings.QQ_CLIENT_SECRET,
redirect_uri=settings.QQ_REDIRECT_URI)
try:
# 携带 code 向 QQ服务器 请求 access_token(code)
access_token = oauth.get_access_token(code)
# 携带 access_token 向 QQ服务器 请求 openid
openid = oauth.get_open_id(access_token)
except Exception as e:
# 如果上面获取 openid 出错，则验证失败
logger.error(e)
# 返回结果
return http.HttpResponseServerError('OAuth2.0认证失败')
# 判断 openid 是否绑定过用户
try:
oauth_user = OAuthQQUser.objects.get(openid=openid)
except OAuthQQUser.DoesNotExist:
# 如果 openid 没绑定美多商城用户， 进入这里
# 调用我们封装号的方法， 对openid 进行加密， 生成 access_token 字符串
access_token = generate_access_token(openid)
# 返回响应， 重新渲染
context = {
'access_token': access_token
}
return render(request, 'oauth_callback.html', context)
else:
# 如果 openid 已绑定美多商城用户
# 根据 user 外键， 获取对应的 QQ用户
qq_user = oauth_user.user
# 实现状态保持
login(request, qq_user)
# 创建重定向到主页的对象
response = redirect(reverse("contents:index"))
# 将用户信息写入到 cookie 中， 有效期15天
response.set_cookie('username', qq_user.username, max_age=3600 * 24 * 15)
# 合并购物车
response = merge_cart_cookie_to_redis(request, qq_user, response)
# 返回响应
return response
def put(self, request, address_id):
json_dict = json.loads(request.body.decode())
receiver = json_dict.get('receiver')
province_id = json_dict.get('province_id')
city_id = json_dict.get('city_id')
district_id = json_dict.get('district_id')
place = json_dict.get('place')
mobile = json_dict.get('mobile')
tel = json_dict.get('tel')
email = json_dict.get('email')
if not all([receiver, province_id, city_id, district_id,
place, mobile]):
return http.HttpResponseForbidden('缺少必传参数')
if not re.match(r'^1[3-9]\d{9}$', mobile):
return http.HttpResponseForbidden('参数mobile有误')
if tel:
if not re.match(r'^(0[0-9]{2,3}-)?([2-9][0-9]{6,7}(-[0-9]{1,4})?$)', tel):
return http.HttpResponseForbidden('参数tel有误')
if email:
if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
return http.HttpResponseForbidden('参数email有误')
try:
Address.objects.filter(id=address_id).update(
user=request.user,
title=receiver,
receiver=receiver,
province_id=province_id,
city_id=city_id,
district_id=district_id,
place=place,
mobile=mobile,
tel=tel,
email=email
)
except Exception as e:
logger.error(e)
return http.JsonResponse({'code': RETCODE.DBERR, 'errmsg': '修改地址失败'})
address = Address.objects.get(id=address_id)
address_dict = {
"id": address.id,
"tetiel": address.title,
"receiver": address.receiver,
"province": address.province.name,
"city": address.city.name,
"district": address.district.name,
"place": address.place,
"mobile": address.mobile,
"tel": address.tel,
"email": address.email
}
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '修改地址成功', 'address': address_dict})
def file_load_stream(wav_name, mono=False):
try:
sr = librosa.get_samplerate(wav_name)
frameSize = sr
hoplength = frameSize // 2
stream = librosa.stream(wav_name,
block_length=1,
frame_length=frameSize,
hop_length=hoplength,
mono=mono)
except:
logger.error("file_broken or not exists!! : {}".format(wav_name))
return stream
def insert(self, table, cols):
metadata = MetaData()
conn = self.engine.connect()
table = Table(table, metadata, autoload=True, autoload_with=self.engine)
while True:
try:
ins = table.insert().values(cols)
conn.execute(ins)
break
except IntegrityError as e:
# print("Integrity Error - Value Probably Already Exists")
logger.error("IntegrityError: {}".format(e))
break
except OperationalError as e:
logger.error("Operation Error: {} - trying Again".format(e))
except Exception as e:
if type(e).__name__ == "IntegrityError":
break
elif type(e).__name__ == "IntegrityError":
logger.error("Operation Error: {} - trying Again".format(e))
pass
else:
ex = "{}:{}".format(type(e).__name__, e)
logger.error(ex)
pass
def put(self,request,address_id):
try:
# 接收参数,查询地址
address = Address.objects.get(id=address_id)
# 设置地址为默认地址
request.user.default_address = address
request.user.save()
except Exception as e:
logger.error(e)
return JsonResponse({'code': 400, 'errmsg': '设置默认地址失败'})
# 响应设置默认地址结果
return JsonResponse({'code': 0, 'errmsg': '设置默认地址成功'})
def delete(self, request, address_id):
try:
# 查询要删除的地址
address = Address.objects.get(id=address_id)
# 将地址逻辑删除设置为True
address.is_deleted = True
address.save()
except Exception as e:
logger.error(e)
return JsonResponse({'code':400, 'errmsg': '删除地址失败'})
# 响应删除地址结果
return JsonResponse({'code':0, 'errmsg': '删除地址成功'})
def write(self):
with open(self.file, self.mode, newline=self.newline,
encoding="utf-8") as csvfile:
self.csvwriter = csv.writer(csvfile,
delimiter=self.delimiter,
quotechar=self.quotechar,
quoting=self.quoting,
escapechar='\\')
for row in self.rows:
try:
self.csvwriter.writerow(row)
except Exception as e:
logger.error("Error: {}".format(str(e)))
logger.error(row)
def get(self, request):
token = request.GET.get('token')
if not token:
return http.HttpResponseBadRequest('缺少token')
user = chick_verify_email_token(token)
if not user:
return http.HttpResponseForbidden('无效的token')
try:
user.email_active = True
user.save()
except Exception as e:
logger.error(e)
return http.HttpResponseServerError('激活邮箱失败')
return redirect(reverse('users:info'))
def get_tweets_from_db():
try:
dynamodb = boto3.resource('dynamodb', region_name=AWS_REGION)
table = dynamodb.Table('twitter-images')
except Exception as e:
logger.error('Error connecting to database table: ' +
(e.fmt if hasattr(e, 'fmt') else '') + ','.join(e.args))
return None
response = table.scan(ReturnConsumedCapacity='TOTAL', )
if response['ResponseMetadata']['HTTPStatusCode'] == 200:
return response['Items']
logger.error('Unknown error retrieving items from database.')
return None
def retry(self, request, reason, spider):
try:
p = request.meta['proxy_object']
p.available = True
p.rating = p.rating + reason
p.get_proxy_state()
except AttributeError:
logger.error('There is no proxy_object in request')
pass
retryreq = request.copy()
proxy_object = self.proxy_storage.get_proxy()
retryreq.meta['proxy_object'] = proxy_object
retryreq.meta['proxy'] = proxy_object.address
logger.info('Request fails, retrying')
return retryreq
def put(self, request, address_id):
json_dict = json.loads(request.body.decode())
title = json_dict.get('title')
if not title:
return http.HttpResponseForbidden('缺少title')
try:
address = Address.objects.get(id=address_id)
address.title = title
address.save()
except Exception as e:
logger.error(e)
return http.JsonResponse({'code': RETCODE.DBERR, 'errmsg': '更新标题失败'})
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '更新标题成功'})
def file_load(wav_name, mono=False):
"""
load .wav file.
wav_name : str
target .wav file
sampling_rate : int
audio file sampling_rate
mono : boolean
When load a multi channels file and this param True, the returned data will be merged for mono data
return : numpy.array( float )
"""
try:
return librosa.load(wav_name, sr=None, mono=mono)
except:
logger.error("file_broken or not exists!! : {}".format(wav_name))
def _compile(code, funcName):
ns = {}
try:
exec(code, ns)
except Exception as e:
logger.error("code: `{0}` 编译时出错，exception: {1}".format(code, e))
raise e
func = None
may_be_function = ns[funcName]
if isfunction(may_be_function):
func = may_be_function
if not func:
logger.error("code: `{0}` 没有找到可用的函数".format(code))
raise ValueError("Code Error , function not found")
return func
def create_table(url):
try:
conn = pymysql.connect(url,
user=rds_user_name,
passwd=rds_password,
db=db_name,
connect_timeout=5)
cursor = conn.cursor()
cursor.execute(
"create table airquality (id int auto_increment primary key, date varchar(255) not null, time varchar(255) not null, co varchar(255) not null, tin_oxide varchar(255) not null, metanic_hydro varchar(255) not null, benzene_conc varchar(255) not null, titania varchar(255) not null, nox varchar(255) not null, tungsten_oxide_nox varchar(255) not null, average_no2 varchar(255) not null, tungsten_oxide_no2 varchar(255) not null, indium_oxide varchar(255) not null, temp varchar(255) not null, relative_humidity varchar(255) not null, absolute_humidity varchar(255) not null);"
)
conn.commit()
except Exception as e:
logger.error(
"ERROR: Unexpected error: Could not connect to MySql instance.")
logger.error(e)
sys.exit()
def put(self,request,address_id):
data = json.loads(request.body.decode())
receiver = data.get('receiver')
province_id = data.get('province_id')
city_id = data.get('city_id')
district_id = data.get('district_id')
place = data.get('place')
mobile = data.get('mobile')
tel = data.get('tel')
email = data.get('email')
# 校验参数
if not all([receiver, province_id, city_id, district_id, place, mobile]):
return JsonResponse({'code': 400,
'errmsg': '缺少必传参数'})
if not re.match(r'^1[3-9]\d{9}$', mobile):
return JsonResponse({'code': 400,
'errmsg': '参数mobile有误'})
if tel:
if not re.match(r'^(0[0-9]{2,3}-)?([2-9][0-9]{6,7})+(-[0-9]{1,4})?$', tel):
return JsonResponse({'code': 400,
'errmsg': '参数tel有误'})
if email:
if not re.match(r'^[a-z0-9][\w\\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
return JsonResponse({'code': 400,
'errmsg': '参数email有误'})
# 判断地址是否存在,并更新地址信息
try:
Address.objects.filter(id=address_id).update(
user=request.user,
title=receiver,
receiver=receiver,
province_id=province_id,
city_id=city_id,
district_id=district_id,
place=place,
mobile=mobile,
tel=tel,
email=email
)
except Exception as e:
logger.error(e)
return JsonResponse({'code': 400, 'errmsg': '更新地址失败'})
def Pj_UploadExcel(request):
id = request.POST.get('id')
if request.method == 'POST':
f = request.FILES.get('file')
excel_type = f.name.split('.')[1]
if excel_type in ['xlsx', 'xls']: # 判断格式
# 开始解析上传的excel表格
wb = xlrd.open_workbook(filename=None,
file_contents=f.read()) # 打开指定路径下的excel
table = wb.sheets()[0] # 获取表中第一个sheet页
rows = table.nrows # 总行数
data_list = [] # 获取表中数据
try:
for i in range(rows): # 遍历每一行数据，将这些数据存储到Interface_Data数据库表中
if i != 0:
data_list.append(table.row_values(i))
in_id = data_list[i - 1][0]
in_mname = data_list[i - 1][1]
in_type = data_list[i - 1][2]
in_url = data_list[i - 1][3]
in_data_type = data_list[i - 1][4]
in_data = data_list[i - 1][5]
in_tname = data_list[i - 1][6]
in_expected_result = data_list[i - 1][7]
in_actual_result = data_list[i - 1][8]
add_interface = Interface_Data(
in_id=in_id,
in_mname=in_mname,
in_type=in_type,
in_url=in_url,
in_data_type=in_data_type,
in_data=in_data,
in_tname=in_tname,
in_expected_result=in_expected_result,
in_actual_result=in_actual_result,
status=id)
add_interface.save()
except:
logger.error('解析excel文件或者数据插入错误')
return HttpResponse(json.dumps(data_list), {'message': '导入成功'})
else:
logger.error('上传文件类型错误！')
return render(request, 'Page/Interface_List.html',
{'message': '导入失败'})
def put(self, request, address_id):
"""设置地址标题"""
# 接收参数：地址标题
json_dict = json.loads(request.body.decode())
title = json_dict.get('title')
try:
# 查询地址
address = Address.objects.get(id=address_id)
# 设置新的地址标题
address.title = title
address.save()
except Exception as e:
logger.error(e)
return JsonResponse({'code': 400, 'errmsg': '设置地址标题失败'})
# 4.响应删除地址结果
return JsonResponse({'code': 0, 'errmsg': '设置地址标题成功'})
def runsql(self, conn, sql):
cursor = conn.cursor()
while True:
try:
cursor.execute(sql)
conn.commit()
break
except IntegrityError as e:
# print("Integrity Error - Value Probably Already Exists")
logger.error("IntegrityError: {}".format(e))
logger.error(sql)
break
except OperationalError as e:
logger.error("Operation Error: {} - trying Again".format(e))
except Exception as e:
pass
ex = "{}:{}".format(type(e).__name__, e)
logger.error(ex)
def post(self, request):
json_dict = json.loads(request.body.decode())
sku_id = json_dict.get('sku_id')
count = json_dict.get('count')
selected = json_dict.get('selected', True)
if not all([sku_id, count]):
return http.HttpResponseForbidden('缺少必要参数')
try:
models.SKU.objects.get(id=sku_id)
except Exception as e:
logger.error(e)
return http.HttpResponseForbidden('商品不存在')
try:
count = int(count)
except Exception as e:
return http.HttpResponseForbidden('参数count有误')
if selected:
if not isinstance(selected, bool):
return http.HttpResponseForbidden('参数selected有误')
# 判断用户是否登录
user = request.user
if user.is_authenticated:
# 用户已登录，操作redis购物车
redis_conn = get_redis_connection('carts')
pl = redis_conn.pipeline()
# 新增购物车数据
pl.hincrby('carts_%s' % user.id, sku_id, count)
# 新增选中的状态
if selected:
pl.sadd('selected_%s' % user.id, sku_id)
# 执行管道
pl.execute()
# 响应结果
return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '添加购物车成功'})
else:
# 用户未登录，操作cookie购物车
cart_str = request.COOKIES.get('carts')
# 如果用户操作过cookie购物车
if cart_str:
# 将cart_str转成bytes,再将bytes转成base64的bytes,最后将bytes转字典
cart_dict = pickle.loads(base64.b64decode(cart_str.encode()))
else: # 用户从没有操作过cookie购物车
cart_dict = {}
# 判断要加入购物车的商品是否已经在购物车中,如有相同商品，累加求和，反之，直接赋值
if sku_id in cart_dict:
# 累加求和
origin_count = cart_dict[sku_id]['count']
count += origin_count
cart_dict[sku_id] = {'count': count, 'selected': selected}
# 将字典转成bytes,再将bytes转成base64的bytes,最后将bytes转字符串
cookie_cart_str = base64.b64encode(
pickle.dumps(cart_dict)).decode()
# 创建响应对象
response = http.JsonResponse({
'code': RETCODE.OK,
'errmsg': '添加购物车成功'
})
# 响应结果并将购物车数据写入到cookie
response.set_cookie('carts',
cookie_cart_str,
max_age=constants.CARTS_COOKIE_EXPIRES)
return response
def get(self, request, mobile):
"""
:param request:
:param mobile: 手机号码
:return: JSON
"""
# 3.创建连接到redis的对象
redis_conn = get_redis_connection('verify_code')
send_flag = redis_conn.get('send_flag_%s' % mobile)
if send_flag:
return http.JsonResponse({'code': RETCODE.THROTTLINGERR,
'errmsg': '发送短信验证码过快'})
# 1.接收参数
image_code_client = request.GET.get('image_code')
uuid = request.GET.get('image_code_id')
# 2.校验参数
if not all([image_code_client, uuid]):
return http.JsonResponse({'code': RETCODE.NECESSARYPARAMERR,
'errmsg': '缺少必传参数'})
# 4.提取图形验证码
image_code_server = redis_conn.get('img_%s' % uuid)
if image_code_server is None:
# 图形验证码过期或者不存在
return http.JsonResponse({'code': RETCODE.IMAGECODEERR,
'errmsg': '图形验证码失效'})
# 5.删除图形验证码，避免恶意侧视图形验证码
try:
redis_conn.delete('img_%s' % uuid)
except Exception as e:
logger.error(e)
# 6.对比图形验证码
image_code_server = image_code_server.decode() # bytes转字符串
if image_code_client.lower() != image_code_server.lower(): # 转小写后比较
return http.JsonResponse({'code': RETCODE.IMAGECODEERR,
'errmsg': '输入图形验证码错误'})
# 7. 生成短信验证码：生成6位数验证码
sms_code = '%06d' % random.randint(0, 999999)
logger.info(sms_code)
print(sms_code)
# 8.保存短信验证码,保存到redis中
# 短信验证码有效期， 单位：秒
# SMS_CODE_REDIS_EXPIRES = 300
# 创建管道
pl = redis_conn.pipeline()
# 保存到redis中
pl.setex('sms_code_%s' % mobile, const.SEND_SMS_TEPLATE_ID, sms_code)
pl.setex('send_flag_%s' % mobile, 60, 1)
# 执行管道
pl.execute()
# 9.发送短信验证码
# 短信模板
# SMS_CODE_REDIS_EXPIRES // 60 = 5min
# SEND_SMS_TEMPLATE_ID = 1
# CCP().send_template_sms(mobile, [sms_code, 5], 1)
# 导入异步的包
# from celery_tasks.sms.email import send_sms_code
# send_sms_code.delay(mobile, sms_code)
# 10.响应结果
return http.JsonResponse({'code': RETCODE.OK,
'errmsg': '发送短信成功'})
