Coverage for benefits/eligibility/views.py: 97%

1""" 

2The eligibility application: view definitions for the eligibility verification flow. 

3""" 

4 

5from django.contrib import messages 

6from django.shortcuts import redirect 

7from django.template.response import TemplateResponse 

8from django.urls import reverse 

9from django.utils.decorators import decorator_from_middleware 

10 

11from benefits.routes import routes 

12from benefits.core import recaptcha, session 

13from benefits.core.middleware import AgencySessionRequired, LoginRequired, RecaptchaEnabled, FlowSessionRequired 

14from benefits.core.models import EnrollmentFlow 

15from . import analytics, forms, verify 

16 

17TEMPLATE_CONFIRM = "eligibility/confirm.html" 

18 

19 

20@decorator_from_middleware(AgencySessionRequired) 

21@decorator_from_middleware(RecaptchaEnabled) 

22def index(request): 

23 """View handler for the enrollment flow selection form.""" 

24 agency = session.agency(request) 

25 session.update(request, eligible=False, origin=agency.index_url) 

26 

27 # clear any prior OAuth token as the user is choosing their desired flow 

28 # this may or may not require OAuth, with a different set of scope/claims than what is already stored 

29 session.logout(request) 

30 

31 context = {"form": forms.EnrollmentFlowSelectionForm(agency=agency)} 

32 

33 if request.method == "POST": 

34 form = forms.EnrollmentFlowSelectionForm(data=request.POST, agency=agency) 

35 

36 if form.is_valid(): 

37 flow_id = form.cleaned_data.get("flow") 

38 flow = EnrollmentFlow.objects.get(id=flow_id) 

39 session.update(request, flow=flow) 

40 

41 analytics.selected_flow(request, flow) 

42 

43 eligibility_start = reverse(routes.ELIGIBILITY_START) 

44 response = redirect(eligibility_start) 

45 else: 

46 # form was not valid, allow for correction/resubmission 

47 if recaptcha.has_error(form): 47 ↛ 48line 47 didn't jump to line 48 because the condition on line 47 was never true

48 messages.error(request, "Recaptcha failed. Please try again.") 

49 context["form"] = form 

50 context.update(agency.eligibility_index_context) 

51 response = TemplateResponse(request, "eligibility/index.html", context) 

52 else: 

53 context.update(agency.eligibility_index_context) 

54 response = TemplateResponse(request, "eligibility/index.html", context) 

55 

56 return response 

57 

58 

59@decorator_from_middleware(AgencySessionRequired) 

60@decorator_from_middleware(FlowSessionRequired) 

61def start(request): 

62 """View handler for the eligibility verification getting started screen.""" 

63 session.update(request, eligible=False, origin=reverse(routes.ELIGIBILITY_START)) 

64 

65 flow = session.flow(request) 

66 

67 return TemplateResponse(request, flow.eligibility_start_template) 

68 

69 

70@decorator_from_middleware(AgencySessionRequired) 

71@decorator_from_middleware(LoginRequired) 

72@decorator_from_middleware(RecaptchaEnabled) 

73@decorator_from_middleware(FlowSessionRequired) 

74def confirm(request): 

75 """View handler for the eligibility verification form.""" 

76 

77 # GET from an already verified user, no need to verify again 

78 if request.method == "GET" and session.eligible(request): 

79 return verified(request) 

80 

81 unverified_view = reverse(routes.ELIGIBILITY_UNVERIFIED) 

82 

83 agency = session.agency(request) 

84 flow = session.flow(request) 

85 

86 # GET for OAuth verification 

87 if request.method == "GET" and flow.uses_claims_verification: 

88 analytics.started_eligibility(request, flow) 

89 

90 is_verified = verify.eligibility_from_oauth(flow, session.oauth_claims(request)) 

91 

92 if is_verified: 

93 return verified(request) 

94 else: 

95 return redirect(unverified_view) 

96 

97 form = flow.eligibility_form_instance() 

98 

99 # GET/POST for Eligibility API verification 

100 context = {"form": form} 

101 

102 # GET from an unverified user, present the form 

103 if request.method == "GET": 

104 session.update(request, origin=reverse(routes.ELIGIBILITY_CONFIRM)) 

105 return TemplateResponse(request, TEMPLATE_CONFIRM, context) 

106 # POST form submission, process form data, make Eligibility Verification API call 

107 elif request.method == "POST": 107 ↛ exitline 107 didn't return from function 'confirm' because the condition on line 107 was always true

108 analytics.started_eligibility(request, flow) 

109 

110 form = flow.eligibility_form_instance(data=request.POST) 

111 # form was not valid, allow for correction/resubmission 

112 if not form.is_valid(): 

113 if recaptcha.has_error(form): 

114 messages.error(request, "Recaptcha failed. Please try again.") 

115 context["form"] = form 

116 return TemplateResponse(request, TEMPLATE_CONFIRM, context) 

117 

118 # form is valid, make Eligibility Verification request to get the verified confirmation 

119 is_verified = verify.eligibility_from_api(flow, form, agency) 

120 

121 # form was not valid, allow for correction/resubmission 

122 if is_verified is None: 

123 analytics.returned_error(request, flow, form.errors) 

124 context["form"] = form 

125 return TemplateResponse(request, TEMPLATE_CONFIRM, context) 

126 # no type was verified 

127 elif not is_verified: 

128 return redirect(unverified_view) 

129 # type was verified 

130 else: 

131 return verified(request) 

132 

133 

134@decorator_from_middleware(AgencySessionRequired) 

135@decorator_from_middleware(LoginRequired) 

136def verified(request): 

137 """View handler for the verified eligibility page.""" 

138 

139 flow = session.flow(request) 

140 analytics.returned_success(request, flow) 

141 

142 session.update(request, eligible=True) 

143 

144 return redirect(routes.ENROLLMENT_INDEX) 

145 

146 

147@decorator_from_middleware(AgencySessionRequired) 

148@decorator_from_middleware(FlowSessionRequired) 

149def unverified(request): 

150 """View handler for the unverified eligibility page.""" 

151 

152 flow = session.flow(request) 

153 

154 analytics.returned_fail(request, flow) 

155 

156 return TemplateResponse(request, flow.eligibility_unverified_template)