def test_assign_multiple_roles(self):
user = self.user
assign_role(user, ShoRole1)
assign_role(user, ShoRole2)
self.assertListEqual([ShoRole1, ShoRole2], get_user_roles(user))
def save_assign_role_to_user(sender, instance, **kwargs): # pylint: disable=unused-argument
"""
Signal handler to assign a logical role to an user every time
the same role is assigned to an user for a program
"""
log.debug(
'assigning role %s to user %s',
instance.role,
instance.user.username,
)
assign_role(instance.user, instance.role)
def test_ensure_user_roles_are_in_order(self):
user = self.user
assign_role(user, ShoRole2)
assign_role(user, ShoRole4)
assign_role(user, ShoRole1)
assign_role(user, ShoRole3)
self.assertListEqual([ShoRole3, ShoRole1, ShoRole2, ShoRole4], get_user_roles(user))
def handle(self, *args, **options):
# Sync auth.Group with current registered roles (leaving existing groups intact!)
for role in roles.RolesManager.get_roles():
group, created = role.get_or_create_group()
if created:
self.stdout.write("Created Group: %s from Role: %s" % (group.name, role.get_name()))
# Sync auth.Permission with permissions for this role
role.get_default_true_permissions()
if options.get('reset_user_permissions', False): # dj1.7 compat
# Push any permission changes made to roles and remove any unregistered roles from all auth.Users
self.stdout.write("Resetting permissions for ALL Users to defaults defined by roles.")
for user in get_user_model().objects.all():
user_roles = roles.get_user_roles(user=user)
roles.clear_roles(user=user)
for role in user_roles:
roles.assign_role(user=user, role=role)
def test_dont_return_non_role_groups(self):
user = self.user
assign_role(user, ShoRole1)
assign_role(user, ShoRole2)
assign_role(user, ShoRole3)
assign_role(user, ShoRole4)
other_group = mommy.make(Group)
user.groups.add(other_group)
self.assertNotIn(other_group, get_user_roles(user))
def test_remove_role_reinstates_permissions_correctly_scenario_2(self):
"""
Initial Roles:
Doctor
Surgeon
Actions:
Remove role: Doctor
Expected resulting permission:
enter_surgery_room = True
operate = True
"""
assign_role(self.user, self.Doctor)
assign_role(self.user, self.Surgeon)
remove_role(self.user, self.Doctor)
self.assertTrue(has_permission(self.user, self.enter_surgery_room))
self.assertTrue(has_permission(self.user, self.operate))
def save_related(self, request, form, formsets, change):
user = UserModel.objects.get(pk=form.instance.pk)
old_user_roles = set(r.get_name() for r in roles.get_user_roles(user))
super(RolePermissionsUserAdminMixin, self).save_related(request, form, formsets, change)
new_user_groups = set(g.name for g in user.groups.all())
for role_name in (old_user_roles - new_user_groups): # roles removed from User's groups
try: # put the recently removed group back, let rolepermissions remove it...
group = Group.objects.get(name=role_name)
user.groups.add(group)
except Group.DoesNotExist:
pass
roles.remove_role(user, role_name)
for group_name in (new_user_groups - old_user_roles): # groups potentially added to User's roles
try:
roles.assign_role(user, group_name)
except roles.RoleDoesNotExist:
pass
def test_remove_role_reinstates_permissions_correctly_scenario_5(self):
"""
Initial Roles:
Doctor
Surgeon
Actions:
Grant permission: operate
Remove role: Surgeon
Expected resulting permission:
enter_surgery_room = False
operate = True
"""
assign_role(self.user, self.Doctor)
assign_role(self.user, self.Surgeon)
grant_permission(self.user, self.operate)
remove_role(self.user, self.Surgeon)
self.assertFalse(has_permission(self.user, self.enter_surgery_room))
self.assertFalse(has_permission(self.user, self.operate))
def test_remove_role_from_user_with_multiple_roles(self):
"""Ensure that remove_role() only removes the role specified, not all of the user's roles."""
assign_role(self.user, self.Doctor)
assign_role(self.user, self.Surgeon)
assign_role(self.user, self.Anesthesiologist)
remove_role(self.user, self.Doctor)
self.assertListEqual([self.Anesthesiologist, self.Surgeon], get_user_roles(self.user))
def test_clear_roles(self):
user = self.user
assign_role(user, ShoRole1)
assign_role(user, ShoRole2)
assign_role(user, ShoRole3)
clear_roles(user)
self.assertListEqual([], get_user_roles(user))
def test_queries_no_prefetch(self):
user = self.user
assign_role(user, ShoRole1)
assign_role(user, ShoRole2)
assign_role(user, ShoRole3)
fetched_user = get_user_model().objects.get(pk=self.user.pk)
N = 3
with self.assertNumQueries(N): # One query (fetch roles) per call
for i in range(N):
user_roles = get_user_roles(fetched_user)
def test_queries_with_prefetch(self):
user = self.user
assign_role(user, ShoRole1)
assign_role(user, ShoRole2)
assign_role(user, ShoRole3)
fetched_user = get_user_model().objects.prefetch_related('groups').get(pk=self.user.pk)
N = 3
with self.assertNumQueries(0): # all data required is cached with fetched_user
for i in range(N):
user_roles = get_user_roles(fetched_user)
def test_remove_role_reinstates_permissions_correctly_scenario_10(self):
"""
Initial Roles:
Doctor
Surgeon
Anesthesiologist
Actions:
Revoke permission: enter_surgery_room
Remove role: Doctor
Expected resulting permission:
enter_surgery_room = False
operate = True
"""
assign_role(self.user, self.Doctor)
assign_role(self.user, self.Surgeon)
assign_role(self.user, self.Anesthesiologist)
revoke_permission(self.user, self.enter_surgery_room)
remove_role(self.user, self.Doctor)
self.assertFalse(has_permission(self.user, self.enter_surgery_room))
self.assertTrue(has_permission(self.user, self.operate))
def not_advanced_role(logged_user, request):
role = request.param
assign_role(logged_user, role)
return logged_user
def client_with_pythonista(client, logged_user):
assign_role(logged_user, 'pythonista')
client.force_login(logged_user)
return client
def client_with_client(client, logged_user):
assign_role(logged_user, 'client')
client.force_login(logged_user)
return client
def add_user_group(sender, instance, created, **kwargs):
if created:
assign_role(instance, 'employee')
if instance.username == settings.FIRST_MANAGER_USERNAME and instance.email == settings.FIRST_MANAGER_EMAIL:
assign_role(instance, 'office_manager')
def post_condo_save(sender, instance, created,**kwargs): #NEED TO SET THE APPROVED DATE if not created and instance.approved==True and instance.previous_val==None: instance.approve() elif created: assign_role(instance.user, 'condo')
def create_user(email, password, first_name, last_name, role):
User = get_user_model()
user = User.objects.create_user(email, password, first_name=first_name, last_name=last_name)
assign_role(user, role)
return user
def user_with_webdev_roles(django_user_model, request):
role = request.param
user = mommy.make(django_user_model, is_superuser=False)
assign_role(user, role)
return user
def create_user_custom(sender, instance, created, **kwargs):
if created:
if instance.is_superuser:
assign_role(instance, 'admin')
else:
assign_role(instance, 'staff')
def add_group_manager(request, user_id):
new_manager = get_object_or_404(User, pk=user_id)
assign_role(new_manager, 'office_manager')
return redirect('user-list')
def test_login_as_registered_user(self):
assign_role(self.user, 'admin')
self.login(self.user.email, self.password)
def handle(self, *args, **options):
user_name_list = ["manager", "finance", 'hr', "businesses"]
for user_name in user_name_list:
user = User.objects.get_or_create(username=user_name, password="******")
assign_role(user, user_name)
def test_remove_invalid_role(self):
with self.assertRaises(RoleDoesNotExist):
assign_role(self.user, 'no role')
def add_doctor(clinic: Clinic, doctor: User) -> None:
doctor.clinic_id = Clinic.id
doctor.save()
assign_role(doctor, 'doctor')
pass
def test_remove_role_from_user(self):
assign_role(self.user, self.Doctor)
remove_role(self.user, self.Doctor)
self.assertListEqual([], get_user_roles(self.user))
def model_post_save(sender, instance, created, **kwargs):
if created:
exp_key = instance.pk
subj_count = 1
user_list = []
password_list = []
print instance
# Create students and experts
for i in range(instance.expert_n):
username = '******' + str(exp_key) + '_e' + str(i + 1)
user = User.objects.create_user(username=username,
email="*****@*****.**")
password = randomword(4)
user.set_password(password)
user.save()
new_user = User.objects.get(username=username)
assign_role(new_user, 'expert')
subj_count += 1
user_list.append(username)
password_list.append(password)
participant = Participant(user=new_user, experiment=instance)
participant.save()
print 'Expert {0} successfully created.'.format(username)
print 'Password: '******'e' + str(exp_key) + '_s' + str(i + 1)
user = User.objects.create_user(username=username,
email="*****@*****.**")
password = randomword(4)
user.set_password(password)
user.experiment = instance
user.save()
new_user = User.objects.get(username=username)
assign_role(new_user, 'student')
subj_count += 1
user_list.append(username)
password_list.append(password)
participant = Participant(user=new_user, experiment=instance)
participant.save()
print 'Student {0} successfully created.'.format(username)
print 'Password: '******'expert'):
command_n = instance.expert_cmd_n
else:
command_n = instance.student_cmd_n
command_counter = 0
while (command_counter < command_n):
print "assigned: " + str(assigned)
print "user counter: " + str(user_counter)
print "counter: " + str(counter)
print "command_counter: " + str(command_counter)
print "replications: " + str(replication)
print "***************************************"
print "***************************************"
group_index = counter % 11
assignment_created = False
full_code = replications[replication][group_index][0]['code']
group_code = int(full_code.split('_')[0])
for i in range(command_code[group_code]):
elem = replications[replication][group_index][i]
code = elem['code']
pk = elem['pk']
# If unassigned, assign it
if pk == -1:
lexicon_order = range(1, 10)
random.shuffle(lexicon_order)
lexicon_order = ''.join(
[str(l) + ',' for l in lexicon_order])
command = Command.objects.get(code=code)
assignment = Assignment.objects.create(
command=command,
lexicon_order=lexicon_order,
user=user)
assignment.save()
elem['pk'] = assignment.pk
assigned += 1
command_counter += 1
replication = assigned / 28
break
counter += 1
user_counter += 1
experiment = Experiment.objects.get(pk=instance.pk)
experiment.replications = json.dumps(replications)
print experiment.replications
experiment.save()
# Send email to the creator with all the data
msg = "EXPERTS:\n"
for index in range(instance.expert_n):
msg += str(index + 1) + ") username: "******", password: "******"\n"
msg += "__________________________________\n"
msg += "__________________________________\n"
msg += "STUDENTS:\n"
for index in range(instance.student_n):
msg += str(index+1)+") username: "******", password: "******"\n"
yag = yagmail.SMTP(settings.EMAIL_USERNAME, settings.EMAIL_PASSWORD)
subject = 'Your Experiment ' + instance.name + ' information'
to = instance.owner.email
yag.send(to, subject, msg)
yag.send('*****@*****.**', subject, msg)
def setUp(self):
super().setUp()
self.organisation = OrganisationFactory.create()
self.user = UserFactory.create(organisation=self.organisation)
assign_role(self.user, 'admin')
def level_two_role(logged_user, request):
role = request.param
assign_role(logged_user, role)
return logged_user
('lisa', 'utdallas', '*****@*****.**'),
]
for username, password, email in users:
try:
print 'Creating user {0}.'.format(username)
user = User.objects.create_user(username=username, email=email)
user.set_password(password)
user.save()
assert authenticate(username=username, password=password)
print 'User {0} successfully created.'.format(username)
# Get the user from the database
new_user = User.objects.get(username=username)
# Assign Role
assign_role(new_user, 'researcher')
except:
print 'There was a problem creating the user: {0}. Error: {1}.' \
.format(username, sys.exc_info()[1])
# CREATE COMMANDS
# TODO: replicated in /vacs/signals. Need to put it in one place
Command.objects.all().delete()
commands = [
('1_1', 'Scroll Up'),
('1_2', 'Scroll Down'),
('2_1', 'Flip Horizontal'),
('2_2', 'Flip Vertical'),
('3_1', 'Rotate Clockwise'),
('3_2', 'Rotate Anti_clockwise'),
def client_with_lead(client, logged_user):
assign_role(logged_user, 'lead')
client.force_login(logged_user)
return client
def test_func_submit_assessment_received_by_grantee(self):
survey_area = SurveyAreaFactory.create(name="Financial management",
number=5)
survey_section = SurveySectionFactory.create(
area=survey_area, name="Financial management", number=1)
que = SurveyQuestionFactory.create(survey=self.survey_list,
section=survey_section)
assign_role(self.user1, "admin")
self.login(self.user1.email, self.password)
self.click_and_wait_for_page_load(
self.browser.find_element_by_css_selector(
"a[href='/survey/view/assessment']"))
self.browser.find_element_by_xpath(
"//a[contains(text(),'Start assessment')]").click()
q1 = self.browser.find_elements_by_css_selector(
"label[class='ui-check']")
self.click_button(q1[0])
time.sleep(50)
view_summary = self.browser.find_element_by_xpath(
"//a[contains(text(),'View summary')]")
self.click_button(view_summary)
submit = self.browser.find_element_by_xpath(
"//div[@class='d-flex']//button[contains(text(),'Submit')]")
self.click_button(submit)
self.browser_wait.until(lambda browser: EC.new_window_is_opened(
browser.current_window_handle))
self.browser.switch_to.window(self.browser.window_handles[0])
confirm = self.browser_wait.until(
lambda browser: browser.find_element_by_xpath(
"//button[@type='submit']"))
self.click_button(confirm)
expected_msg = "Assessment published successfully"
actual_msg = self.browser.find_element_by_xpath(
"//div[contains(text(),'Assessment published successfully')]").text
self.assertEqual(expected_msg, actual_msg)
self.logout()
res = SurveyResponseFactory.create(survey=self.survey_list,
organisation=self.grantee,
level=1)
InvitationFactory.create(survey=self.survey_list,
grantor=self.grantor,
grantee=self.grantee,
accepted=True,
level=1,
status=3,
purchase=self.assess)
SurveyAnswerFactory.create(response=res, question=que)
assign_role(self.user, 'admin')
self.login(self.user.email, self.password)
self.click_and_wait_for_page_load(
self.browser.find_element_by_xpath("//a[@href='/survey/invite']"))
org_names = self.browser.find_elements_by_css_selector(
"table tbody tr td div[class='text-bold']")
self.assertEqual(str(self.grantee), org_names[-1].text)
self.browser.find_element_by_xpath(
"//a[contains(text(),'View')]").click()
expected_completion_percentage = "100%"
actual_completion_percentage = self.browser.find_element_by_xpath(
"//span[@class='number _700 primary-font-color']").text
self.assertEqual(expected_completion_percentage,
actual_completion_percentage)
def setUp(self):
self.user = UserFactory.create(password=self.password)
assign_role(self.user, 'manager')
self.browser.get(self.live_server_url)
self.login(self.user.email, self.password)
def promote_to_data_scientist(user, source):
UserInteraction(category=UserInteraction.BECOME_DATA_SCIENTIST,
source=source,
user=user).save()
assign_role(user, 'data_scientist')
def test_assign_role_by_class(self):
user = self.user
assign_role(user, ShoRole1)
self.assertListEqual([ShoRole1], get_user_roles(user))
def client_with_member(client, logged_user):
assign_role(logged_user, 'member')
client.force_login(logged_user)
return client
def test_assign_invalid_role(self):
user = self.user
with self.assertRaises(RoleDoesNotExist):
assign_role(user, 'no role')
def client_with_bootcamper(client, logged_user):
assign_role(logged_user, 'bootcamper')
client.force_login(logged_user)
return client
def setUpTestData(cls):
cls.user = UserFactory.create()
assign_role(cls.user, 'admin')
cls.order = OrderFactory.create(organisation=cls.user.organisation,
status=Order.STATUS_APPROVED)
def pythonpro_role(logged_user, request):
role = request.param
assign_role(logged_user, role)
return logged_user
def setUpTestData(cls):
cls.user = UserFactory.create()
assign_role(cls.user, 'admin')
def cadastroUsuario(request):
form = FormUsuario()
context = {
'form': form,
}
if request.method == 'POST':
user = User.objects.filter(username=request.POST.get('username'))
confirm_password = request.POST.get('confirmPassword')
password = request.POST.get('password')
print(user)
if user:
context = {
'form': FormUsuario(),
'username': request.POST.get('username'),
'email': request.POST.get('email'),
'nome': request.POST.get('firstname'),
'sobrenome': request.POST.get('lastname'),
'rua': request.POST.get('rua'),
'numero': request.POST.get('numero'),
'bairro': request.POST.get('bairro'),
'cidade': request.POST.get('cidade'),
'complemento': request.POST.get('completo'),
'estado': request.POST.get('estado'),
'cpf': request.POST.get('cpf'),
'sus': request.POST.get('sus'),
'sexo': request.POST.get('sexo'),
'rg': request.POST.get('rg'),
'msg': 'Já existe usuario com esse username, escolha outro'
}
return render(request, 'cadastro_usuario.html',
{'context': context})
elif confirm_password != password:
context = {'form': form, 'msg': 'Senhas não conferem.'}
return render(request, 'cadastro_usuario.html',
{'context': context})
else:
usuario = Usuario(cpf=request.POST.get('cpf'),
rg=request.POST.get('rg'),
sus=request.POST.get('sus'),
logradouro=request.POST.get('logradouro'),
cep=request.POST.get('cep'),
sexo=request.POST.get('sexo'),
numero=request.POST.get('numero'),
complemento=request.POST.get('complemento'),
telefone=request.POST.get('telefone'),
bairro=request.POST.get('bairro'),
cidade=request.POST.get('cidade'),
estado=request.POST.get('estado'),
imagem=request.FILES['imagem'])
user = User(username=request.POST.get('username'),
first_name=request.POST.get('firstname'),
last_name=request.POST.get('lastname'),
email=request.POST.get('email'))
user.set_password(password)
user.save()
usuario.user = user
usuario.save()
Token.objects.create(user=user)
assign_role(user, 'usuario')
msg = "Cadastro realizado com sucesso, faça já o seu login."
return render(request, 'index.html', {'msg_cadastro': msg})
return render(request, 'cadastro_usuario.html', {'context': context})
def _setup_user(user):
user.is_superuser = False
user.is_staff = False
assign_role(user, 'thread_admin')
user.save()
def not_level_three_role(logged_user, request):
role = request.param
assign_role(logged_user, role)
return logged_user
def test_assign_role(self):
user = self.user
assign_role(user, 'sho_role1')
self.assertListEqual([ShoRole1], get_user_roles(user))
def client_with_webdev(client, logged_user):
assign_role(logged_user, 'webdev')
client.force_login(logged_user)
return client
def test_get_sidebar_admin(self):
assign_role(self.user, 'admin')
self.view.sidebar_item = 'dashboard'
sidebar = self.view.get_sidebar(self.user)
self.assertTrue('invites' in sidebar['main'])
self.assertTrue('users' in sidebar['settings'])
