def auth(request):
data = JSONParser().parse(request)
try:
username = data['username']
except Exception:
return JsonResponse(retcode(errcode("9999", '注册姓名不能为空'), "9999",
'注册姓名不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
password = data['password']
except Exception:
return JsonResponse(retcode(errcode("9999", '注册密码不能为空'), "9999",
'注册密码不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user = EnterpriseUser.objects.get(user_name=username,
user_password=password)
except EnterpriseUser.DoesNotExist, e:
log.error(repr(e))
return JsonResponse(retcode(errcode("0403", '用户不存在或用户密码不正确'), "0403",
'用户不存在或用户密码不正确'),
safe=True,
status=status.HTTP_403_FORBIDDEN)
def process_request(self, request):
if request.path.startswith(r'/container/api/v1/cloudbox/tms/'): # 检测如果不是登录的话
try:
token = request.META.get('HTTP_AUTHORIZATION')
log.info("request token %s" % token)
conn = self.get_connection_from_pool()
if token:
# try:
# sess = Session.objects.get(pk=request.session.session_key)
# sess_param = sess.get_decoded()
# if sess_param[token] and (token in sess_param.keys()):
# log.info('session is valid pass')
# else:
# log.info("session timeout or invalid session")
# return JsonResponse(retcode(errcode("0401", "session timeout or invalid session"),
# "0401", "session timeout or invalid session"),
# safe=True,
# status=status.HTTP_401_UNAUTHORIZED)
# except Session.DoesNotExist:
# return JsonResponse(retcode(errcode("0401", "no authorized, session invalid"),
# "0401", "no authorized, session invalid"),
# safe=True,
# status=status.HTTP_401_UNAUTHORIZED)
if conn.hexists(PERMISSION_GROUP_HASH, token):
group = conn.hget(PERMISSION_GROUP_HASH, token)
#admin level direct pass
if group == 'admin':
pass
#guest and operator should filter
else:
if conn.hexists(PERMISSION_URL_HASH, group):
url_list = conn.hget(PERMISSION_URL_HASH, group).split(',')
req_url = request.path
# print req_url
match_flag = False
for url_pattern in url_list:
result = re.match(url_pattern, req_url)
if result:
match_flag = True
# 非法请求url直接返回
if not match_flag:
return JsonResponse(retcode(errcode("0401", "no authorized"), "0401", "no authorized"), safe=True,
status=status.HTTP_401_UNAUTHORIZED)
else:
return JsonResponse(retcode(errcode("0401", "no authorized"), "0401", "no authorized"), safe=True,
status=status.HTTP_401_UNAUTHORIZED)
else:
return JsonResponse(retcode(errcode("0401", "no authorized"), "0401", "no authorized, token is null"), safe=True,
status=status.HTTP_401_UNAUTHORIZED)
else:
if request.path.startswith(r'/container/api/v1/cloudbox/tms/upload/'):
log.info("request without valid token bypass, if the request is upload api")
else:
log.info("request without valid token reject")
return JsonResponse(retcode(errcode("0401", "no authorized"), "0401", "令牌失效，请重新登录"), safe=True,
status=status.HTTP_401_UNAUTHORIZED)
except Exception:
return JsonResponse(retcode(errcode("0401", "no authorized"), "0401", "no authorized exception"), safe=True,
status=status.HTTP_401_UNAUTHORIZED)
def enterpriseuser_fuzzy_query(request):
pagination_class = api_settings.DEFAULT_PAGINATION_CLASS
paginator = pagination_class()
data = JSONParser().parse(request)
# group_id -> group.name
group_map = {}
try:
keyword = data['keyword']
except Exception:
return JsonResponse(retcode(errcode("9999", '关键字为空'), "9999", '关键字为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_id = data['enterprise_id']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业id为空'), "9999",
'企业id为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user_data = EnterpriseUser.objects.filter(
Q(user_name__contains=keyword),
enterprise_id=enterprise_id).order_by('register_time')
for item in user_data:
group_map[item.group.access_group_id] = item.group.group
log.info("group_map= %s" % group_map)
page = paginator.paginate_queryset(user_data, request)
ser_ret = EnterpriseUserSerializer(page, many=True)
ser_data_list = []
for data in ser_ret.data:
data['group'] = group_map[data['group']]
ser_data_list.append(data)
except Exception, e:
log.error(repr(e))
def set_rent_fee_rate(request):
data = JSONParser().parse(request)
try:
type_id = data['type_id']
except Exception:
return JsonResponse(retcode(errcode("9999", '箱子类型不能为空'), "9999",
'箱子类型不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
fee_per_hour = data['fee_per_hour']
except Exception:
return JsonResponse(retcode(errcode("9999", '箱子租赁价格不能为空'), "9999",
'箱子租赁价格不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
box_type_info = BoxTypeInfo.objects.get(id=type_id)
box_type_info.price = float(fee_per_hour)
box_type_info.save()
ser_data = BoxTypeInfoSerializer(box_type_info)
except BoxTypeInfo.DoesNotExist, e:
log.error(repr(e))
return JsonResponse(retcode(errcode("9999", '修改云箱租赁价格失败'), "9999",
'修改云箱租赁价格失败'),
safe=True,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def box_bill_real_time_all_filter(request):
ret_list = []
current_time = datetime.datetime.now(tz=timezone)
pagination_class = api_settings.DEFAULT_PAGINATION_CLASS
paginator = pagination_class()
data = JSONParser().parse(request)
try:
keyword = data['keyword']
except Exception:
return JsonResponse(retcode(errcode("9999", '关键字为空'), "9999", '关键字为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
log.info("input keyword is %s" % keyword)
log.debug("input keyword type is %s" % type(keyword))
enterprise_id_list = EnterpriseInfo.objects.filter(
Q(enterprise_name__contains=keyword))
enterprise_id_list_ser = EnterpriseInfoSerializer(enterprise_id_list,
many=True)
log.debug("enterprise_id_list is %s" % enterprise_id_list_ser.data)
log.debug("current_time.year=%s, current_time.month=%s" %
(current_time.year, current_time.month))
try:
for enterprise in enterprise_id_list:
rentlease_list = RentLeaseInfo.objects.filter(
user_id__enterprise__enterprise_id=enterprise.enterprise_id)
# rentlease_list = rentlease_list_with_today.exclude(lease_end_time__year=current_time.year,
# lease_end_time__month=current_time.month,
# lease_end_time__day=current_time.day)
if rentlease_list:
on_num = 0
off_num = 0
fee = 0
bill = {}
for item in rentlease_list:
if item.rent_status == 0 and (not item.lease_end_time):
off_num = off_num + 1
if item.lease_end_time \
and (item.lease_end_time.year == current_time.year) \
and (item.lease_end_time.month == current_time.month):
on_num = on_num + 1
fee = fee + item.rent
bill['on_num'] = on_num
bill['off_num'] = off_num
bill['fee'] = fee
bill['enterprise_id'] = enterprise.enterprise_id
bill['enterprise_name'] = enterprise.enterprise_name
ret_list.append(bill)
else:
log.info("rentlease_list is null")
continue
except Exception, e:
log.error(repr(e))
return JsonResponse(retcode(errcode("0500", '云箱计费查询失败'), "0500",
'云箱计费查询失败'),
safe=True,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def enterprise_user_detail(request, user_id):
try:
user = EnterpriseUser.objects.get(user_id=user_id)
ser_user = EnterpriseUserSerializer(user)
ret = ser_user.data
ret['group'] = user.group.group
except EnterpriseUser.DoesNotExist:
return JsonResponse(retcode(errcode("9999", "查询用户信息失败"), "9999", "查询用户信息失败"), safe=True,
status=status.HTTP_400_BAD_REQUEST)
return JsonResponse(retcode(ret, "0000", "Succ"), safe=True, status=status.HTTP_200_OK)
def group_detail(request, access_group_id):
try:
group = AccessGroup.objects.get(access_group_id=access_group_id)
ser_group = AccessGroupSerializer(group)
except EnterpriseUser.DoesNotExist:
return JsonResponse(retcode(errcode("9999", "查询用户信息失败"), "9999",
"查询用户信息失败"),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
return JsonResponse(retcode(ser_group.data, "0000", "Succ"),
safe=True,
status=status.HTTP_200_OK)
def enterpise_info_detail(request, enterprise_id):
try:
ret_enterpriseinfo = EnterpriseInfo.objects.get(
enterprise_id=enterprise_id)
ser_enterpriseinfo = EnterpriseInfoSerializer(ret_enterpriseinfo)
except EnterpriseInfo.DoesNotExist:
return JsonResponse(retcode(errcode("9999", "查询企业信息失败"), "9999",
"查询企业信息失败"),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
return JsonResponse(retcode(ser_enterpriseinfo.data, "0000", "Succ"),
safe=True,
status=status.HTTP_200_OK)
def del_enterpise_info(request, enterprise_id):
ret = {}
try:
EnterpriseInfo.objects.get(enterprise_id=enterprise_id).delete()
ret['enterprise_id'] = enterprise_id
except EnterpriseInfo.DoesNotExist:
return JsonResponse(retcode(errcode("9999", "删除企业信息失败"), "9999",
"删除企业信息失败"),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
return JsonResponse(retcode(ret, "0000", "Succ"),
safe=True,
status=status.HTTP_200_OK)
def list_enterprise_user(request, group):
pagination_class = api_settings.DEFAULT_PAGINATION_CLASS
paginator = pagination_class()
group_query_set = AccessGroup.objects.all()
group_map = {}
for item in group_query_set:
group_map[item.access_group_id] = item.group
try:
if group == 'all':
enterprise_user_ret = EnterpriseUser.objects.all().exclude(group__group='admin')
page = paginator.paginate_queryset(enterprise_user_ret, request)
enterprise_user_ser = EnterpriseUserSerializer(page, many=True)
revised_enterprise_user_list = []
for item in enterprise_user_ser.data:
group_id = item['group']
item['group'] = group_map[group_id]
revised_enterprise_user_list.append(item)
else:
try:
obj_group = AccessGroup.objects.get(group=group)
except AccessGroup.DoesNotExist:
return JsonResponse(retcode(errcode("9999", '企业用户群组不存在'), "9999", '企业用户群组不存在'), safe=True,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
enterprise_user_ret = EnterpriseUser.objects.filter(group=obj_group).order_by('-register_time')
page = paginator.paginate_queryset(enterprise_user_ret, request)
enterprise_user_ser = EnterpriseUserSerializer(page, many=True)
revised_enterprise_user_list = []
for item in enterprise_user_ser.data:
group_id = item['group']
item['group'] = group_map[group_id]
revised_enterprise_user_list.append(item)
except Exception, e:
log.error(repr(e))
def box_type_info_list(request):
try:
box_type_info_list = BoxTypeInfo.objects.all().order_by('id')
ser_data = BoxTypeInfoSerializer(box_type_info_list, many=True)
except e:
log.error(repr(e))
return JsonResponse(retcode(ser_data.data, "0000", "Succ"),
safe=True,
status=status.HTTP_200_OK)
def change_password(request):
data = JSONParser().parse(request)
try:
user_id = data['user_id']
except Exception:
return JsonResponse(retcode(errcode("9999", '用户id不能为空'), "9999",
'用户id不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
orig_password = data['orig_password']
except Exception:
return JsonResponse(retcode(errcode("9999", '原密码不能为空'), "9999",
'原密码不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
new_password = data['new_password']
except Exception:
return JsonResponse(retcode(errcode("9999", '新密码不能为空'), "9999",
'新密码不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
timestamp = data['timestamp']
except Exception:
return JsonResponse(retcode(errcode("9999", '异常错误'), "9999", '异常错误'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user = EnterpriseUser.objects.get(user_id=user_id)
# check salt valid
current_utc = int(time.time())
if current_utc - timestamp > settings.SALT_DURATION:
return JsonResponse(retcode(errcode("4031", '非法登陆未经授权'), "4031",
'非法登陆未经授权'),
safe=True,
status=status.HTTP_403_FORBIDDEN)
m2 = hashlib.md5()
m2.update(user.user_password_encrypt + str(timestamp))
gen_password = m2.hexdigest()
log.info(
'origin_password=%s, gen_password=%s, user_password_encrypt=%s, timestamp=%s'
% (orig_password, gen_password, user.user_password_encrypt,
timestamp))
if gen_password != orig_password:
return JsonResponse(retcode(errcode("0403", '原始密码输入不正确'), "0403",
'原始密码输入不正确'),
safe=True,
status=status.HTTP_403_FORBIDDEN)
else:
user.user_password_encrypt = new_password
user.save()
except EnterpriseUser.DoesNotExist, e:
log.error(e)
return JsonResponse(retcode(errcode("0403", '用户不存在或用户密码不正确'), "0403",
'用户不存在或用户密码不正确'),
safe=True,
status=status.HTTP_403_FORBIDDEN)
def add_enterprise_admin(request):
ret = {}
data = JSONParser().parse(request)
try:
user_name = data['user_name']
except Exception:
return JsonResponse(retcode({}, "9999", '注册姓名不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
user_password = data['user_password']
except Exception:
return JsonResponse(retcode({}, "9999", '注册密码不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
user_real_name = data['user_real_name']
except Exception:
return JsonResponse(retcode({}, "9999", '注册用户姓名不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
user_phone = data['user_phone']
except Exception, e:
user_phone = ''
log.error(repr(e))
def enterprise_month_bill(request, enterprise_id):
pagination_class = api_settings.DEFAULT_PAGINATION_CLASS
paginator = pagination_class()
try:
box_rent_fee_month_bill = BoxRentFeeByMonth.objects.filter(
enterprise=enterprise_id).order_by('date')
except BoxRentFeeByMonth.DoesNotExist, e:
log.error(repr(e))
return JsonResponse(retcode(errcode("0500", '查询企业计费报表失败'), "0500",
'查询企业计费报表失败'),
safe=True,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def enterpise_deposit_confirm(request):
data = JSONParser().parse(request)
try:
enterprise_id = data['enterprise_id']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业id为空'), "9999",
'企业id为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
ret_enterpriseinfo = EnterpriseInfo.objects.get(
enterprise_id=enterprise_id)
ser_enterpriseinfo = EnterpriseInfoSerializer(ret_enterpriseinfo)
ret_enterpriseinfo.enterprise_deposit_status = 1
ret_enterpriseinfo.save()
except EnterpriseInfo.DoesNotExist:
return JsonResponse(retcode(errcode("9999", "查询企业信息失败"), "9999",
"查询企业信息失败"),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
return JsonResponse(retcode(ser_enterpriseinfo.data, "0000", "Succ"),
safe=False,
status=status.HTTP_200_OK)
def list_enterpise_info(request):
pagination_class = api_settings.DEFAULT_PAGINATION_CLASS
paginator = pagination_class()
try:
enterprise_ret = EnterpriseInfo.objects.all().order_by(
'-last_update_time')
page = paginator.paginate_queryset(enterprise_ret, request)
ret_ser = EnterpriseInfoSerializer(page, many=True)
except Exception:
return JsonResponse(retcode(errcode("9999", "查询企业信息列表失败"), "9999",
"查询企业信息列表失败"),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
return paginator.get_paginated_response(ret_ser.data)
def auth_user_logout(request):
data = JSONParser().parse(request)
try:
user_id = data['user_id']
except Exception:
return JsonResponse(retcode(errcode("9999", '用户id不能为空'), "9999",
'用户id不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user = EnterpriseUser.objects.get(user_id=user_id)
conn = get_connection_from_pool()
if conn.hexists(USER_ALIAS_ID_HASH, user.user_id):
conn.hdel(USER_ALIAS_ID_HASH, user.user_id)
# if user.user_alias_id:
# user.user_alias_id = ''
user.save()
except EnterpriseUser.DoesNotExist, e:
log.error(e)
return JsonResponse(retcode(errcode("0403", '登出用户不存在'), "0403",
'登出用户不存在'),
safe=True,
status=status.HTTP_403_FORBIDDEN)
def enterprise_fuzzy_query(request):
pagination_class = api_settings.DEFAULT_PAGINATION_CLASS
paginator = pagination_class()
data = JSONParser().parse(request)
try:
keyword = data['keyword']
except Exception:
return JsonResponse(retcode(errcode("9999", '关键字为空'), "9999", '关键字为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
enterprise_data = EnterpriseInfo.objects.filter(
Q(enterprise_name__contains=keyword)).order_by('register_time')
page = paginator.paginate_queryset(enterprise_data, request)
ser_ret = EnterpriseInfoSerializer(page, many=True)
return paginator.get_paginated_response(ser_ret.data)
def auth_with_salt(request):
data = JSONParser().parse(request)
try:
username = data['username']
except Exception:
return JsonResponse(retcode(errcode("9999", '注册姓名不能为空'), "9999",
'注册姓名不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
password = data['password']
except Exception:
return JsonResponse(retcode(errcode("9999", '注册密码不能为空'), "9999",
'注册密码不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
timestamp = data['timestamp']
except Exception:
return JsonResponse(retcode(errcode("9999", '异常错误'), "9999", '异常错误'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user = EnterpriseUser.objects.get(user_name=username)
# check salt valid
current_utc = int(time.time())
if current_utc - timestamp > settings.SALT_DURATION:
return JsonResponse(retcode(errcode("4031", '非法登陆未经授权'), "4031",
'非法登陆未经授权'),
safe=True,
status=status.HTTP_403_FORBIDDEN)
m2 = hashlib.md5()
m2.update(user.user_password_encrypt + str(timestamp))
gen_password = m2.hexdigest()
log.info("password=%s, gen_password=%s, timestamp=%s, username=%s" %
(password, gen_password, timestamp, username))
if gen_password != password:
return JsonResponse(retcode(errcode("0403", '用户不存在或用户密码不正确'),
"0403", '用户不存在或用户密码不正确'),
safe=True,
status=status.HTTP_403_FORBIDDEN)
log.info("login verify success, begin alias_id init")
conn = get_connection_from_pool()
conn.hset(USER_ALIAS_ID_HASH, user.user_id, uuid.uuid1().hex)
# user.user_alias_id = uuid.uuid1().hex
# user.save()
except EnterpriseUser.DoesNotExist, e:
log.error(repr(e))
return JsonResponse(retcode(errcode("0403", '用户不存在或用户密码不正确'), "0403",
'用户不存在或用户密码不正确'),
safe=True,
status=status.HTTP_403_FORBIDDEN)
def enterprise_month_bill_detail(request, enterprise_id, date):
pagination_class = api_settings.DEFAULT_PAGINATION_CLASS
paginator = pagination_class()
try:
log.info("enterprise_id=%s, date=%s" % (enterprise_id, date))
year = date.split('-')[0]
month = int(date.split('-')[1])
# if month <=0 or month >12:
# return JsonResponse(retcode(errcode("0400", '日期参数错误'), safe=True, status=status.HTTP_400_BAD_REQUEST)
rent_info_list = RentLeaseInfo.objects.filter(
user_id__enterprise__enterprise_id=enterprise_id,
lease_end_time__year=year,
lease_end_time__month=month).order_by('-lease_end_time')
except Exception, e:
log.error(repr(e))
return JsonResponse(retcode(errcode("0500", '查询企业月报表明细错误'), "0500",
'查询企业月报表明细错误'),
safe=True,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def update_enterprise_user(request):
ret = {}
data = JSONParser().parse(request)
try:
avatar_url = data['avatar_url']
except Exception:
return JsonResponse(retcode(errcode("9999", '修改头像url不能为空'), "9999", '修改头像url不能为空'), safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user_real_name = data['user_real_name']
except Exception:
return JsonResponse(retcode(errcode("9999", '修改姓名不能为空'), "9999", '修改姓名不能为空'), safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user_gender = data['user_gender']
except Exception:
return JsonResponse(retcode(errcode("9999", '修改用户性别不能为空'), "9999", '修改用户性别不能为空'), safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user_nickname = data['user_nickname']
except Exception:
return JsonResponse(retcode(errcode("9999", '修改用户性别不能为空'), "9999", '修改用户性别不能为空'), safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user_phone = data['user_phone']
except Exception:
return JsonResponse(retcode(errcode("9999", '用户号码不能为空'), "9999", '用户号码不能为空'), safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_id = data['enterprise_id']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业信息id不能为空'), "9999", '企业信息id不能为空'), safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user_id = data['user_id']
except Exception:
return JsonResponse(retcode(errcode("9999", '修改用户id不能为空'), "9999", '修改用户id不能为空'), safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user_email = data['user_email']
except Exception, e:
log.error(repr(e))
user_email = ''
def admin_auth_with_salt(request):
data = JSONParser().parse(request)
try:
username = data['username']
except Exception:
return JsonResponse(retcode(errcode("9999", '注册姓名不能为空'), "9999",
'注册姓名不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
password = data['password']
except Exception:
return JsonResponse(retcode(errcode("9999", '注册密码不能为空'), "9999",
'注册密码不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
timestamp = data['timestamp']
except Exception:
return JsonResponse(retcode(errcode("9999", '异常错误'), "9999", '异常错误'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user = EnterpriseUser.objects.get(user_name=username,
group__group='admin')
# check salt valid
current_utc = int(time.time())
if current_utc - timestamp > settings.SALT_DURATION:
return JsonResponse(retcode(errcode("4031", '非法登陆未经授权'), "4031",
'非法登陆未经授权'),
safe=True,
status=status.HTTP_403_FORBIDDEN)
m2 = hashlib.md5()
m2.update(user.user_password_encrypt + str(timestamp))
gen_password = m2.hexdigest()
log.info("password=%s, gen_password=%s, timestamp=%s, username=%s" %
(password, gen_password, timestamp, username))
if gen_password != password:
return JsonResponse(retcode(errcode("0403", '用户不存在或用户密码不正确'),
"0403", '用户不存在或用户密码不正确'),
safe=True,
status=status.HTTP_403_FORBIDDEN)
except EnterpriseUser.DoesNotExist, e:
log.error(repr(e))
return JsonResponse(retcode(errcode("0403", '用户不存在或用户密码不正确'), "0403",
'用户不存在或用户密码不正确'),
safe=True,
status=status.HTTP_403_FORBIDDEN)
def box_bill_real_time_all(request):
ret_list = []
current_time = datetime.datetime.now(tz=timezone)
pagination_class = api_settings.DEFAULT_PAGINATION_CLASS
paginator = pagination_class()
try:
enterprise_query_list = EnterpriseInfo.objects.all()
for enterprise in enterprise_query_list:
rentlease_list = RentLeaseInfo.objects.filter(
user_id__enterprise__enterprise_id=enterprise.enterprise_id)
# rentlease_list = rentlease_list_with_today.exclude(lease_end_time__year=current_time.year,
# lease_end_time__month=current_time.month,
# lease_end_time__day=current_time.day)
if rentlease_list:
on_num = 0
off_num = 0
fee = 0
bill = {}
for item in rentlease_list:
if item.rent_status == 0 and (not item.lease_end_time):
off_num = off_num + 1
if item.lease_end_time \
and (item.lease_end_time.year == current_time.year) \
and (item.lease_end_time.month == current_time.month):
on_num = on_num + 1
fee = fee + item.rent
bill['on_num'] = on_num
bill['off_num'] = off_num
bill['fee'] = fee
bill['enterprise_id'] = enterprise.enterprise_id
bill['enterprise_name'] = enterprise.enterprise_name
ret_list.append(bill)
else:
continue
except Exception, e:
log.error(repr(e))
return JsonResponse(retcode(errcode("0500", '云箱计费查询失败'), "0500",
'云箱计费查询失败'),
safe=True,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def update_enterprise_admin(request):
ret = {}
data = JSONParser().parse(request)
try:
user_phone = data['user_phone']
except Exception:
return JsonResponse(retcode({}, "9999", '用户号码不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
user_email = data['user_email']
except Exception:
return JsonResponse(retcode({}, "9999", '用户邮件地址不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_id = data['enterprise_id']
except Exception:
return JsonResponse(retcode({}, "9999", '企业信息id不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
user_id = data['user_id']
except Exception:
return JsonResponse(retcode({}, "9999", '修改用户id不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
role = data['role']
except Exception:
return JsonResponse(retcode({}, "9999", '修改用户角色不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
group = data['group']
except Exception:
return JsonResponse(retcode({}, "9999", '企业用户所属群组不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
avatar_url = data['avatar_url']
except Exception:
return JsonResponse(retcode({}, "9999", '头像url不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
user_gender = data['user_gender']
except Exception, e:
log.error(repr(e))
user_gender = ''
try:
tmpfile_path = os.path.join('.', file_obj.name)
if os.path.exists(tmpfile_path):
q = Auth(self.access_key, self.secret_key)
log.info("begin base64 filename")
file_name_base64 = base64.b64encode(self.to_str(file_obj.name))
log.info(
"filename=%s, filenametype=%s, base64filename=%s" %
(file_obj.name, type(file_obj.name), file_name_base64))
key = "%s-%s" % (uuid.uuid1(), file_name_base64)
token = q.upload_token(self.bucket_name, key, 3600)
ret, info = put_file(token, key, tmpfile_path)
if info.status_code == 200:
ret['url'] = "%s/%s" % (self.base_url, key)
else:
ret['url'] = ""
os.remove(tmpfile_path)
except Exception, e:
log.error(repr(e))
ret['error'] = e
os.remove(tmpfile_path)
return Response(data=errcode('0500', ret), status=500)
return Response(data=retcode(ret, "0000", "Succ"), status=200)
def to_str(self, str_or_unicode):
if isinstance(str_or_unicode, unicode):
value = str_or_unicode.encode('utf-8')
else:
value = str_or_unicode
return value
log.error(repr(e))
avatar_url = ''
try:
user_gender = data['user_gender']
except Exception, e:
log.error(repr(e))
user_gender = ''
try:
user_nickname = data['user_nickname']
except Exception, e:
log.error(repr(e))
user_nickname = ''
try:
enterprise_id = data['enterprise_id']
except Exception:
return JsonResponse(retcode({}, "9999", '企业信息id不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
role = data['role']
except Exception:
return JsonResponse(retcode({}, "9999", '企业用户角色不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
group = data['group']
except Exception:
return JsonResponse(retcode({}, "9999", '企业用户所属群组不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
log.info("add enterprise user input data = %s" % data)
try:
try:
enterprise = EnterpriseInfo.objects.get(enterprise_id=enterprise_id)
except EnterpriseUser.DoesNotExist:
return JsonResponse(retcode({}, "9999", '企业信息id不存在'), safe=True,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def add_enterprise_user(request):
ret = {}
data = JSONParser().parse(request)
try:
user_name = data['user_name']
except Exception:
return JsonResponse(retcode(errcode("9999", '注册登陆名不能为空'), "9999", '注册登陆名不能为空'), safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user_real_name = data['user_real_name']
except Exception:
return JsonResponse(retcode(errcode("9999", '注册用户姓名不能为空'), "9999", '注册用户姓名不能为空'), safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user_gender = data['user_gender']
except Exception:
return JsonResponse(retcode(errcode("9999", '注册用户性别不能为空'), "9999", '注册用户性别不能为空'), safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user_phone = data['user_phone']
except Exception:
return JsonResponse(retcode({}, "9999", '注册用户号码不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_id = data['enterprise_id']
except Exception:
return JsonResponse(retcode({}, "9999", '企业信息id不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
role = data['role']
except Exception:
return JsonResponse(retcode({}, "9999", '企业用户角色不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
group = data['group']
except Exception:
return JsonResponse(retcode({}, "9999", '企业用户所属群组不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
try:
enterprise = EnterpriseInfo.objects.get(enterprise_id=enterprise_id)
except EnterpriseUser.DoesNotExist:
return JsonResponse(retcode({}, "9999", '企业信息id不存在'), safe=True,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
try:
group_obj = AccessGroup.objects.get(group=group)
except AccessGroup.DoesNotExist:
return JsonResponse(retcode({}, "9999", '企业用户群组不存在'), safe=True,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
try:
usr = EnterpriseUser.objects.get(user_name=user_name)
if usr:
log.error("Enterprise User exists already and return 500 error")
return JsonResponse(retcode({}, "0500", '登陆名已存在'), safe=True,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except EnterpriseUser.DoesNotExist:
with transaction.atomic():
md = hashlib.md5()
md.update('hna12345')
md5_pwd = md.hexdigest()
new_user = EnterpriseUser(user_id=uuid.uuid1(), user_name=user_name, user_password='******',
status='', avatar_url='', user_phone=user_phone,
user_email='', register_time=datetime.datetime.now(tz=tz),
enterprise=enterprise, user_token=uuid.uuid4().hex, role=role,
group=group_obj, user_real_name=user_real_name, user_gender=user_gender,
user_alias_id=uuid.uuid1().hex, user_password_encrypt=md5_pwd)
new_user.save()
auth_user_group = AuthUserGroup(user_token=new_user.user_token, group=group_obj)
auth_user_group.save()
ret['user_id'] = new_user.user_id
update_redis_token(new_user.user_token, group)
except Exception, e:
log.error(repr(e))
return JsonResponse(retcode({}, "0500", '创建用户失败'), safe=True, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def update_enterprise_info(request):
data = JSONParser().parse(request)
try:
enterprise_id = data['enterprise_id']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业id为空'), "9999",
'企业id为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_name = data['enterprise_name']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业名称不能为空'), "9999",
'企业名称不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_tele = data['enterprise_tele']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业联系电话不能为空'), "9999",
'企业联系电话不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_license_id = data['enterprise_license_id']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业营业执照序号不能为空'), "9999",
'企业营业执照序号不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_legal_rep_name = data['enterprise_legal_rep_name']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业法人名称不能为空'), "9999",
'企业法人名称不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_deposit = data['enterprise_deposit']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业保证金不能为空'), "9999",
'企业保证金不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_email = data['enterprise_email']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业邮箱不能为空'), "9999",
'企业邮箱不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_license_id_url = data['enterprise_license_id_url']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业营业执照照片url不能为空'), "9999",
'企业营业执照照片url不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_homepage_url = data['enterprise_homepage_url']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业网址不能为空'), "9999",
'企业网址不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_address = data['enterprise_address']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业地址不能为空'), "9999",
'企业地址不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
ret = {}
ret['enterprise_id'] = enterprise_id
try:
enterprise_edit = EnterpriseInfo.objects.get(
enterprise_id=enterprise_id)
enterprise_edit.enterprise_name = enterprise_name
enterprise_edit.enterprise_tele = enterprise_tele
enterprise_edit.enterprise_license_id = enterprise_license_id
enterprise_edit.enterprise_license_id_url = enterprise_license_id_url
enterprise_edit.enterprise_legal_rep_name = enterprise_legal_rep_name
enterprise_edit.enterprise_email = enterprise_email
enterprise_edit.enterprise_deposit = enterprise_deposit
enterprise_edit.last_update_time = datetime.datetime.now(tz)
enterprise_edit.enterprise_homepage_url = enterprise_homepage_url
enterprise_edit.enterprise_address = enterprise_address
enterprise_edit.save()
except EnterpriseInfo.DoesNotExist:
return JsonResponse(retcode(errcode("9999", '请求修改的企业信息不存在'), "9999",
'请求修改的企业信息不存在'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
return JsonResponse(retcode(ret, "0000", 'Succ'),
safe=True,
status=status.HTTP_200_OK)
'注册密码不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
user = EnterpriseUser.objects.get(user_name=username,
user_password=password)
except EnterpriseUser.DoesNotExist, e:
log.error(repr(e))
return JsonResponse(retcode(errcode("0403", '用户不存在或用户密码不正确'), "0403",
'用户不存在或用户密码不正确'),
safe=True,
status=status.HTTP_403_FORBIDDEN)
ser_user = EnterpriseUserSerializer(user)
ret = ser_user.data
ret['group'] = user.group.group
return JsonResponse(retcode(ret, "0000", "Succ"),
safe=True,
status=status.HTTP_200_OK)
@csrf_exempt
@api_view(['GET'])
def list_group(request):
pagination_class = api_settings.DEFAULT_PAGINATION_CLASS
paginator = pagination_class()
try:
access_group_ret = AccessGroup.objects.all()
page = paginator.paginate_queryset(access_group_ret, request)
access_group_ser = AccessGroupSerializer(page, many=True)
except Exception, e:
log.error(repr(e))
def add_enterprise_info(request):
data = JSONParser().parse(request)
try:
enterprise_name = data['enterprise_name']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业名称不能为空'), "9999",
'企业名称不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_tele = data['enterprise_tele']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业联系电话不能为空'), "9999",
'企业联系电话不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_license_id = data['enterprise_license_id']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业营业执照序号不能为空'), "9999",
'企业营业执照序号不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_legal_rep_name = data['enterprise_legal_rep_name']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业法人名称不能为空'), "9999",
'企业法人名称不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_deposit = data['enterprise_deposit']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业保证金不能为空'), "9999",
'企业保证金不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_email = data['enterprise_email']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业邮箱不能为空'), "9999",
'企业邮箱不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_license_id_url = data['enterprise_license_id_url']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业营业执照照片url不能为空'), "9999",
'企业营业执照照片url不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_homepage_url = data['enterprise_homepage_url']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业网址不能为空'), "9999",
'企业网址不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_address = data['enterprise_address']
except Exception:
return JsonResponse(retcode(errcode("9999", '企业地址不能为空'), "9999",
'企业地址不能为空'),
safe=True,
status=status.HTTP_400_BAD_REQUEST)
try:
enterprise_info = EnterpriseInfo(
enterprise_id=uuid.uuid1(),
enterprise_name=enterprise_name,
enterprise_tele=enterprise_tele,
enterprise_license_id=enterprise_license_id,
enterprise_license_id_url=enterprise_license_id_url,
enterprise_legal_rep_name=enterprise_legal_rep_name,
enterprise_email=enterprise_email,
enterprise_deposit=enterprise_deposit,
enterprise_deposit_status=0,
register_time=datetime.datetime.now(tz),
last_update_time=datetime.datetime.now(tz),
enterprise_homepage_url=enterprise_homepage_url,
enterprise_address=enterprise_address)
enterprise_info.save()
except Exception, e:
log.error(repr(e))
