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 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 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 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 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 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 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 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))
def order_list(request, shop_id):
try:
goods_order_list = GoodsOrder.objects.filter(shop__id=shop_id, driver_take_status=1, receiver_take_status=0)
except GoodsOrder.DoesNotExist, e:
log.error(repr(e))
return JsonResponse(retcode(errcode("0400", '目的商店不存在'), "0400", '目的商店不存在'), safe=True,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def order_detail(request, order_id):
try:
goods_order = GoodsOrder.objects.get(id=order_id, driver_take_status=1, receiver_take_status=0)
except GoodsOrder.DoesNotExist, e:
log.error(repr(e))
return JsonResponse(retcode(errcode("0400", '运单不存在'), "0400", '运单不存在'), 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 arrive_ack(request):
ret = {}
data = JSONParser().parse(request)
try:
order_id = data['order_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", 'user_id不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
goods_order = GoodsOrder.objects.get(id=order_id, driver__user_id=user_id, driver_arrive_shop_status=0)
goods_order.driver_arrive_shop_status = 1
goods_order.save()
except GoodsOrder.DoesNotExist, e:
log.error(repr(e))
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 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 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 ack_order(request):
ret = {}
data = JSONParser().parse(request)
try:
deviceid = data['deviceid']
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", 'user_id不能为空'), safe=True, status=status.HTTP_400_BAD_REQUEST)
try:
goods_order_detail = GoodsOrderDetail.objects.get(order__driver__user_id=user_id, box__deviceid=deviceid,
driver_take_status=0)
# print goods_order_detail.driver_take_status
try:
with transaction.atomic():
goods_order_detail.driver_take_status = 1
goods_order_detail.save()
goods_order_detail_list = GoodsOrderDetail.objects.filter(order=goods_order_detail.order)
detail_total_num = goods_order_detail_list.count()
detail_ack_num = 0
for item in goods_order_detail_list:
if item.driver_take_status == 1:
detail_ack_num = + 1
else:
continue
if detail_ack_num == detail_total_num and detail_ack_num != 0:
goods_order = goods_order_detail.order
goods_order.driver_take_status = 1
ret['shop_id'] = goods_order.shop.id
goods_order.save()
log.info("the goods order has been ack")
ret['detail_total_num'] = detail_total_num
ret['detail_ack_num'] = detail_ack_num
except Exception, e:
log.error(repr(e))
except GoodsOrderDetail.DoesNotExist, e:
log.error(repr(e))
return JsonResponse(retcode(errcode("0400", '云箱不存在'), "0400", '云箱不存在'), safe=True, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
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_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 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 = ''
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 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 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:
role_type = data['role_type']
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,
role_type=role_type,
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(auth_id=uuid.uuid1(),
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 order_info(request, deviceid):
try:
goods_order_detail = GoodsOrderDetail.objects.get(box__deviceid=deviceid, driver_take_status=0)
except GoodsOrderDetail.DoesNotExist, e:
log.error(repr(e))
return JsonResponse(retcode(errcode("0400", '云箱不存在'), "0400", '云箱不存在'), safe=True, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
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))
ret = {}
ret['enterprise_id'] = enterprise_info.enterprise_id
return JsonResponse(retcode(ret, "0000", "Succ"), safe=True, status=status.HTTP_200_OK)
@csrf_exempt
@api_view(['POST'])
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:
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)
'注册密码不能为空'),
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 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)
