Coverage for benefits/enrollment_switchio/views.py: 98%

1import logging 

2from django.http import HttpRequest, JsonResponse 

3from django.shortcuts import redirect 

4from django.urls import reverse 

5from django.views.generic import FormView, View 

6import sentry_sdk 

7 

8from benefits.enrollment_switchio.models import SwitchioConfig 

9from benefits.routes import routes 

10from benefits.core import models, session 

11from benefits.core.mixins import EligibleSessionRequiredMixin, AgencySessionRequiredMixin 

12from benefits.enrollment import analytics, forms 

13from benefits.enrollment.enrollment import Status 

14from benefits.enrollment_switchio.enrollment import ( 

15 request_registration, 

16 get_registration_status, 

17 get_latest_active_token_value, 

18) 

19from benefits.enrollment_switchio.session import Session 

20 

21logger = logging.getLogger(__name__) 

22 

23 

24class IndexView(AgencySessionRequiredMixin, EligibleSessionRequiredMixin, FormView): 

25 """View for the enrollment landing page.""" 

26 

27 template_name = "enrollment_switchio/index.html" 

28 form_class = forms.CardTokenizeSuccessForm 

29 

30 def get_context_data(self, **kwargs): 

31 context = super().get_context_data(**kwargs) 

32 

33 request = self.request 

34 flow = session.flow(self.request) 

35 

36 tokenize_system_error_form = forms.CardTokenizeFailForm( 

37 routes.ENROLLMENT_SYSTEM_ERROR, "form-card-tokenize-fail-system-error" 

38 ) 

39 tokenize_success_form = forms.CardTokenizeSuccessForm( 

40 action_url=routes.ENROLLMENT_SWITCHIO_INDEX, auto_id=True, label_suffix="" 

41 ) 

42 context.update( 

43 { 

44 **flow.enrollment_index_context, 

45 "forms": [tokenize_system_error_form, tokenize_success_form], 

46 "form_success": tokenize_success_form.id, 

47 "form_system_error": tokenize_system_error_form.id, 

48 "cta_button": "tokenize_card", 

49 "enrollment_method": models.EnrollmentMethods.DIGITAL, 

50 "transit_processor": {"name": "Switchio", "website": "https://switchio.com/transport/"}, 

51 "locale": self._get_locale(request.LANGUAGE_CODE), 

52 } 

53 ) 

54 return context 

55 

56 def _get_locale(self, django_language_code): 

57 """Given a Django language code, return the corresponding locale to use with Switchio's tokenization gateway.""" 

58 # mapping from Django's I18N LANGUAGE_CODE to Switchio's locales 

59 locale = {"en": "en", "es": "es"}.get(django_language_code, "en") 

60 return locale 

61 

62 def get(self, request: HttpRequest, *args, **kwargs): 

63 session = Session(request) 

64 switchio_config = self.agency.switchio_config 

65 

66 if session.registration_id: 

67 response = get_registration_status(switchio_config=switchio_config, registration_id=session.registration_id) 

68 if response.status is Status.SUCCESS: 

69 reg_state = response.registration_status.regState 

70 if reg_state == "tokenization_finished": 

71 # give card token to index template so it can send 

72 # "finished card tokenization" event and POST either the 

73 # CardTokenizeSuccessForm or CardTokenizeFailForm. 

74 context_data = self.get_context_data(**kwargs) 

75 

76 context_data["card_token"] = get_latest_active_token_value(response.registration_status.tokens) 

77 return self.render_to_response(context=context_data) 

78 elif reg_state == "verification_failed": 

79 return redirect(routes.ENROLLMENT_RETRY) 

80 elif reg_state == "tokenization_failed": 80 ↛ 91line 80 didn't jump to line 91 because the condition on line 80 was always true

81 sentry_sdk.capture_exception(Exception("Tokenization failed")) 

82 return redirect(routes.ENROLLMENT_SYSTEM_ERROR) 

83 else: 

84 sentry_sdk.capture_exception(response.exception) 

85 

86 if response.status is Status.SYSTEM_ERROR: 

87 return redirect(routes.ENROLLMENT_SYSTEM_ERROR) 

88 elif response.status is Status.EXCEPTION: 88 ↛ 91line 88 didn't jump to line 91 because the condition on line 88 was always true

89 return redirect(routes.SERVER_ERROR) 

90 

91 return super().get(request=request, *args, **kwargs) 

92 

93 def form_valid(self, form): 

94 card_token = form.cleaned_data.get("card_token") # noqa 

95 

96 # (this is where we will enroll the card token) 

97 # status, exception = enroll(self.request, card_token) 

98 

99 # return handle_enrollment_results(self.request, status, exception) 

100 return redirect(routes.ENROLLMENT_SUCCESS) 

101 

102 

103class GatewayUrlView(AgencySessionRequiredMixin, EligibleSessionRequiredMixin, View): 

104 """View for the tokenization gateway registration""" 

105 

106 def get(self, request: HttpRequest, *args, **kwargs): 

107 session = Session(request) 

108 switchio_config = self.agency.switchio_config 

109 

110 if session.registration_id is None or session.gateway_url is None: 

111 return self._request_registration(request, switchio_config, session) 

112 else: 

113 response = get_registration_status(switchio_config=switchio_config, registration_id=session.registration_id) 

114 

115 if response.status is Status.SUCCESS: 

116 # if the registration session is no longer valid, request a new registration session. 

117 if response.registration_status.regState in ["expired", "deleted"]: 

118 return self._request_registration(request, switchio_config, session) 

119 else: 

120 return self._gateway_url_response(session) 

121 else: 

122 logger.debug(f"Error occurred while attempting to get registration status for {session.registration_id}") 

123 sentry_sdk.capture_exception(response.exception) 

124 analytics.failed_pretokenization_request(request, response.status_code) 

125 

126 if response.status is Status.SYSTEM_ERROR: 

127 redirect = reverse(routes.ENROLLMENT_SYSTEM_ERROR) 

128 else: 

129 redirect = reverse(routes.SERVER_ERROR) 

130 

131 data = {"redirect": redirect} 

132 return JsonResponse(data) 

133 

134 def _request_registration(self, request: HttpRequest, switchio_config: SwitchioConfig, session: Session) -> JsonResponse: 

135 response = request_registration(request, switchio_config) 

136 

137 if response.status is Status.SUCCESS: 

138 registration = response.registration 

139 session.registration_id = registration.regId 

140 session.gateway_url = registration.gtwUrl 

141 

142 return self._gateway_url_response(session) 

143 else: 

144 logger.debug("Error occurred while requesting a tokenization gateway registration", exc_info=response.exception) 

145 sentry_sdk.capture_exception(response.exception) 

146 analytics.failed_pretokenization_request(request, response.status_code) 

147 

148 if response.status is Status.SYSTEM_ERROR: 

149 redirect = reverse(routes.ENROLLMENT_SYSTEM_ERROR) 

150 else: 

151 redirect = reverse(routes.SERVER_ERROR) 

152 

153 data = {"redirect": redirect} 

154 return JsonResponse(data) 

155 

156 def _gateway_url_response(self, session: Session): 

157 data = {"gateway_url": session.gateway_url} 

158 return JsonResponse(data)