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'])