def get_context(self, request, *args, **kwargs): programs = Program.objects.filter(live=True).select_related('programpage').order_by("id") js_settings = { "gaTrackingID": settings.GA_TRACKING_ID, "host": webpack_dev_server_host(request), "environment": settings.ENVIRONMENT, "sentry_dsn": sentry.get_public_dsn(), "release_version": settings.VERSION } username = get_social_username(request.user) context = super(HomePage, self).get_context(request) def get_program_page(program): """Return a None if ProgramPage does not exist, to avoid template errors""" try: return program.programpage except ProgramPage.DoesNotExist: return None program_pairs = [(program, get_program_page(program)) for program in programs] context["programs"] = program_pairs context["is_public"] = True context["has_zendesk_widget"] = True context["google_maps_api"] = False context["authenticated"] = not request.user.is_anonymous context["is_staff"] = has_role(request.user, [Staff.ROLE_ID, Instructor.ROLE_ID]) context["username"] = username context["js_settings_json"] = json.dumps(js_settings) context["title"] = self.title context["ga_tracking_id"] = "" context["coupon_code"] = get_coupon_code(request) return context
def standard_error_page(request, status_code, template_filename): """ Returns an error page with a given template filename and provides necessary context variables """ name = request.user.profile.preferred_name if not request.user.is_anonymous else "" authenticated = not request.user.is_anonymous username = get_social_username(request.user) response = render( request, template_filename, context={ "has_zendesk_widget": True, "is_public": True, "js_settings_json": json.dumps({ "release_version": settings.VERSION, "environment": settings.ENVIRONMENT, "sentry_dsn": sentry.get_public_dsn(), "user": serialize_maybe_user(request.user), }), "authenticated": authenticated, "name": name, "username": username, "is_staff": has_role(request.user, [Staff.ROLE_ID, Instructor.ROLE_ID]), "support_email": settings.EMAIL_SUPPORT, "sentry_dsn": sentry.get_public_dsn(), } ) response.status_code = status_code return response
def get_program_page_context(programpage, request): """ Get context for the program page""" from cms.serializers import ProgramPageSerializer courses_query = ( programpage.program.course_set.all() ) js_settings = { "gaTrackingID": settings.GA_TRACKING_ID, "host": webpack_dev_server_host(request), "environment": settings.ENVIRONMENT, "sentry_dsn": sentry.get_public_dsn(), "release_version": settings.VERSION, "user": serialize_maybe_user(request.user), "program": ProgramPageSerializer(programpage).data, } username = get_social_username(request.user) context = super(ProgramPage, programpage).get_context(request) context["is_staff"] = has_role(request.user, [Staff.ROLE_ID, Instructor.ROLE_ID]) context["is_public"] = True context["has_zendesk_widget"] = True context["google_maps_api"] = False context["authenticated"] = not request.user.is_anonymous context["username"] = username context["js_settings_json"] = json.dumps(js_settings) context["title"] = programpage.title context["courses"] = courses_query context["ga_tracking_id"] = programpage.program.ga_tracking_id return context
def assert_standard_role_permissions(self, expected_bool, program=None): """ Helper function to assert role and permissions assignment """ assert isinstance(expected_bool, bool) assert has_role(self.user, 'staff') is expected_bool assert has_permission(self.user, 'can_advance_search') is expected_bool assert has_object_permission('can_advance_search', self.user, program or self.program) is expected_bool
def wrapper(request, *args, **kwargs): user = request.user if user_is_authenticated(user): if has_role(user, role): return dispatch(request, *args, **kwargs) redirect = redirect_to_login if redirect is None: redirect = getattr( settings, 'ROLEPERMISSIONS_REDIRECT_TO_LOGIN', False) if redirect: return dj_redirect_to_login(request.get_full_path()) raise PermissionDenied
def find_leads_by_date_joined_interval(begin: datetime, end: datetime): return list(user for user in User.objects.filter(date_joined__gte=begin, date_joined__lte=end).all() if not has_role(user, ['client', 'member']))
def assert_no_action_taken(create_or_update_client, logged_user, mailoutbox): assert create_or_update_client.call_count == 0 assert len(mailoutbox) == 0 assert has_role(logged_user, 'lead') assert not has_role(logged_user, 'client')
def setUserStudentRole(id): user = get_object_or_404(User, pk=id) assign_role(user, 'student') return has_role(user, Student)
def test_user_creation(resp_token_with_no_user, django_user_model): user = django_user_model.objects.get(email=CUSTOMER_EMAIL) assert has_role(user, 'client') assert not has_role(user, 'lead')
def has_any_webdev_role(user): return has_role(user, 'lead client webdev member'.split())
def is_pythonista(user): return has_role(user, 'pythonista')
def test_has_role_by_name(self): user = self.user self.assertTrue(has_role(user, 'ver_role1'))
def show_waiting_for_confirm_choose_topic(request): # 确认当前教师 teacher = request.user teacher_obj = User.objects.get(id=teacher.id) # 查找当前教师的学生的题目 topic2teacher = Topic2Teacher.objects.filter(teacher_id=teacher_obj.id) topic_list = list() for t2t in topic2teacher: topic_list.append(t2t.topic_id) print("Topic List:", topic_list) print("-------------------------") topic2student_list = list() for i in range(len(topic_list)): topic2student_list.append( Topic2Student.objects.filter(topic_id=topic_list[i])) print("Topic2Student List", topic2student_list) topic2student_list_clean = list() for j in range(len(topic2student_list)): if isinstance(topic2student_list[j], list): for item in topic2student_list[j]: topic2student_list_clean.append(item) else: topic2student_list_clean.append(topic2student_list[j]) print("整理后的Topic2Student List", topic2student_list_clean) student_id_list = list() for t2s in topic2student_list_clean: for item in t2s: student_id_list.append(item.student_id) student_list = list() for student_id in student_id_list: student_list.append(User.objects.get(id=student_id)) print("--------------------") print("学生列表", student_list) print("GUANLIYUAN?") print(has_role(teacher_obj, ['admin'])) print("老师??") print(has_role(teacher_obj, ['teacher'])) result_list = list() # if has_role(teacher_obj, ['admin']): # print("glyglygly") # student_phase_3_list = User.objects.filter(user_phase_id=3) if has_role(teacher_obj, ['teacher']): print("tttttt") for student in student_list: if student.user_phase_id == 2: result_list.append(student) student2topic_dict = dict() for student in result_list: topic = get_object_or_404(Topic2Student, student=student) student2topic_dict[student] = topic.topic.title print("DIXT") print(student2topic_dict) context = { "result": student2topic_dict, # "admin_result": student_phase_3_list } # 展示所有确认状态为2的学生 return render(request, "choose_topic/waiting_for_confirm.html", context=context)
def has_role_template_tag(user, role): role_list = role.split(',') return has_role(user, role_list)
def has_roles(user, roles): has_roles = False for role in roles: if has_role(user, role): has_roles = True return has_roles
def update_profile_from_edx(backend, user, response, is_new, *args, **kwargs): # pylint: disable=unused-argument """ Gets profile information from EDX and saves them in the user profile Args: backend (social.backends.oauth.BaseOAuth2): the python social auth backend user (User): user object response (dict): dictionary of the user information coming from previous functions in the pipeline is_new (bool): whether the authenticated user created a new local instance Returns: None """ # this function is completely skipped if the backend is not edx or # the user has not created now if backend.name != EdxOrgOAuth2.name: return if has_role(user, [Staff.ROLE_ID, Instructor.ROLE_ID]): next_relative_url = "/learners" else: next_relative_url = "/dashboard" next_url = backend.strategy.session.load().get( 'next') or backend.strategy.session.get('next') if not next_url: next_url = next_relative_url backend.strategy.session_set('next', next_url) user_profile_edx = kwargs.get('edx_profile') update_email(user_profile_edx, user) if not is_new: return try: user_profile = Profile.objects.get(user=user) except Profile.DoesNotExist: # this should never happen, since the profile is created with a signal # right after the user is created log.error('No profile found for the user %s', user.username) return name = user_profile_edx.get('name', "") user_profile.edx_name = name user_profile.first_name, user_profile.last_name = split_name(name) user_profile.preferred_name = name user_profile.edx_bio = user_profile_edx.get('bio') user_profile.country = user_profile_edx.get('country') user_profile.edx_requires_parental_consent = user_profile_edx.get( 'requires_parental_consent') user_profile.edx_level_of_education = user_profile_edx.get( 'level_of_education') user_profile.edx_goals = user_profile_edx.get('goals') user_profile.edx_language_proficiencies = user_profile_edx.get( 'language_proficiencies') try: user_profile.preferred_language = user_profile.edx_language_proficiencies[ 0]['code'] except (IndexError, ValueError, KeyError, TypeError): pass user_profile.gender = user_profile_edx.get('gender') user_profile.edx_mailing_address = user_profile_edx.get('mailing_address') user_profile.agreed_to_terms_of_service = True user_profile.save() log.debug('Profile for user "%s" updated with values from EDX %s', user.username, user_profile_edx)
def view(request, name): asso = get_object_or_404(Association, name=name) flag = not request.user.is_superuser and not has_role( request.user, 'respo') if flag: member = get_object_or_404(Membership, member=request.user, asso=asso) else: member = None # Prepare useful queryset simples = Dashboard.get_members(asso, MemberRole.SIMPLE) office = Dashboard.get_members(asso, MemberRole.OFFICE) president = Dashboard.get_members(asso, MemberRole.PRESIDENT) all = simples | office | president others = User.objects.all().exclude(pk__in=all.values('member')) office = office | president # Nested classes in order to create forms with different behaviours class AssoForm(forms.Form): def __init__(self, *args, **kwargs): super(AssoForm, self).__init__(*args, **kwargs) for field_name, field in self.fields.items(): field.widget.attrs['class'] = 'form-control' class OfficeForm(AssoForm): membre = forms.ModelChoiceField(queryset=simples, required=True) class AddForm(AssoForm): membre = forms.ModelChoiceField(queryset=others, required=True) class RemoveForm(AssoForm): membre = forms.ModelChoiceField(queryset=all, required=True) class PresForm(AssoForm): membre = forms.ModelChoiceField( queryset=(simples | office).exclude( role__exact=MemberRole.PRESIDENT._value_), required=True) if request.method == 'POST': if 'officeModal' in request.POST: form = OfficeForm(request.POST) Dashboard.add_office_member(asso, form) elif 'addModal' in request.POST: form = AddForm(request.POST) Dashboard.add_member(asso, form) elif 'presidentModal' in request.POST: form = PresForm(request.POST) Dashboard.designate_president(asso, form) else: form = RemoveForm(request.POST) Dashboard.remove_member(asso, form) if Dashboard.msg: return redirect(reverse('core:association', args=[asso.name])) else: office_form = OfficeForm() add_form = AddForm() remove_form = RemoveForm() president_form = PresForm() # Creating templates variables variables = {} variables['can_add_office'] = has_object_permission( 'add_office', request.user, asso) variables['can_remove_office'] = variables['can_add_office'] variables['can_manage_members'] = has_object_permission( 'validate_member', request.user, asso) variables['events'] = Dashboard.related_events(asso) variables['office'] = office variables['asso'] = asso variables['info'] = Dashboard.msg variables['fail'] = Dashboard.error variables['respo'] = has_role(request.user, 'respo') variables[ 'pres'] = True if member is None else member.role == MemberRole.PRESIDENT._value_ variables['office_form'] = office_form variables['add_form'] = add_form variables['remove_form'] = remove_form variables['president_form'] = president_form variables['waiting'] = str(EventStatus.WAITING._value_) variables['validated'] = str(EventStatus.VALIDATED._value_) variables['pending'] = str(EventStatus.PENDING._value_) variables['rejected'] = str(EventStatus.REJECTED._value_) Dashboard.msg = None return render(request, 'dashboard.html', variables)
def user_login(request, template_name='vacs/login.html', current_app=None, extra_context=None): if request.method == "POST": form = forms.LoginForm(request, data=request.POST) if form.is_valid(): # Okay, security check complete. Log the user in. auth_login(request, form.get_user()) user = User.objects.get(pk=form.get_user_id()) if has_role(user, 'researcher'): print "%%%%%%%%%%%%%%% R %%%%%%%%%%%%%%%%" return HttpResponseRedirect('/vacs/experiments') elif has_role(user, ['student', 'expert']): print "%%%%%%%%%%%%%%% P %%%%%%%%%%%%%%%%" # if the current vac is null, add the first one on the list participant = Participant.objects.get(user=user) experiment = participant.experiment # Get the assignments that are not done assignments = Assignment.objects.filter(user=user, done=False) if assignments: # if not empty grab the first assignment assignment = assignments[0] # if the current vac is null, add the first one on the list if not assignment.current_vac: vacs = Vac.objects.filter( experiment__id=participant.experiment.pk) try: vac = vacs[:1].get() except Vac.DoesNotExist: return render( request, 'vacs/error_message.html', { 'message': 'Please tell the researcher to add the VACs' }) assignment.current_vac = vac assignment.save() print "ABOUT TO REDIRECT" return redirect('evaluation_edit', assignment.pk, assignment.current_vac.pk) elif experiment.in_validation: # if experiment ready for validation val_assignments = ValAssignment.objects.filter(user=user, done=False) if val_assignments: # if not empty grab the first assignment val_assignment = val_assignments[0] # if the current score is null, add the vac that is closest to the list if not val_assignment.current_score: vacs = Score.objects.filter( experiment__id=participant.experiment.pk) try: vac = vacs[:1].get() except Vac.DoesNotExist: return render( request, 'vacs/error_message.html', { 'message': 'Please tell the researcher to add the VACs' }) # Get the current score scores = Score.objects.filter( experiment=experiment, command=val_assignment.command, lexicon_number=val_assignment.lexicon_number) score = get_critical_score(scores) val_assignment.current_score = score val_assignment.save() return redirect('validation_edit', val_assignment.pk, val_assignment.current_score.pk) else: return redirect('finished') else: # if empty but not in validation # redirect to waiting mesage return redirect('validation_index') else: print "%%%%%%%%%%%%%%% N %%%%%%%%%%%%%%%%" return HttpResponseRedirect('/') else: form = forms.LoginForm() current_site = get_current_site(request) context = { 'form': form, 'redirect_field_name': '/', 'site': current_site, 'site_name': current_site.name, } if extra_context is not None: context.update(extra_context) if current_app is not None: request.current_app = current_app return TemplateResponse(request, template_name, context)
def test_user_does_not_have_VerRole2(self): user = self.user self.assertFalse(has_role(user, VerRole2))
def test_anonymous_user_promoted_to_client(valid_resp_anonymous, anonymous_user): assert has_role(anonymous_user, 'client') assert not has_role(anonymous_user, 'lead') assert not has_role(anonymous_user, 'member')
def test_not_existent_role(self): user = self.user self.assertFalse(has_role(user, 'not_a_role'))
def test_user_promoted_to_client(valid_resp, logged_user): assert has_role(logged_user, 'client') assert not has_role(logged_user, 'lead') assert not has_role(logged_user, 'member')
def is_data_scientist(user): return has_role(user, 'data_scientist')
def eligibility_score(request): elig_amount = 0 c_type = "" user = request.user if has_role(user, Customer): try: info_all = CurrentLoan.objects.filter( user=PersonalAccount.objects.all().filter( user=request.user)[0]) savings = PersonalInfo.objects.filter( user=PersonalAccount.objects.all().filter(user=request.user)[0] ).values("average_monthly_savings")[0]["average_monthly_savings"] info = (info_all).values_list("user", flat=True) length = len(info) emi_list = [] for i in range(0, length): Loan_amount = ( info_all).values("current_amount")[i]["current_amount"] Payment_period = ( info_all).values("current_length")[i]["current_length"] Interest_rate = float( ((info_all ).values("current_interest")[i]["current_interest"]) / 100) emi = int((Loan_amount * pow( (Interest_rate / 12) + 1, (Payment_period)) * Interest_rate / 12) / (pow(Interest_rate / 12 + 1, (Payment_period)) - 1)) emi_list.append(emi) total_emi = sum(emi_list) left_amount = int(savings - total_emi) if request.method == 'POST': eligibility_form = EligibilityForm(data=request.POST) if eligibility_form.is_valid(): tenure = int(eligibility_form.cleaned_data["tenure"]) rate = int(eligibility_form.cleaned_data["rate"]) / 1200 type = eligibility_form.cleaned_data["type"] amount = int((left_amount * (pow(rate + 1, tenure) - 1)) / (pow(rate + 1, tenure) * rate)) amount1 = str(amount) zeros = str(pow(10, (len(amount1) - 1)))[1:] if (int(amount1[1]) < 5): amount2 = int(amount1[0] + zeros) else: amount2 = int(str(int(amount1[0]) + 1) + zeros) elig_amount = f"{amount2:,d}" c_type = type + " " else: messages.error(request, eligibility_form.errors) else: eligibility_form = EligibilityForm() return render( request, 'eligibility_score.html', { 'eligibility_form': eligibility_form, 'elig_amount': elig_amount, 'c_type': c_type }) except: return render(request, 'eligibility_error.html') else: raise Http404
def is_bootcamper(user): return has_role(user, 'bootcamper')
def credit_score(request): user = request.user if has_role(user, Customer): try: info_all = DuesInfo.objects.filter( user=PersonalAccount.objects.all().filter( user=request.user)[0]) info = (info_all).values_list("user", flat=True) score = 0 if not info: length = 1 else: length = len(info) Currently_Owned_Amount = [] Previously_Owned_Amount = [] Total_Number_Of_Overdues_in_Current_Loans = [] Total_Overdue_Amount_of_Current_Loans = [] Maximum_Number_of_Days_Amount_is_Overdue_in_Current_Loans = [] Total_Overdue_Amount_of_Current_Loans = [] Total_Overdue_Amount_of_Completed_Loans = [] Maximum_Number_of_Days_Amount_is_Overdue_in_Completed_Loans = [] for i in range(0, length): Currently_Owned_Amount.append((info_all).values( "Currently_Owned_Amount")[i]["Currently_Owned_Amount"]) Previously_Owned_Amount.append((info_all).values( "Previously_Owned_Amount")[i]["Previously_Owned_Amount"]) Total_Number_Of_Overdues_in_Current_Loans.append( (info_all ).values("Total_Number_Of_Overdues_in_Current_Loans")[i] ["Total_Number_Of_Overdues_in_Current_Loans"]) Total_Overdue_Amount_of_Current_Loans.append( (info_all).values("Total_Overdue_Amount_of_Current_Loans") [i]["Total_Overdue_Amount_of_Current_Loans"]) Maximum_Number_of_Days_Amount_is_Overdue_in_Current_Loans.append(( info_all ).values( "Maximum_Number_of_Days_Amount_is_Overdue_in_Current_Loans" )[i][ "Maximum_Number_of_Days_Amount_is_Overdue_in_Current_Loans"]) Total_Overdue_Amount_of_Current_Loans.append( (info_all).values("Total_Overdue_Amount_of_Current_Loans") [i]["Total_Overdue_Amount_of_Current_Loans"]) Total_Overdue_Amount_of_Completed_Loans.append( (info_all ).values("Total_Overdue_Amount_of_Completed_Loans")[i] ["Total_Overdue_Amount_of_Completed_Loans"]) Maximum_Number_of_Days_Amount_is_Overdue_in_Completed_Loans.append( (info_all).values( "Maximum_Number_of_Days_Amount_is_Overdue_in_Completed_Loans" )[i] ["Maximum_Number_of_Days_Amount_is_Overdue_in_Completed_Loans"] ) avg_Currently_Owned_Amount = (sum(Currently_Owned_Amount) / length) avg_Previously_Owned_Amount = (sum(Previously_Owned_Amount) / length) avg_Total_Number_Of_Overdues_in_Current_Loans = ( sum(Total_Number_Of_Overdues_in_Current_Loans) / length) avg_Total_Overdue_Amount_of_Current_Loans = ( sum(Total_Overdue_Amount_of_Current_Loans) / length) avg_Maximum_Number_of_Days_Amount_is_Overdue_in_Current_Loans = ( sum(Maximum_Number_of_Days_Amount_is_Overdue_in_Current_Loans) / length) avg_Total_Overdue_Amount_of_Current_Loans = ( sum(Total_Overdue_Amount_of_Current_Loans) / length) avg_Total_Overdue_Amount_of_Completed_Loans = ( sum(Total_Overdue_Amount_of_Completed_Loans) / length) avg_Maximum_Number_of_Days_Amount_is_Overdue_in_Completed_Loans = ( sum(Maximum_Number_of_Days_Amount_is_Overdue_in_Completed_Loans ) / length) score = 696 data = Score(user=PersonalAccount.objects.all().filter( user=request.user)[0], credit_score=score) data.save() return render(request, 'credit_score.html', {"score": score}) except: return render(request, 'user_dashboard.html') else: raise Http404
def test_user_has_role(resp_lead_creation, django_user_model): user = django_user_model.objects.first() assert has_role(user, 'lead')
def desk_controle(request): template = loader.get_template('repatriate/desk_controle.html') prov = Provider.objects.get(username=request.user.username) sites = [ rs.site.slug for rs in RegistrationSiteProvider.objects.filter(provider=prov) ] context = {"user": prov} if has_role(prov, [DeskAssistantAdmin, SuperAdmin, DNDSTech]): srv = Target.active_objects.all() pn = Person.active_objects.all() d_progres_m = DuplicateProgresMenage.not_fix_objects.all() context.update({'d_progres_m': d_progres_m}) elif has_role(prov, [DeskControle]): srv = Target.active_objects.filter(site_engistrement__in=sites) pn = Person.active_objects.filter(target__site_engistrement__in=sites) else: return redirect('/') if request.method == 'POST' and '_per_Date' in request.POST: period_form = SearchFormPerPeriod(request.POST or None) date_s = request.POST.get('start_date').replace("/", "-") date_e = request.POST.get('end_date').replace("/", "-") return redirect("export-xls/{start}/{end}".format(start=date_s, end=date_e)) else: period_form = SearchFormPerPeriod() context.update({'period_form': period_form}) search_form = SearchForm(request.POST or None) result = "" result_not_found = "" if request.method == 'POST' and '_search' in request.POST: print("search") if search_form.is_valid(): result = search_form.get_result('num_progres_individuel') if not result: print("Not found") result_not_found = "Aucun numéro ne correspond" context.update({ 'result_not_found': result_not_found, 'search_form': search_form, 'msg_result': result }) invalide_num_pi = pn.filter(is_invalide_num_pi=True) num_pi_sans_num_pm = pn.filter(is_num_pi_sans_num_pm=True) not_empty_num_pi_alg = pn.filter(is_not_empty_num_pi_alg=True) vrf_wihtout_num_pi = pn.filter(is_vrf_wihtout_num_pi=True) sans_doc_avec_num_pi = pn.filter(is_sans_doc_avec_num_pi=True) requise_num_progres_menage = srv.filter(is_requise_num_progres_menage=True) invalide_num_progres_menage = srv.filter( is_invalide_num_progres_menage=True) invalide_num_tel = srv.filter(is_invalide_num_tel=True) not_empty_num_progres_menage_alg = srv.filter( is_not_empty_num_progres_menage_alg=True) no_doc_with_num_pm = srv.filter(is_no_doc_with_num_pm=True) site_not_existe = srv.filter(is_site_not_existe=True) context.update({ 'invalide_num_pi': invalide_num_pi, 'num_pi_sans_num_pm': num_pi_sans_num_pm, 'not_empty_num_pi_alg': not_empty_num_pi_alg, 'vrf_wihtout_num_pi': vrf_wihtout_num_pi, 'sans_doc_avec_num_pi': sans_doc_avec_num_pi, 'requise_num_progres_menage': requise_num_progres_menage, 'invalide_num_progres_menage': invalide_num_progres_menage, 'invalide_num_tel': invalide_num_tel, 'not_empty_num_progres_menage_alg': not_empty_num_progres_menage_alg, 'no_doc_with_num_pm': no_doc_with_num_pm, 'site_not_existe': site_not_existe, }) nb_menage = srv.count() nb_person = pn.count() nb_person_f = pn.filter(membre_sexe=Person.FEMALE).count() nb_person_m = pn.filter(membre_sexe=Person.MALE).count() pn_0_4 = pn.filter(membre_age__lte=4) pn_5_11 = pn.filter(membre_age__gte=5, membre_age__lte=11) pn_12_17 = pn.filter(membre_age__gte=12, membre_age__lte=17) pn_18_59 = pn.filter(membre_age__gte=18, membre_age__lte=59) pn_plus60 = pn.filter(membre_age__gte=60) pn_0_4_count_m = pn_0_4.filter(membre_sexe=Person.MALE).count() pn_0_4_count_f = pn_0_4.filter(membre_sexe=Person.FEMALE).count() pn_0_4_count = pn_0_4_count_m + pn_0_4_count_f pn_5_11_count_m = pn_5_11.filter(membre_sexe=Person.MALE).count() pn_5_11_count_f = pn_5_11.filter(membre_sexe=Person.FEMALE).count() pn_5_11_count = pn_5_11_count_m + pn_5_11_count_f pn_12_17_count_m = pn_12_17.filter(membre_sexe=Person.MALE).count() pn_12_17_count_f = pn_12_17.filter(membre_sexe=Person.FEMALE).count() pn_12_17_count = pn_12_17_count_f + pn_12_17_count_m pn_18_59_count_m = pn_18_59.filter(membre_sexe=Person.MALE).count() pn_18_59_count_f = pn_18_59.filter(membre_sexe=Person.FEMALE).count() pn_18_59_count = pn_18_59_count_f + pn_18_59_count_m plus60_count_m = pn_plus60.filter(membre_sexe=Person.MALE).count() plus60_count_f = pn_plus60.filter(membre_sexe=Person.FEMALE).count() plus60_count = plus60_count_f + plus60_count_m context.update({ "srv": srv, "pn_0_4_count_m": pn_0_4_count_m, "pn_0_4_count_f": pn_0_4_count_f, "pn_0_4_count": pn_0_4_count, "pn_5_11_count_m": pn_5_11_count_m, "pn_5_11_count_f": pn_5_11_count_f, "pn_5_11_count": pn_5_11_count, "pn_12_17_count_m": pn_12_17_count_m, "pn_12_17_count_f": pn_12_17_count_f, "pn_12_17_count": pn_12_17_count, "pn_18_59_count_m": pn_18_59_count_m, "pn_18_59_count_f": pn_18_59_count_f, "pn_18_59_count": pn_18_59_count, "plus60_count_m": plus60_count_m, "plus60_count_f": plus60_count_f, "plus60_count": plus60_count, "nb_menage": nb_menage, "nb_person": nb_person, "nb_person_m": nb_person_m, "nb_person_f": nb_person_f, }) return HttpResponse(template.render(context, request))
def test_user_become_client(resp_token, logged_user): assert has_role(logged_user, 'client') assert not has_role(logged_user, 'lead')
def export_xls(request, *args, **kwargs): start = date_format(kwargs["start"]) end = date_format(kwargs["end"]) prov = Provider.objects.get(username=request.user.username) if has_role(prov, [DeskControle]): sites = [ rs.site.slug for rs in RegistrationSiteProvider.objects.filter(provider=prov) ] pn = Person.active_objects.filter(target__site_engistrement__in=sites) if has_role(prov, [DeskAssistantAdmin, SuperAdmin, DNDSTech]): pn = Person.active_objects.all() else: redirect('/') pn = pn.filter(target__date_entretien__gte=start, target__date_entretien__lte=end) response = HttpResponse(content_type='application/ms-excel') response[ 'Content-Disposition'] = 'attachment; filename="export brute retournés.xls"' wb = xlwt.Workbook(encoding='utf-8') ws = wb.add_sheet('Users') # Sheet header, first row row_num = 0 font_style = xlwt.XFStyle() font_style.font.bold = True columns = [ 'identifier', 'nom_agent', 'num_enregistrement', 'site_engistrement', 'date_arrivee', 'date_entretien', 'continent_asile', 'pays_asile', 'ville_asile', 'camp', 'num_progres_menage', 'point_de_entree', 'continent_naissance', 'pays_naissance', 'lieu_naissance', 'chef_etat_civil', 'chef_profession', 'chef_doc', 'num_doc', 'beneficiez_lassistance', 'actuelle_region', 'actuelle_cercle', 'actuelle_commune', 'actuelle_qvf', 'actuelle_nom_generale_utilise', 'rue', 'porte', 'tel', 'abris', 'nature_construction', 'type_hebergement', 'membre_pays', 'nbre_membre_reste', 'etat_sante', 'situation_maladie', 'type_maladie', 'type_aigue', 'prise_medicament', 'type_medicaments', 'suivi_formation', 'domaine_formation', 'metier_pays_prove', 'exercice_secteur', 'formation_socio_prof', 'secteur_prof', 'projet_activite', 'type_projet', 'souhait_activite', 'lieu_region', 'lieu_cercle', 'lieu_commune', 'lieu_qvf', 'lieu_non_generale_utilise', 'num_progres_individuel' ] # columns = [f.name for f in Target._meta.get_fields()] + [ # f.name for f in Person._meta.get_fields()] for col_num in range(len(columns)): ws.write(row_num, col_num, columns[col_num], font_style) # Sheet body, remaining rows font_style = xlwt.XFStyle() for row in pn: row_num += 1 col_num = 0 ws.write(row_num, col_num, row.target.identifier, font_style) col_num += 1 ws.write(row_num, col_num, row.target.nom_agent, font_style) col_num += 1 ws.write(row_num, col_num, row.target.num_enregistrement, font_style) col_num += 1 ws.write(row_num, col_num, row.target.site_engistrement.name, font_style) col_num += 1 ws.write(row_num, col_num, get_date(row.target.date_arrivee), font_style) col_num += 1 ws.write(row_num, col_num, get_date(row.target.date_entretien), font_style) col_num += 1 ws.write(row_num, col_num, row.target.continent_asile, font_style) col_num += 1 ws.write(row_num, col_num, row.target.pays_asile, font_style) col_num += 1 ws.write(row_num, col_num, row.target.ville_asile, font_style) col_num += 1 ws.write(row_num, col_num, row.target.camp, font_style) col_num += 1 ws.write(row_num, col_num, row.target.num_progres_menage, font_style) col_num += 1 ws.write(row_num, col_num, row.target.point_de_entree, font_style) col_num += 1 ws.write(row_num, col_num, row.target.continent_naissance, font_style) col_num += 1 ws.write(row_num, col_num, row.target.pays_naissance, font_style) col_num += 1 ws.write(row_num, col_num, row.target.lieu_naissance, font_style) col_num += 1 ws.write(row_num, col_num, row.target.chef_etat_civil, font_style) col_num += 1 ws.write(row_num, col_num, row.target.chef_profession, font_style) col_num += 1 ws.write(row_num, col_num, row.target.chef_doc, font_style) col_num += 1 ws.write(row_num, col_num, row.target.num_doc, font_style) col_num += 1 ws.write(row_num, col_num, row.target.beneficiez_lassistance, font_style) col_num += 1 ws.write(row_num, col_num, row.target.actuelle_region, font_style) col_num += 1 ws.write(row_num, col_num, row.target.actuelle_cercle, font_style) col_num += 1 ws.write(row_num, col_num, row.target.actuelle_commune, font_style) col_num += 1 ws.write(row_num, col_num, row.target.actuelle_qvf, font_style) col_num += 1 ws.write(row_num, col_num, row.target.actuelle_nom_generale_utilise, font_style) col_num += 1 ws.write(row_num, col_num, row.target.rue, font_style) col_num += 1 ws.write(row_num, col_num, row.target.porte, font_style) col_num += 1 ws.write(row_num, col_num, row.target.tel, font_style) col_num += 1 ws.write(row_num, col_num, row.target.abris, font_style) col_num += 1 ws.write(row_num, col_num, row.target.nature_construction, font_style) col_num += 1 ws.write(row_num, col_num, row.target.type_hebergement, font_style) col_num += 1 ws.write(row_num, col_num, row.target.membre_pays, font_style) col_num += 1 ws.write(row_num, col_num, row.target.nbre_membre_reste, font_style) col_num += 1 ws.write(row_num, col_num, row.target.etat_sante, font_style) col_num += 1 ws.write(row_num, col_num, row.target.situation_maladie, font_style) col_num += 1 ws.write(row_num, col_num, row.target.type_maladie, font_style) col_num += 1 ws.write(row_num, col_num, row.target.type_aigue, font_style) col_num += 1 ws.write(row_num, col_num, row.target.prise_medicament, font_style) col_num += 1 ws.write(row_num, col_num, row.target.type_medicaments, font_style) col_num += 1 ws.write(row_num, col_num, row.target.suivi_formation, font_style) col_num += 1 ws.write(row_num, col_num, row.target.domaine_formation, font_style) col_num += 1 ws.write(row_num, col_num, row.target.metier_pays_prove, font_style) col_num += 1 ws.write(row_num, col_num, row.target.exercice_secteur, font_style) col_num += 1 ws.write(row_num, col_num, row.target.formation_socio_prof, font_style) col_num += 1 ws.write(row_num, col_num, row.target.secteur_prof, font_style) col_num += 1 ws.write(row_num, col_num, row.target.projet_activite, font_style) col_num += 1 ws.write(row_num, col_num, row.target.type_projet, font_style) col_num += 1 ws.write(row_num, col_num, row.target.souhait_activite, font_style) col_num += 1 ws.write(row_num, col_num, row.target.lieu_region, font_style) col_num += 1 ws.write(row_num, col_num, row.target.lieu_cercle, font_style) col_num += 1 ws.write(row_num, col_num, row.target.lieu_commune, font_style) col_num += 1 ws.write(row_num, col_num, row.target.lieu_qvf, font_style) col_num += 1 ws.write(row_num, col_num, row.target.lieu_non_generale_utilise, font_style) col_num += 1 ws.write(row_num, col_num, row.num_progres_individuel, font_style) col_num += 1 # break wb.save(response) return response
def create_access(request): # Get discord access token corresponding to the code by the auth data = { 'client_id': config.client_id, 'client_secret': config.client_secret, 'grant_type': 'authorization_code', 'code': request.data['code'], 'redirect_uri': request.data['redirect_uri'], 'scope': 'identify guilds' } headers = { 'Content-Type': 'application/x-www-form-urlencoded' } response_access = requests.post('%s/oauth2/token' % API_ENDPOINT, data=data, headers=headers) # Use the access token to get the guilds the user is part of if response_access.status_code != 200: return Response('Bad discord code', status=status.HTTP_400_BAD_REQUEST) headers = { "Authorization": ("Bearer " + str(response_access.json()['access_token'])) } response_guilds = requests.get('%s/users/@me/guilds' % API_ENDPOINT, headers=headers) if response_guilds.status_code != 200: return Response('Bad access token', status=status.HTTP_400_BAD_REQUEST) # A user is allowed a bot access token if he shares at least one guild with the bot shared_guilds = [] bot_guild_ids = [guild.id for guild in bot.guilds] for guild in response_guilds.json(): if int(guild['id']) in bot_guild_ids: shared_guilds.append({'id': guild['id'], 'name': guild['name']}) if len(shared_guilds) == 0: return Response('User does not share server with bot', status=status.HTTP_403_FORBIDDEN) response_user = requests.get('%s/users/@me' % API_ENDPOINT, headers=headers) if response_user.status_code != 200: return Response('Bad access token', status=status.HTTP_400_BAD_REQUEST) user_id = response_user.json()['id'] # check if user exists in database, creating one if necessary query = User.objects.filter(username=user_id) if not query.exists(): user = User.objects.create_user(username=user_id) for role in default_roles: assign_role(user, role) else: user = query[0] # caches the current guilds of a user for a login - use a real caching mechanism if deployed at large scale user.profile.guilds.clear() for guild_dict in shared_guilds: guild = Guild.objects.filter(id=str(guild_dict['id']))[0] user.profile.guilds.add(guild) # Check if the owner role status of the user is up to date and edit it if necessary is_specified_as_owner = user_id in config.bot_owners is_owner = has_role(user, "owner") if is_owner and not is_specified_as_owner: remove_role(user, 'owner') elif not is_owner and is_specified_as_owner: assign_role(user, 'owner') user.save() # update bot access token Token.objects.filter(user=user).delete() token = Token.objects.create(user=user) # send back bot access token return Response(token.key, status=status.HTTP_200_OK)
def test_user_stay_lead(resp_token, logged_user): assert not has_role(logged_user, 'client') assert has_role(logged_user, 'lead')
def is_client(user: User): return has_role(user, 'client')
def get_object(self): user = self.request.user if has_role(user, 'instructor'): self.fields += ['cnh'] return Employee.objects.get(pk=user.pk) return Person.objects.get(pk=user.pk)
def update_profile_from_edx(backend, user, response, is_new, *args, **kwargs): # pylint: disable=unused-argument """ Gets profile information from EDX and saves them in the user profile Args: backend (social.backends.oauth.BaseOAuth2): the python social auth backend user (User): user object response (dict): dictionary of the user information coming from previous functions in the pipeline is_new (bool): whether the authenticated user created a new local instance Returns: None """ # this function is completely skipped if the backend is not edx or # the user has not created now if backend.name != EdxOrgOAuth2.name: return if has_role(user, [Staff.ROLE_ID, Instructor.ROLE_ID]): next_relative_url = "/learners" else: next_relative_url = "/dashboard" next_url = backend.strategy.session.load().get('next') or backend.strategy.session.get('next') if not next_url: next_url = next_relative_url backend.strategy.session_set('next', next_url) user_profile_edx = kwargs.get('edx_profile') update_email(user_profile_edx, user) if not is_new: return try: user_profile = Profile.objects.get(user=user) except Profile.DoesNotExist: # this should never happen, since the profile is created with a signal # right after the user is created log.error('No profile found for the user %s', user.username) return name = user_profile_edx.get('name', "") user_profile.edx_name = name user_profile.first_name, user_profile.last_name = split_name(name) user_profile.preferred_name = name user_profile.edx_bio = user_profile_edx.get('bio') user_profile.country = user_profile_edx.get('country') user_profile.edx_requires_parental_consent = user_profile_edx.get('requires_parental_consent') user_profile.edx_level_of_education = user_profile_edx.get('level_of_education') user_profile.edx_goals = user_profile_edx.get('goals') user_profile.edx_language_proficiencies = user_profile_edx.get('language_proficiencies') try: user_profile.preferred_language = user_profile.edx_language_proficiencies[0]['code'] except (IndexError, ValueError, KeyError, TypeError): pass user_profile.gender = user_profile_edx.get('gender') user_profile.edx_mailing_address = user_profile_edx.get('mailing_address') user_profile.agreed_to_terms_of_service = True user_profile.save() log.debug( 'Profile for user "%s" updated with values from EDX %s', user.username, user_profile_edx )
def check_admin(request, *args, **kwargs): if not has_role(request.user, Admin) and not request.user.is_superuser: raise PermissionDenied("You Do Not have permissions to access this page") return func(request, *args, **kwargs)
def test_user_has_VerRole1(self): user = self.user self.assertTrue(has_role(user, VerRole1))
def is_staff(event, user): staff = Staff.objects.filter(event=event, member=user) return staff.count() == 1 or has_role(user, 'respo')\ or user.is_superuser or user == event.creator
def test_user_has_VerRole1_or_VerRole2(self): user = self.user self.assertTrue(has_role(user, [VerRole1, VerRole2]))
def is_lead(user: User): return has_role(user, 'lead')
def test_user_has_VerRole1_or_VerRole3_by_name(self): user = self.user VerRole3.assign_role_to_user(user) self.assertTrue(has_role(user, ['ver_role1', 'ver_new_name']))
def is_member(user: User): return has_role(user, 'member')
def test_none_user_param(self): self.assertFalse(has_role(None, 'ver_role1'))
def is_webdev(user: User): return has_role(user, 'webdev')