def test_update_user(self):
self.test_create_user()
username_to_update = 'updatedUserSerializer'
first_name_to_update = "UpdatedUser"
last_name_to_update = "UsingSerializer2"
user_data_to_update = {
'username': username_to_update,
'email': self.email,
'password': '******',
'first_name': first_name_to_update,
'last_name': last_name_to_update,
"profile": {
"role": Profile.PHYSICIAN
}
}
user_in_database = User.objects.get(email=self.email)
user_serialized = UserSerializer(instance=user_in_database,
data=user_data_to_update)
user_serialized_valid = user_serialized.is_valid()
user_created = user_serialized.save()
user_in_database_after_updated = User.objects.get(email=self.email)
self.assertTrue(user_serialized_valid)
self.assertEquals(user_in_database_after_updated, user_created)
self.assertEquals(user_in_database_after_updated.username,
username_to_update)
self.assertEquals(user_in_database_after_updated.first_name,
first_name_to_update)
self.assertEquals(user_in_database_after_updated.last_name,
last_name_to_update)
def register(self, request):
'''
Allows users to register themselves. Being then put on a waiting list to be approved.
'''
if request.user.is_authenticated():
return Response(
{
'error':
"An already registered user can't register new users!"
}, status.HTTP_400_BAD_REQUEST)
dataRequest = request.data.copy()
password = dataRequest.pop('password', None)
email = dataRequest.get('email', None)
if email != None and password != None:
email = email.lower()
try:
user = User.objects.get(email=email)
return Response(
{'error': "An user with this email already exists"},
status=status.HTTP_400_BAD_REQUEST)
except User.DoesNotExist:
if (not 'username' in dataRequest):
dataRequest['username'] = email[:30]
dataRequest['email'] = email
serializer = UserSerializer(data=dataRequest,
context={'request': request})
user_validated = serializer.is_valid(raise_exception=True)
if user_validated:
new_user = serializer.save()
new_user.set_password(password)
new_user.is_active = False
new_user.save()
staff = User.objects.filter(is_staff=True)
History.new(event=History.ADD,
actor=new_user,
object=new_user,
authorized=staff)
return Response(serializer.data,
status=status.HTTP_201_CREATED)
return Response({'error': "User details invalid"},
status=status.HTTP_400_BAD_REQUEST)
return Response(
{
'error':
"Email and password are mandatory fields on registering a new user"
},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format='json'):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
# generating tokens for the user
if user:
token = Token.objects.create(user=user)
json = serializer.data
json['token'] = token.key
print(token)
return Response(serializer.data,
status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
form = FileSerializer(data=request.data)
if form.is_valid():
input = form.save()
path = os.path.join(settings.MEDIA_ROOT, str(input.file))
workbook = xlrd.open_workbook(filename=path)
sheet = workbook.sheet_by_index(0)
if sheet.nrows < 2:
return Response({'message': 'There is no users in file'}, status=status.HTTP_400_BAD_REQUEST)
else:
for i in range(2, sheet.nrows):
student_id = sheet.cell(i, 0).value
last_name = sheet.cell(i, 1).value
first_name = sheet.cell(i, 2).value
major_string = sheet.cell(i, 4).value
email = sheet.cell(i, 6).value
if major_string.lower().strip() == 'программная инженерия':
major = Major.SE.name
else:
major = Major.AMI.name
username = email.split("@")[0].strip()
data = {
'username': username,
'first_name': first_name,
'last_name': last_name,
'email': email,
'password': student_id,
}
serialized = UserSerializer(data=data)
if serialized.is_valid():
user = serialized.save()
response = serialized.data
UserPreferences.objects.create(
user=user,
user_preference=Preference.STUDENT.name
)
UserMajor.objects.create(
user=user,
user_major=major
)
Mark.objects.create(user=user, first_name=user.first_name,
second_name=user.last_name,
major=major)
UserStudentID.objects.create(user=user, student_id=student_id)
del response['password']
del response['first_name']
del response['last_name']
return Response({"status": "OK"}, status=status.HTTP_201_CREATED)
def test_try_to_create_a_staff_user_trough_serializer(self):
email = '*****@*****.**'
user_data = {
'username': '******',
'email': email,
'password': '******',
'first_name': "CreatedStaffUser",
'last_name': "UsingSerializer",
'is_staff': True,
"profile": {
"role": Profile.NURSE
}
}
user_serialized = UserSerializer(data=user_data)
user_serialized_valid = user_serialized.is_valid()
user_created = user_serialized.save()
self.assertTrue(user_serialized_valid)
self.assertFalse(user_created.is_staff)
def test_create_user(self):
user_data = {
'username': '******',
'email': self.email,
'password': '******',
'first_name': "CreatedUser",
'last_name': "UsingSerializer",
"profile": {
"role": Profile.NURSE
}
}
user_serialized = UserSerializer(data=user_data)
user_serialized_valid = user_serialized.is_valid()
user_created = user_serialized.save()
user_in_database = User.objects.get(email=self.email)
self.assertTrue(user_serialized_valid)
self.assertEquals(user_in_database, user_created)
self.assertFalse(user_in_database.is_active)
def create_users(self):
"""
Create ordinary Users.
"""
prompt(_(u'Create the users (%d)' % self._total_users))
for item in RandomItemSupplier(self._total_users):
user_serializer = UserSerializer(data=item)
if user_serializer.is_valid():
user_data = user_serializer.data
user_data['is_staff'] = False
user_data['is_active'] = True
user_data['password'] = RandomItemSupplier.USER_PASSWORD
user = self.create_user_by_api(**user_data)
if user:
self._users.append(user)
item['user'] = user.pk
person_serializer = PersonSerializer(data=item)
if person_serializer.is_valid():
person_data = person_serializer.data
person = self.create_person_by_api(**person_data)
if person:
self._persons.append(person)
info(_(u'Done'))
def post(self, request, format=None):
serializer = 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)