def test_empty_string_userprofile_creates_nonexistent_custom_fields(self):
# If a user profile is submitted that contains empty string custom
# fields that didn't exist previously, in that case those fields should
# be created with the empty value
user = User.objects.get(username='******')
# remove user custom fields
CustomField.objects.create(id='extra',
type='str',
required=True,
label='Required')
UserProfileCustomField.objects.filter(user=user).delete()
self.assertEqual(
UserProfileCustomField.get_user_value(user, 'country'), None)
self.assertEqual(UserProfileCustomField.get_user_value(user, 'extra'),
None)
self.client.force_login(self.admin_user)
with open(self.activity_with_empty_userinfo, 'rb') as alf:
response = self.client.post(self.url, {'activity_log_file': alf})
# should be redirected to the success page
self.assert_redirects_success(response)
# "extra" field is required, so the CustomField is created anyway
self.assertEqual(UserProfileCustomField.get_user_value(user, 'extra'),
'')
# Country field is not required, so is not created with an empty value
self.assertEqual(
UserProfileCustomField.get_user_value(user, 'country'), None)
def test_empty_userprofile_doesnt_update_fields(self):
user = User.objects.get(username='******')
userprofile = UserProfile.objects.get(user=user)
userprofile.phone_number = '123456789'
userprofile.organisation = 'home'
userprofile.save()
self.client.force_login(self.admin_user)
with open(self.basic_activity_log, 'rb') as activity_log_file:
response = self.client.post(
self.url, {'activity_log_file': activity_log_file})
# should be redirected to the success page
self.assert_redirects_success(response)
userprofile = UserProfile.objects.get(user=user)
self.assertEqual(userprofile.phone_number, '123456789')
self.assertEqual(userprofile.organisation, 'home')
self.assertEqual(
UserProfileCustomField.get_user_value(user, 'country'), 'FI')
self.assertEqual(
UserProfileCustomField.get_user_value(user, 'agree_to_terms'),
None)
def test_edit_profile_not_req_str_change(self):
custom_field = CustomField(id='str_not_req',
label='String not required',
required=False,
type='str')
custom_field.save()
upcf = UserProfileCustomField(key_name=custom_field,
user=self.normal_user,
value_str="my string")
upcf.save()
self.client.force_login(self.normal_user)
post_data = {
'organisation': self.normal_user.userprofile.organisation,
'email': self.normal_user.email,
'username': self.normal_user.username,
'first_name': self.normal_user.first_name,
'last_name': self.normal_user.last_name,
'str_not_req': "my new string"
}
count_start = UserProfileCustomField.objects.all().count()
response = self.client.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200)
count_end = UserProfileCustomField.objects.all().count()
self.assertEqual(count_start, count_end)
updated_row = UserProfileCustomField.objects.get(key_name=custom_field,
user=self.normal_user)
self.assertEqual(updated_row.value_str, "my new string")
def test_edit_profile_req_bool_no_change(self):
custom_field = CustomField(id='bool_req',
label='Boolean required',
required=True,
type='bool')
custom_field.save()
upcf = UserProfileCustomField(key_name=custom_field,
user=self.normal_user,
value_bool=True)
upcf.save()
self.client.force_login(self.normal_user)
post_data = {
'organisation': self.normal_user.userprofile.organisation,
'email': self.normal_user.email,
'username': self.normal_user.username,
'first_name': self.normal_user.first_name,
'last_name': self.normal_user.last_name,
'bool_req': True
}
count_start = UserProfileCustomField.objects.all().count()
response = self.client.post(self.url, data=post_data)
self.assertEqual(response.status_code, 200)
count_end = UserProfileCustomField.objects.all().count()
self.assertEqual(count_start, count_end)
updated_row = UserProfileCustomField.objects.get(key_name=custom_field,
user=self.normal_user)
self.assertEqual(updated_row.value_bool, True)
def test_edit_profile_req_bool_no_change(self):
custom_field = CustomField(id='bool_req',
label='Boolean required',
required=True,
type='bool')
custom_field.save()
upcf = UserProfileCustomField(key_name=custom_field,
user=self.user,
value_bool=True)
upcf.save()
post_data = self.base_data.copy()
post_data['bool_req'] = True
count_start = UserProfileCustomField.objects.all().count()
response = self.api_client.post(self.url,
format='json',
data=post_data,
authentication=self.get_credentials())
self.assertHttpCreated(response)
count_end = UserProfileCustomField.objects.all().count()
self.assertEqual(count_start, count_end)
updated_row = UserProfileCustomField.objects.get(key_name=custom_field,
user=self.user)
self.assertEqual(updated_row.value_bool, True)
def test_existing_user_empty_fields_override(self):
self.client.force_login(user=self.admin_user)
with open(self.all_fields, 'rb') as upload_user_file:
upload_file = SimpleUploadedFile(upload_user_file.name,
upload_user_file.read())
user = User.objects.get(username='******')
# Remove any existing field
UserProfileCustomField.objects.filter(user=user).delete()
self.client.post(self.url, {
'upload_file': upload_file,
'only_update': False
})
user = User.objects.get(username='******')
profile = UserProfile.objects.get(user=user)
self.assertEqual(user.first_name, 'UpdatedName')
self.assertEqual(user.last_name, 'UpdatedLastname')
self.assertEqual(profile.phone_number, '555555555')
self.assertEqual(
UserProfileCustomField.get_user_value(user, 'country'), 'Portugal')
self.assertEqual(
UserProfileCustomField.get_user_value(user, 'agree_to_terms'),
True)
self.assertEqual(UserProfileCustomField.get_user_value(user, 'age'),
99)
def test_wrong_type_int_in_str(self):
custom_field = CustomField(id='str',
label='String',
required=True,
type='str')
custom_field.save()
upcf = UserProfileCustomField(key_name=custom_field,
user=self.normal_user,
value_str=123)
upcf.save()
self.assertEqual(123, upcf.get_value())
def test_wrong_type_int_in_bool_1(self):
custom_field = CustomField(id='bool',
label='Boolean',
required=True,
type='bool')
custom_field.save()
upcf = UserProfileCustomField(key_name=custom_field,
user=self.normal_user,
value_bool=1)
upcf.save()
self.assertEqual(1, upcf.get_value())
def test_user_custom_field_model_name(self):
custom_field = CustomField(id='str',
label='String',
required=True,
type='str')
custom_field.save()
upcf = UserProfileCustomField(key_name=custom_field,
user=self.normal_user,
value_str=self.VALUE_STR_DEFAULT)
upcf.save()
self.assertEqual('str: demo', str(upcf))
def test_existing_user_nonempty_fields_only_update(self):
self.client.force_login(user=self.admin_user)
with open(self.all_fields, 'rb') as upload_user_file:
upload_file = SimpleUploadedFile(upload_user_file.name,
upload_user_file.read())
user = User.objects.get(username='******')
user.first_name = 'firstname'
user.last_name = 'lastname'
user.save()
profile = UserProfile.objects.get(user=user)
profile.phone_number = '000000000'
profile.save()
# Remove any existing custom field
UserProfileCustomField.objects.filter(user=user).delete()
UserProfileCustomField.objects.create(
user=user,
key_name=CustomField.objects.get(id='country'),
value_str='Spain')
UserProfileCustomField.objects.create(
user=user,
key_name=CustomField.objects.get(id='agree_to_terms'),
value_bool=False)
UserProfileCustomField.objects.create(
user=user,
key_name=CustomField.objects.get(id='age'),
value_int=30)
self.client.post(self.url, {
'upload_file': upload_file,
'only_update': True
})
user = User.objects.get(username='******')
profile = UserProfile.objects.get(user=user)
self.assertEqual(user.first_name, 'firstname')
self.assertEqual(user.last_name, 'lastname')
self.assertEqual(profile.phone_number, '000000000')
self.assertEqual(
UserProfileCustomField.get_user_value(user, 'country'), 'Spain')
self.assertEqual(
UserProfileCustomField.get_user_value(user, 'agree_to_terms'),
False)
self.assertEqual(UserProfileCustomField.get_user_value(user, 'age'),
30)
def test_userprofile_updated(self):
self.client.force_login(self.admin_user)
with open(self.activity_with_userinfo, 'rb') as activity_log_file:
response = self.client.post(self.url,
{'activity_log_file':
activity_log_file})
# should be redirected to the success page
self.assert_redirects_success(response)
user = User.objects.get(username='******')
userprofile = UserProfile.objects.get(user=user)
self.assertEqual(userprofile.phone_number, '123456789')
self.assertEqual(userprofile.organisation, 'home')
self.assertEqual(UserProfileCustomField.get_user_value(user, 'country'), 'ES')
self.assertEqual(UserProfileCustomField.get_user_value(user, 'agree_to_terms'), True)
def test_wrong_type_bool_in_int(self):
custom_field = CustomField(id='int',
label='Integer',
required=True,
type='int')
custom_field.save()
upcf = UserProfileCustomField(key_name=custom_field,
user=self.normal_user,
value_int=True)
upcf.save()
self.assertEqual(True, upcf.get_value())
upcf.value_int = False
upcf.save()
self.assertEqual(False, upcf.get_value())
def test_wrong_type_str_in_int(self):
custom_field = CustomField(id='int',
label='Integer',
required=True,
type='int')
custom_field.save()
with self.assertRaises(ValueError):
UserProfileCustomField(key_name=custom_field,
user=self.normal_user,
value_int=self.VALUE_STR_DEFAULT).save()
def test_wrong_type_str_in_bool(self):
custom_field = CustomField(id='bool',
label='Boolean',
required=True,
type='bool')
custom_field.save()
with self.assertRaises(ValidationError):
UserProfileCustomField(key_name=custom_field,
user=self.normal_user,
value_bool=self.VALUE_STR_DEFAULT).save()
def test_custom_fields(self):
self.client.force_login(user=self.admin_user)
with open(self.custom_fields, 'rb') as upload_user_file:
upload_file = SimpleUploadedFile(upload_user_file.name,
upload_user_file.read())
user_count_start = User.objects.all().count()
self.client.post(self.url, {'upload_file': upload_file,
'only_update': True})
user_count_end = User.objects.all().count()
self.assertEqual(user_count_start+2, user_count_end)
# check the user data
user100 = User.objects.get(username='******')
self.assertEqual(user100.userprofile.phone_number, "+0123456789")
self.assertEqual(UserProfileCustomField.get_user_value(
user100, 'country'), "Sweden")
self.assertEqual(UserProfileCustomField.get_user_value(
user100, 'age'), 24)
self.assertTrue(UserProfileCustomField.get_user_value(
user100, 'agree_to_terms'))
user101 = User.objects.get(username='******')
self.assertEqual(user101.userprofile.phone_number, "+987654321")
self.assertEqual(UserProfileCustomField.get_user_value(
user101, 'country'), "Iceland")
self.assertEqual(UserProfileCustomField.get_user_value(
user101, 'age'), 30)
self.assertFalse(UserProfileCustomField.get_user_value(
user101, 'agree_to_terms'))
def test_custom_field_multiple_rows(self):
custom_field = CustomField(id='str',
label='String',
required=True,
type='str')
custom_field.save()
upcf = UserProfileCustomField(key_name=custom_field,
user=self.normal_user,
value_str=self.VALUE_STR_DEFAULT)
upcf.save()
with self.assertRaises(IntegrityError):
upcf = UserProfileCustomField(key_name=custom_field,
user=self.normal_user,
value_str="my other string")
upcf.save()
def test_edit_profile_not_req_str_change(self):
custom_field = CustomField(id='str_not_req',
label='String not required',
required=False,
type='str')
custom_field.save()
upcf = UserProfileCustomField(key_name=custom_field,
user=self.user,
value_str="my string")
upcf.save()
post_data = self.base_data.copy()
post_data['str_not_req'] = "my new string"
count_start = UserProfileCustomField.objects.all().count()
response = self.api_client.post(self.url,
format='json',
data=post_data,
authentication=self.get_credentials())
self.assertHttpCreated(response)
count_end = UserProfileCustomField.objects.all().count()
self.assertEqual(count_start, count_end)
updated_row = UserProfileCustomField.objects.get(key_name=custom_field,
user=self.user)
self.assertEqual(updated_row.value_str, "my new string")
def test_edit_profile_req_bool_change(self):
custom_field = CustomField(id='bool_req',
label='Boolean required',
required=True,
type='bool')
custom_field.save()
upcf = UserProfileCustomField(key_name=custom_field,
user=self.normal_user,
value_bool=True)
upcf.save()
self.client.force_login(self.normal_user)
post_data = {
'organisation': self.normal_user.userprofile.organisation,
'email': self.normal_user.email,
'username': self.normal_user.username,
'first_name': self.normal_user.first_name,
'last_name': self.normal_user.last_name,
'bool_req': False
}
count_start = UserProfileCustomField.objects.all().count()
self.client.post(self.url, data=post_data)
self.assertRaises(ValidationError)
count_end = UserProfileCustomField.objects.all().count()
self.assertEqual(count_start, count_end)
def handle(self, *args, **options):
custom_fields = CustomField.objects.all()
with open(options['filepath'], newline='') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
# check the user exists in db
try:
user = User.objects.get(username=row.get('username'))
except User.DoesNotExist:
print("user not found: ", row.get('username'))
continue
# update phone no
user_profile = UserProfile.objects.get(user=user)
if user_profile.phone_number == "" or user_profile.phone_number is None:
user_profile.phone_number = row.get('phone_number')
user_profile.save()
print("%s: phone_number updated to %s" %
(row.get("username"), row.get('phone_number')))
for cf in custom_fields:
try:
upcf = UserProfileCustomField.objects.get(
user=user, key_name=cf.id)
except UserProfileCustomField.DoesNotExist:
upcf = UserProfileCustomField(user=user, key_name=cf)
print("%s: adding customfield record for %s" %
(row.get("username"), cf.id))
if cf.type == 'str' and (upcf.value_str is None
or upcf.value_str == ""):
upcf.value_str = row.get(cf.id)
upcf.save()
print("%s: %s updated to %s" %
(row.get("username"), cf.id, row.get(cf.id)))
if cf.type == 'int' and (upcf.value_int is None
or upcf.value_int == ""):
upcf.value_int = row.get(cf.id)
upcf.save()
print("%s: %s updated to %s" %
(row.get("username"), cf.id, row.get(cf.id)))
def test_custom_field_get_value_bool(self):
custom_field = CustomField(id='bool',
label='Boolean',
required=True,
type='bool')
custom_field.save()
upcf = UserProfileCustomField(key_name=custom_field,
user=self.normal_user,
value_bool=True)
upcf.save()
self.assertEqual(upcf.get_value(), True)
self.assertNotEqual(upcf.get_value(), "True")
self.assertNotEqual(upcf.get_value(), 123)
self.assertNotEqual(upcf.get_value(), False)
self.assertNotEqual(upcf.get_value(), None)
def test_custom_field_get_value_int(self):
custom_field = CustomField(id='int',
label='Integer',
required=True,
type='int')
custom_field.save()
upcf = UserProfileCustomField(key_name=custom_field,
user=self.normal_user,
value_int=123)
upcf.save()
self.assertEqual(upcf.get_value(), 123)
self.assertNotEqual(upcf.get_value(), "123")
self.assertNotEqual(upcf.get_value(), True)
self.assertNotEqual(upcf.get_value(), False)
self.assertNotEqual(upcf.get_value(), None)
def register_form_process(self, form):
# Create new user
username = form.cleaned_data.get("username")
email = form.cleaned_data.get("email")
password = form.cleaned_data.get("password")
first_name = form.cleaned_data.get("first_name")
last_name = form.cleaned_data.get("last_name")
user = User.objects.create_user(username, email, password)
user.first_name = first_name
user.last_name = last_name
user.save()
# create UserProfile record
UserProfile.objects.create(
user = user,
job_title =form.cleaned_data.get("job_title"),
organisation =form.cleaned_data.get("organisation")
)
# save any custom fields
custom_fields = CustomField.objects.all()
for custom_field in custom_fields:
if custom_field.type == 'int':
profile_field = UserProfileCustomField(
key_name=custom_field,
user=user,
value_int=form.cleaned_data.get(custom_field.id))
elif custom_field.type == 'bool':
profile_field = UserProfileCustomField(
key_name=custom_field,
user=user,
value_bool=form.cleaned_data.get(custom_field.id))
else:
profile_field = UserProfileCustomField(
key_name=custom_field,
user=user,
value_str=form.cleaned_data.get(custom_field.id))
if (form.cleaned_data.get(custom_field.id) is not None
and form.cleaned_data.get(custom_field.id) != '') \
or custom_field.required is True:
profile_field.save()
def test_custom_field_get_value_str(self):
custom_field = CustomField(id='str',
label='String',
required=True,
type='str')
custom_field.save()
upcf = UserProfileCustomField(key_name=custom_field,
user=self.normal_user,
value_str=self.VALUE_STR_DEFAULT)
upcf.save()
self.assertEqual(upcf.get_value(), self.VALUE_STR_DEFAULT)
self.assertNotEqual(upcf.get_value(), True)
self.assertNotEqual(upcf.get_value(), False)
self.assertNotEqual(upcf.get_value(), None)
self.assertNotEqual(upcf.get_value(), 123)
def process_register_custom_fields(self, bundle):
custom_fields = CustomField.objects.all()
for custom_field in custom_fields:
try:
value = bundle.data[custom_field.id]
except KeyError:
continue
if custom_field.type == 'int':
profile_field = UserProfileCustomField(key_name=custom_field,
user=bundle.obj,
value_int=value)
elif custom_field.type == 'bool':
profile_field = UserProfileCustomField(key_name=custom_field,
user=bundle.obj,
value_bool=value)
else:
profile_field = UserProfileCustomField(key_name=custom_field,
user=bundle.obj,
value_str=value)
if (value is not None
and value != '') \
or custom_field.required is True:
profile_field.save()
