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