def user_detail(request, id, format=None):
"""
Retrieve, update or delete a server assets instance.
"""
try:
snippet = User.objects.get(id=id)
except User.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = serializers.UserSerializer(snippet)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = serializers.UserSerializer(snippet, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
if not request.user.has_perm('OpsManage.delete_user'):
return Response(status=status.HTTP_403_FORBIDDEN)
snippet.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def get(self, request, *args, **kwargs):
pk = kwargs.get('pk')
if pk:
try:
# 用户对象不能直接作为数据返回给前台
user_obj = models.User.objects.get(pk=pk)
# 序列化一下用户对象
user_ser = serializers.UserSerializer(user_obj)
return Response({
'status': 0,
'msg': 'ok',
'results': user_ser.data
})
except:
return Response({'status': 2, 'msg': '用户不存在'})
else:
# 用户对象列表(queryset)不能直接作为数据返回给前台
user_obj_list = models.User.objects.all()
# 序列化一下用户对象
user_ser = serializers.UserSerializer(user_obj_list, many=True)
return Response({
'status': 0,
'msg': 'ok',
'results': user_ser.data
})
def user_list(request, format=None):
"""
List all order, or create a server assets order.
"""
if request.method == 'GET':
snippets = User.objects.all()
serializer = serializers.UserSerializer(snippets, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = serializers.UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format='json'):
serializer = serializers.UserSerializer(data=request.data,
context={'request': request})
if serializer.is_valid(raise_exception=True):
user = serializer.save()
# confirmation_url = request.build_absolute_uri(reverse('confirmation'))
token = tokens.user_confirmation_token.make_token(user)
uid = urlsafe_base64_encode(force_bytes(user.pk)).decode()
try:
mailer.send_confirmation_email(
user,
{
# 'confirmation_url': confirmation_url,
'token': token,
'uid': uid,
})
return Response({'id': user.pk})
except:
print('Unexpected errors on sending an e-mail')
user.delete()
raise
return Response(status=status.HTTP_422_UNPROCESSABLE_ENTITY)
def put(self, request, format=None):
user = self.get_object(request.user.id)
serializer = serializers.UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, *args, **kwargs):
body = json.loads(request.body)
user = models.User.objects.get(username=request.user.username)
serializer = serializers.UserSerializer(instance=user, data=body)
serializer.is_valid()
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def register(request):
serialized = serializers.UserSerializer(data=request.DATA)
if serialized.is_valid():
User.objects.create_user(serialized.init_data['username'],
serialized.init_data['password'])
return Response(serialized.data, status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, userId):
obj = {'userId': userId}
self.check_object_permissions(request, obj)
user = models.Users.objects.get(uuid=userId)
user = serializers.UserSerializer(user)
return Response(user.data, status.HTTP_200_OK)
def sign_in(request):
try:
query = models.User.objects.get(username=request.data['username'],
password=request.data['password'])
serializer = serializers.UserSerializer(query)
except models.User.DoesNotExist:
return Response({'details': ['Invalid username or password']},
status=status.HTTP_404_NOT_FOUND)
return Response(serializer.data)
def get(self, request, *args, **kwargs):
# ret = {'code':1001, 'msg':None, 'data': None}
try:
username = request._request.GET.get('username')
user_obj = models.UserInfo.objects.filter(
username=username).first()
if not user_obj:
user = models.UserInfo.objects.all()
ser = serializers.UserSerializer(instance=user, many=True)
ret = json.dumps(ser.data, ensure_ascii=False)
else:
ser = serializers.UserSerializer(instance=user_obj, many=False)
ret = json.dumps(ser.data, ensure_ascii=False)
# ret['msg'] = '用户查找成功'
except Exception as e:
pass
return HttpResponse(ret)
def update_user(request, id):
data = {}
person = models.Person.objects.get(id=id)
if person:
if request.data["user_type"] == "1":
user = models.User.objects.get(id=person.user_id)
address = request.data["address"]
if address:
serializer = serializers.UserSerializer(
user, data={"address": request.data["address"]})
if serializer.is_valid():
serializer.save()
elif request.data["user_type"] == "2":
organizer = models.Organizer.objects.get(id=person.organizer_id)
serializer = serializers.OrganizerSerializer(
organizer,
data={
"address": request.data["address"],
"experience": request.data["experience"],
"organization": request.data["organization"]
})
if serializer.is_valid():
serializer.save()
data["errors"] = str(serializer.errors)
if request.data.get("first_name", None):
data["first_name"] = request.data.get("first_name", None)
if request.data.get("last_name", None):
data["last_name"] = request.data.get("last_name", None)
if request.data.get("phone_no", None):
data["phone_no"] = request.data.get("phone_no", None)
if "image" in request.data:
if person.image:
image = str(person.image)
path = "media\\uploads\\users\\" + image.split("/")[-1]
os.remove(path)
data["image"] = request.data["image"]
else:
data["image"] = person.image
serializer = serializers.PersonOnlySerializer(person, data=data)
if serializer.is_valid():
person = serializer.save()
serializer = serializers.PersonSerializer(person)
return Response(status=status.HTTP_200_OK, data=serializer.data)
if "errors" not in data:
data["errors"] = str(serializer.errors)
else:
data["errors"] += str(serializer.errors)
return Response(status=status.HTTP_400_BAD_REQUEST, data=data)
return Response(status=status.HTTP_400_BAD_REQUEST, data={})
def me(self, request, *args, **kwargs):
if request.user.is_authenticated():
if 'expand_accounts' in request.GET:
request.user.all_accounts = request.user.accounts_set.all()
if 'expand_links' in request.GET:
request.user.all_links = request.user.links.all()
serializer = serializers.UserSerializer(
request.user, context={'request': request})
return Response(serializer.data)
raise PermissionDenied()
def gen_token_response(user):
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)
return OrderedDict(user=serializers.UserSerializer(user).data,
token=token,
expired=api_settings.JWT_EXPIRATION_DELTA,
type=api_settings.JWT_AUTH_HEADER_PREFIX)
def upload_profile_picture(request):
decoded_image = base64.b64decode(request.data)
img_content = ContentFile(decoded_image, f'{request.user.username}.jpg')
data = {'profile_picture': img_content}
serializer = serializers.UserSerializer(request.user,
data=data,
partial=True)
serializer.is_valid(raise_exception=True)
serializer.save()
print(serializer.data)
return Response(serializer.data)
def get(self, *args, **kwargs):
uid = self.kwargs.get('id')
try:
user_object = models.User.objects.get(id=uid)
serializer = serializers.UserSerializer(user_object)
return Response(serializer.data)
except ObjectDoesNotExist:
return Response(data={'message': 'Object does not exist!'})
def create(self, request, *args, **kwargs):
"""
Append token on user registration
"""
context = {'request': request}
serializer = serializers.UserSerializer(data=request.data,
context=context)
if serializer.is_valid():
model_obj = serializer.save()
token = get_tokens_for_user(model_obj)
response = {'user': serializer.data, 'token': token}
return Response(response, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, *args, **kwargs):
queryset = models.User.objects.all()
paginator = Paginator(
queryset, settings.REST_FRAMEWORK.get('PAGE_SIZE'))
page = self.request.GET.get('page')
try:
queryset = paginator.page(page)
except (PageNotAnInteger, EmptyPage):
return Response(data={})
serializer = serializers.UserSerializer(queryset, many=True)
return Response(serializer.data)
def post(self, request, version, GUID):
try:
data = json.loads(request.body)
except Exception as e:
return Response('request body not set',
status=status.HTTP_400_BAD_REQUEST)
try:
Device = models.Device.objects.get(GUID=GUID)
except models.Device.DoesNotExist:
return Response('device with selected GUID not found',
status=status.HTTP_404_NOT_FOUND)
if not Device.active:
return Response('device with selected GUID is inactive',
status=status.HTTP_403_FORBIDDEN)
try:
code = str(data['code'])
except Exception as e:
return Response('code is not set',
status=status.HTTP_400_BAD_REQUEST)
if not code.isdigit():
return Response('wrong data format',
status=status.HTTP_400_BAD_REQUEST)
if Device.verification_code == code:
Device.verified = True
Device.save()
else:
return Response('wrong verification code',
status=status.HTTP_403_FORBIDDEN)
try:
User = models.User.objects.get(devices=Device)
for device in User.devices.all():
if device.id != Device.id:
device.active = False
device.save()
except Exception as e:
User = None
if User is not None:
content = serializers.UserSerializer(User).data
else:
content = None
return Response(content, status=status.HTTP_202_ACCEPTED)
def post(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
# email field in User isn't unique & setting it manually caused failure in CI, so ...
if User.objects.filter(email=request.data['email']).exists():
return Response({
"email": ["user with this email address already exists."]
}, status=400)
serializer.is_valid(raise_exception=True)
user = serializer.save()
return Response({
"user": serializers.UserSerializer(user, context=self.get_serializer_context()).data,
"token": AuthToken.objects.create(user)[1]
})
def upload_profile_image(self, request):
'''
profile image should be passed the the body
of the request
'''
try:
user = am.GidaUser.objects.get(username=request.user.username)
serializer = aps.UserSerializer(data=request.data)
if serializer.is_valid():
data = request.data['image']
# image = cloudinary.uploader.upload(data)
# user.header_image = image['url']
user.save()
return Response({'header_image': data})
except Exception:
return Response({'status': 'Upload failed'})
def status(self, request):
"""Get the current API status (user, team, competition)."""
current = models.Competition.current()
response = {
'competition': {
'start': current.competition_start,
'end': current.competition_end
}
}
if request.user.is_authenticated:
response['user'] = serializers.UserSerializer(request.user).data
response['user']['eligible'] = request.user.profile.eligible
if request.user.profile.current_team:
response['team'] = serializers.TeamProfileSerializer(
request.user.profile.current_team).data
return Response(response)
def retrieve(self, request, pk=None):
"""
Fetch barcode and return serialized product
or serialized user.
"""
barcode, _ = Barcode.objects.get_or_create(number=pk)
# Return 404 if barcode is not associated
if not barcode.account and not barcode.product:
return Response({'error': 'Barcode not found.'},
status=404)
if barcode.account:
serializer = serializers.UserSerializer(barcode.account.user)
else:
serializer = serializers.ProductSerializer(barcode.product)
return Response(serializer.data)
def deposit(self, request, pk=None):
"""
Make deposit using the deposit serializer
"""
user = auth_models.User.objects.get(id=pk)
serializer = DepositSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
deposit = serializer.create(user)
# Serialize result and create response
user_serializer = serializers.UserSerializer(deposit['user'])
return Response({
"user": user_serializer.data,
"old_balance": str(deposit['old_balance']),
"new_balance": str(deposit['new_balance']),
})
def admin_detail(request):
'''
Retrieve, update or delete a admin instance.
检索、更新或删除管理员实例。
'''
ids = request.POST.get('ids')
id = request.POST.get('id')
if request.method == "DELETE":
print(id)
print(ids)
if ids:
try:
#批量删除
User.objects.extra(where=['id IN (' + ids[:-1] + ')']).delete()
return JsonResponse({"status": 200, "msg": "删除成功"})
except:
return JsonResponse({"status": 400, "msg": "删除失败"})
else:
try:
snippet = User.objects.get(id=id)
except User.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
snippet.delete()
return JsonResponse({"status": 200, "msg": "删除成功"})
if request.method == "PUT":
print(request.data)
try:
snippet = User.objects.get(id=id)
except User.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
serializer = serializers.UserSerializer(snippet, data=request.data)
if serializer.is_valid():
serializer.save()
return Response({"status": 200, "msg": "修改成功"})
return Response({"status": 400, "msg": "登录名重复,请检查表单"})
def post(self, request, *args, **kwargs):
request_data = request.data
# 数据是否合法（增加对象需要一个字典数据）
if not isinstance(request_data, dict) or request_data == {}:
return Response({'status': 1, 'msg': '数据有误'})
# 数据类型合法，但数据内容不一定合法，需要校验数据
user_ser = serializers.UserDeserializer(data=request_data)
if user_ser.is_valid():
# 校验通过，完成新增
user_obj = user_ser.save()
# print('user_obj', user_obj)
return Response({
'status':
0,
'msg':
'ok',
'results':
serializers.UserSerializer(user_obj).data
# 'results': ''
})
else:
# 校验失败
return Response({'status': 1, 'msg': user_ser.errors})
def test_serializers(self):
""" Test that serializers work """
def printJson(header, testSerializer):
print("---------------------------{}---------------------------".
format(header))
print(JsonResponse(testSerializer.data, safe=False))
print("\n")
acSerializer = s.AircraftSerializer(self.ac)
printJson("Aircraft Data", acSerializer)
spareSerializer = s.SpareSerializer(self.spare)
printJson("Spare Data", spareSerializer)
sDet = s.OutputSpareDetailSerializer(self.spareDetail)
printJson("Spare Detail Data", sDet)
userSerializer = s.UserSerializer(self.user)
printJson("User Data", userSerializer)
profileSerializer = s.ProfileSerializer(self.user.profile)
printJson("Normal Profile Data", profileSerializer)
techProfileSerializer = s.TechnicianSerializer(self.user.profile)
printJson("Technician Profile Data", techProfileSerializer)
updateSerializer = s.UpdateSerializer(self.testUpdate)
printJson("Update Data", updateSerializer)
defectSerializer = s.OutputDefectSerializer(self.defect)
printJson("Defect Data", defectSerializer)
def purchase(self, request, pk=None):
"""
Make purchase using the purchase serializer
"""
user = auth_models.User.objects.get(id=pk)
# Get purchase serializer
serializer = self.get_serializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
purchase = serializer.create(user)
# Create serializer for docs
user_serializer = serializers.UserSerializer(purchase['user'])
product_serializer = serializers.ProductSerializer(purchase['product'])
return Response({
"product": product_serializer.data,
"user": user_serializer.data,
"old_balance": str(purchase['old_balance']),
"new_balance": str(purchase['new_balance']),
})
def post(self, request, format=None):
body = json.loads(request.body)
serializer = serializers.UserSerializer(data=body)
serializer.is_valid()
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def admin_list(request):
'''
List all order, or create a server admin order.
'''
if request.method == "GET":
page = int(request.GET.get('page'))
limit = int(request.GET.get('limit'))
if page == 1:
stat = page - 1
end = page * limit
else:
stat = (page - 1) * limit
end = page * limit
# 直接展示表单
queryset = User.objects.order_by('id').all()
count = User.objects.order_by('id').all().count()
serializer = serializers.UserSerializer(queryset, many=True)
data = {
"code": 0,
"msg": '',
"count": count,
"data": serializer.data[stat:end]
}
return Response(data)
if request.method == "POST":
username = request.POST.get('username')
role = request.POST.get('role')
email = request.POST.get('email')
infopass = request.POST.get('infopass')
repass = request.POST.get('repass')
if infopass and repass:
if infopass != repass:
return JsonResponse({"status": 400, "msg": '密码不一致'})
try:
User.objects.get(username=username)
return JsonResponse({
"user": username,
"status": 400,
"msg": '用户已存在'
})
except:
if role == "general":
password = infopass
try:
User.objects.create_user(username,
email=email,
password=password)
except Exception as e:
return JsonResponse({"status": 400, "msg": e})
return JsonResponse({"status": 200, "msg": '增加成功'})
elif role == "super":
password = infopass
try:
User.objects.create_superuser(username,
email=email,
password=password)
except Exception as e:
return JsonResponse({"status": 400, "msg": e})
return JsonResponse({"status": 200, "msg": '增加成功'})
else:
return JsonResponse({{"status": 400, "msg": '密码不能为空'}})
def current_user(request):
"""
Determine the current user by their token, and return their data
"""
serializer = serializers.UserSerializer(request.user)
return Response(serializer.data)
