def update_user_info(request):
request.data['contact'] = request.user.contact
# keep contact inviriant, password is automatically safe
serializer = UserSerializer(request.user, data=request.data)
if serializer.is_valid():
serializer.save()
return CostaResponse('0', 'OK')
def add_update(data):
'''
@summary: add (if no) or update a user record.
@parm data: a dict for the User's serializer.
@return: None.
'''
try:
user = User.objects.get(openid=data['openid'])
user_se = UserSerializer(user, data=data, partial=True)
except User.DoesNotExist:
user_se = UserSerializer(data=data)
if user_se.is_valid():
user_se.save()
def post(self, request, format=None):
"""
create User
"""
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
return Response(serializer.data,
status=status.HTTP_201_CREATED)
else:
return Response(status=status.HTTP_501_NOT_IMPLEMENTED)
return Response(status=status.HTTP_406_NOT_ACCEPTABLE,
data=serializer.errors)
def signup(request, format=None):
if request.method == 'POST':
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
digits = [i for i in range(0, 10)]
random_str = ""
for i in range(6):
index = math.floor(random.random() * 10)
random_str += str(digits[index])
serializer.save()
newdict = {'otp': random_str}
newdict.update(serializer.data)
return Response(newdict, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_add_user():
data = {
"username": "******",
"email": "*****@*****.**",
"first_name": "Test",
"last_name": "Test",
"password": "******",
"confirm_password": "******",
}
serializer = UserSerializer(data=data)
assert serializer.is_valid() is True
instance = serializer.save()
assert instance.username == "test"
def ppost(self, request, *args, **kwargs):
import json
print(json.dumps(request.data, indent=2))
#serializer = self.get_serializer(data=request.data)
#serializer = UserSerializer.objects.create_user(**request.data)
#user = get_user_model().objects.create_user(email="*****@*****.**",
# password="******")
print("after user")
serializer = UserSerializer(data=request.data)
print("created serializer")
try:
serializer.is_valid(raise_exception=True)
except exceptions as e:
print("Exception:%s" % e.strerror)
print("serializer_isvalid")
#self.perform_create(serializer)
serializer.save()
print("serializer.data:", json.dumps(serializer.data, indent=2))
headers = self.get_success_headers(serializer.data)
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=headers)
def create_empty_user(request):
data = {
'name': '',
'clock': None,
'token': '',
'drinking': False,
'smoking': False
}
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def update(self, request, pk):
"""
Updates a User with the given data
:param request: HttpRequest
:param pk: User primary key
:return: Response
"""
user = get_object_or_404(User, pk=pk)
self.check_object_permissions(request, user)
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
user = serializer.save()
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
user_token = request.data['token']
res = self.debug_token(user_token)
sns_id = res['data']['user_id']
try:
user = User.objects.get(sns_type='facebook', sns_id=sns_id)
# token 갱신
data = {'sns_access_token': user_token}
serializer = UserSerializer(user, data=data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(response_data(True, serializer.data))
else:
return Response(response_data(False, 'FB 토큰 갱신 에러'))
except User.DoesNotExist:
return Response(response_data(True, None))
def post(self, request, format=None):
#查看注册权限是否打开
if not getRegisterPermission(request):
return Response("Registration not open!",
status=HTTP_400_BAD_REQUEST)
data = request.data.copy()
username = data.get('username')
#查看用户注册用户名是否重名
if User.objects.filter(username=username):
return Response("The username already exists!", status=HTTP_200_OK)
data['type'] = UserType.REGULAR_USER
serializer = UserSerializer(data=data)
if serializer.is_valid(raise_exception=True):
serializer.save()
return Response(serializer.data, status=HTTP_200_OK)
return Response(serializer.errors, status=HTTP_400_BAD_REQUEST)
def user_list(request):
if request.method == 'GET':
user = User.objects.all()
user_serializer = UserSerializer(user, many=True)
return JsonResponse(user_serializer.data, safe=False)
# In order to serialize objects, we must set 'safe=False'
elif request.method == 'POST':
user_data = JSONParser().parse(request)
user_serializer = UserSerializer(data=user_data)
if user_serializer.is_valid():
user_serializer.save()
return JsonResponse(user_serializer.data,
status=status.HTTP_201_CREATED)
return JsonResponse(user_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
data = serializer.validated_data
try:
okta_user_id = create_okta_user(data)
send_email(data['email'], okta_user_id)
serializer.save(okta_id=okta_user_id)
return JsonResponse({"result": {"okta_user_id": okta_user_id}},
status=status.HTTP_201_CREATED)
except Exception as e:
return JsonResponse({"result": {'error': e.args[0]}},
status=status.HTTP_400_BAD_REQUEST)
return JsonResponse({"result": {'error': serializer.errors}},
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, format=None):
old_password = request['PUT']['old_password']
if not request.user.check_password(old_password):
return Response(status=status.HTTP_406_NOT_ACCEPTABLE,
data='이전 비밀번호가 맞지 않습니다.')
serializer = UserSerializer(request.user,
data=request.data,
partial=True)
if serializer.is_valid(raise_exception=True):
account = serializer.save()
if account:
return Response(status=status.HTTP_202_ACCEPTED,
data=serializer.data)
return Response(status=status.HTTP_501_NOT_IMPLEMENTED)
return Response(status=status.HTTP_406_NOT_ACCEPTABLE,
data=serializer.errors)
def create(self, request, *args, **kwargs):
username = request.data.get("username", None)
password = request.data.get("password", None)
lang = request.data.get("lang", 'fa')
user_serializer = UserSerializer(data={
"username": username,
"password": password
},
context={"request": request})
if user_serializer.is_valid():
user = user_serializer.save()
if password:
user.set_password(password)
user.save()
profile = UserProfile.objects.create(user=user, lang=lang)
return Response(self.serializer_class(profile).data)
else:
return Response(status=400)
def create(self, request, format=None):
content = request.data
user = User.objects.create(
first_name=content.get("first_name"),
surname=content.get("surname"),
email=content.get("email"),
date_of_birth=content.get("date_of_birth"),
phone=content.get("phone"),
country_code_lookup=content.get("country_code_lookup"),
gender=content.get("gender"),
password=content.get("password"))
user.save()
serializer = UserSerializer(data=content)
if serializer.is_valid():
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_404_NOT_FOUND)
def user_detail(request, pk):
# find user by pk (id)
try:
user = User.objects.get(pk=pk)
if request.method == 'GET':
user_serializer = UserSerializer(user)
return JsonResponse(user_serializer.data)
elif request.method == 'PUT':
user_serializer = UserSerializer(user, data=request.data)
if user_serializer.is_valid():
user_serializer.save()
return JsonResponse(user_serializer.data)
return JsonResponse(user_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
user.delete()
return JsonResponse({'message': 'User was deleted successfully!'}, status=status.HTTP_204_NO_CONTENT)
except User.DoesNotExist:
return JsonResponse({'message': 'The User does not exist'}, status=status.HTTP_404_NOT_FOUND)
def post(self, request, format=None):
user_data = {
"username": request.data["email"].split('@')[0],
"email": request.data["email"],
"password": request.data["password"],
}
print(user_data)
user = User.objects.create_user(username=user_data["username"],
email=user_data["email"],
password=user_data["password"])
print('holal', user.username)
serializer = UserSerializer(data=user)
if serializer.is_valid():
serializer.save()
return Response({
'status': 'ok',
'descripcion': 'usuario creado'
},
status=status.HTTP_201_CREATED)
def post(self, request):
data = request.data
user = self.get_user(data['user_id'])
if isinstance(user, Response):
return user
try:
int(data['score_worth'])
except ValueError:
return Response({'message': 'Invalid score type.'},
status=status.HTTP_400_BAD_REQUEST)
if int(data['score_worth']) < 0:
return Response({'message': 'Score can not be a negative number.'},
status=status.HTTP_400_BAD_REQUEST)
# first submits the score, then calculates the new rank of the user
# and returns the updates values of the user.
pipeline = redis_instance.pipeline()
pipeline.zadd(set_name, {data['user_id']: data['score_worth']},
incr=True)
pipeline.zrevrank(set_name, data['user_id'])
pipeline.zadd(user.country, {data['user_id']: data['score_worth']},
incr=True)
pipeline.zrevrank(user.country, data['user_id'])
pipeline.zscore(user.country, data['user_id'])
pipeline_values = pipeline.execute()
data = {
'rank': int(pipeline_values[1]) + 1,
'points': int(pipeline_values[4]),
'country_rank': int(pipeline_values[3]) + 1,
}
# saves the updated rank and score of the user to the database.
serializer = UserSerializer(user,
data=data,
context={'request': request},
partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request, *args, **kwargs):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
token, created = Token.objects.get_or_create(
user=serializer.instance)
return_serializer = UserSerializer(user)
view_format = {
'status_code': status.HTTP_201_CREATED,
'data': {
'user': return_serializer.data,
'token': token.key
}
}
return Response(view_format, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_post_employee(request):
# get all employee
if request.method == 'GET':
employees = User.objects.all()
serializer = UserSerializer(employees, many=True)
return Response(serializer.data)
# insert a new record for a employee
if request.method == 'POST':
data = {
"uid": request.data.get('uid'),
"uname": request.data.get('uname'),
"uemail": request.data.get('uemail'),
"upassword": request.data.get('upassword'),
"ucontact": request.data.get('ucontact')
}
serializer = UserSerializer(data=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 list_of_users(request):
if request.method == 'GET':
users = Person.objects.all()
serializer = PersonSerializer(users, many=True)
return Response(serializer.data)
elif request.method == 'POST':
u_serializer = UserSerializer(data=request.data.get("user"))
if u_serializer.is_valid():
u_serializer.save()
data = request.data
rating = Rating.objects.create()
data['user_id'] = u_serializer.data.get("id")
data['rating_id'] = rating.id
p_serializer = PersonSerializer(data=data)
if p_serializer.is_valid():
p_serializer.save()
return Response(p_serializer.data, status=status.HTTP_201_CREATED)
return Response(p_serializer.errors, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
return Response(status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request, *args, **kwargs): # pylint: disable=unused-argument
"""
Defines HTTP POST method for Register Endpoint
"""
serializer = UserSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
user = User.objects.create_user(serializer.initial_data['email'],
serializer.initial_data['password'],
first_name=serializer.initial_data['first_name'],
last_name=serializer.initial_data['last_name'],
is_vendor=serializer.initial_data['is_vendor'])
token = create_jwt(user)
return Response({
'token': token,
'user': serializer.data,
}, status=status.HTTP_201_CREATED)
def put(self, request, *args, **kwargs):
"""
Updates the parameters of the user
"""
try:
data = request.data.copy() #Request.data is immutable
user = CustomUser.objects.get(pk=request.user.id)
if not data.__contains__("username"):
data["username"] = getattr(user, "username")
serializer = UserSerializer(user, data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
else:
data['error'] = serializer.errors
return Response(data=data, status=status.HTTP_204_NO_CONTENT)
except CustomUser.DoesNotExist:
data = {}
data["error"] = "Sorry but you don't exist"
raise ValidationError(data)
def check_user(self, data):
"""
Check if there is a user with that email, otherwise it creates it
:param data: Information of the user
:return: User
"""
email = data.get('email', '')
user_data = {
'email': email,
'phone': data.get('phone', ''),
'address': data.get('address', '')
}
user = User.objects.filter(email=email).first()
serializer = UserSerializer(
user, data=user_data) if user else UserSerializer(data=user_data)
if serializer.is_valid():
user = serializer.save()
return user, serializer.data
else:
return Response(serializer.error_messages,
status=status.HTTP_400_BAD_REQUEST)
def user_detail(request, pk, format=None):
"""
Retrieve, update or delete a code item.
"""
try:
user1 = user.objects.get(user_id=pk)
except user.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = UserSerializer(user1)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = UserSerializer(user1, 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':
user1.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def get_delete_update_employee(request, pk):
try:
user = User.objects.get(pk=pk)
except User.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
# get details of a single employee
if request.method == 'GET':
serializer = UserSerializer(user)
return Response(serializer.data)
# update details of a single employee
if request.method == 'PUT':
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_204_NO_CONTENT)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
# delete a single employee
if request.method == 'DELETE':
user.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def createInactive(request):
email = request.POST.get('email')
password = request.POST.get('password')
if not email:
return Response({'response': 'error', 'message': 'No data found'})
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
saved_user = serializer.save()
current_site = get_current_site(request)
mail_subject = 'Activate your account.'
message = render_to_string(
'../templates/core/acc_active_email.html', {
'email': email,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(
saved_user.email)),
'token': account_activation_token.make_token(saved_user),
})
emailToBeSent = EmailMessage(mail_subject, message, to=[email])
emailToBeSent.send()
res = messages.info(
request,
'Please confirm your email address to complete registration')
return Response(request.data,
status=201,
template_name='ct/caloriestracker.html')
else:
messages.error(request, 'Invalid credentials')
return Response(request.data,
status=400,
template_name='ct/caloriestracker.html')
#return Response({"response" : "error", "message" : serializer.errors})
#return Response({"response" : "success", "message" : "user created succesfully"})
messages.success(request, 'That went swwwwimmingly')
return redirect('caloriestracker')
def user_detail(request, pk, format=None):
"""
Retrieve, update or delete a user detail.
"""
try:
user = User.objects.get(pk=pk)
except User.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = UserSerializer(user)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = UserSerializer(user, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
user.active = False
user.save()
return Response(status=status.HTTP_204_NO_CONTENT)
def participant(self, request):
username = request.data.get('username')
password = request.data.get('password')
user = authenticate(request, username=username, password=password)
if user:
login(request, user)
user_serializer = UserSerializer(user, data=request.data)
# auth = request.data.get('auth')
auth_obj = UserAuth.objects.get(user=user)
if auth_obj.role == "participant":
return Response(
{"error": "A Participant cannot add his own new role."},
status=status.HTTP_400_BAD_REQUEST)
elif (auth_obj.role == "instructor") ^ (
auth_obj.role == "participant and instructor"):
UserAuth.objects.filter(user=user).update(
role="participant and instructor")
auth_obj.save()
participant_data = request.data.get('participant')
ParticipantProfile.objects.update_or_create(
user=user, defaults=participant_data)
if user_serializer.is_valid():
user_serializer.save()
return Response(user_serializer.data,
status=status.HTTP_201_CREATED)
else:
return Response(user_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
return Response({"error": "Wrong username or wrong password"},
status=status.HTTP_403_FORBIDDEN)
def user_list(request):
# GET list of User, POST a new User, DELETE all User
if request.method == 'GET':
user = User.objects.all()
name = request.GET.get('name', None)
if name is not None:
user = user.filter(name__icontains=name)
user_serializer = UserSerializer(user, many=True)
return JsonResponse(user_serializer.data, safe=False)
# 'safe=False' for objects serialization
elif request.method == 'POST':
# user_data = JSONParser().parse(request)
user_serializer = UserSerializer(data=request.data)
if user_serializer.is_valid():
user_serializer.save()
return JsonResponse(user_serializer.data, status=status.HTTP_201_CREATED)
return JsonResponse(user_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
count = User.objects.all().delete()
return JsonResponse({'message': '{} User was/were deleted successfully!'.format(count[0])}, status=status.HTTP_204_NO_CONTENT)
def test_user_serializer(self):
# write
data = {
'username': '******',
'password': '******',
'identity_document_number': 'B875013(6)',
}
serializer = UserSerializer(data=data)
serializer.is_valid(raise_exception=True)
user = serializer.save()
self.assertEqual(user.username, 'foo')
self.assertEqual(user.identity_document_number, 'B875013(6)')
# duplicated username
data = {
'username': '******',
'password': '******',
'identity_document_number': 'B875013(6)',
}
serializer = UserSerializer(data=data)
with self.assertRaises(ValidationError):
serializer.is_valid(raise_exception=True)
# invalid identity document number
data = {
'username': '******',
'password': '******',
'identity_document_number': 'B875013(0)',
}
serializer = UserSerializer(data=data)
with self.assertRaises(ValidationError):
serializer.is_valid(raise_exception=True)
# read
serializer = UserSerializer(user)
with self.assertRaises(NotImplementedError):
_ = serializer.data
def addUser(request): # 添加数据
ser = UserSerializer(data=request.data)
if ser.is_valid():
ser.save()
return Response(ser.data)
return Response(ser.errors)
