def registration_code_details(request, course_id): """ Post handler to mark the registration code as 1) valid 2) invalid 3) Unredeem. """ course_key = CourseKey.from_string(course_id) code = request.POST.get('registration_code') action_type = request.POST.get('action_type') course = get_course_by_id(course_key, depth=0) action_type_messages = { 'invalidate_registration_code': _('This enrollment code has been canceled. It can no longer be used.'), 'unredeem_registration_code': _('This enrollment code has been marked as unused.'), 'validate_registration_code': _('The enrollment code has been restored.') } try: registration_code = CourseRegistrationCode.objects.get(code=code) except CourseRegistrationCode.DoesNotExist: return JsonResponse( { 'message': _(u'The enrollment code ({code}) was not found for the {course_name} course.' ).format(code=code, course_name=course.display_name) }, status=400) if action_type == 'invalidate_registration_code': registration_code.is_valid = False registration_code.save() if RegistrationCodeRedemption.is_registration_code_redeemed(code): code_redemption = RegistrationCodeRedemption.get_registration_code_redemption( code, course_key) delete_redemption_entry(request, code_redemption, course_key) if action_type == 'validate_registration_code': registration_code.is_valid = True registration_code.save() if action_type == 'unredeem_registration_code': code_redemption = RegistrationCodeRedemption.get_registration_code_redemption( code, course_key) if code_redemption is None: return JsonResponse( { 'message': _(u'The redemption does not exist against enrollment code ({code}).' ).format(code=code) }, status=400) delete_redemption_entry(request, code_redemption, course_key) return JsonResponse({'message': action_type_messages[action_type]})
def test_look_up_valid_registration_code(self): """ test lookup for the valid registration code and that registration code has been redeemed by user and then mark the registration code as in_valid when marking as invalidate, it also lookup for registration redemption entry and also delete that redemption entry and un_enroll the student who used that registration code for their enrollment. """ for i in range(2): CourseRegistrationCode.objects.create( code='reg_code{}'.format(i), course_id=unicode(self.course.id), created_by=self.instructor, invoice=self.sale_invoice, invoice_item=self.invoice_item, mode_slug=CourseMode.DEFAULT_MODE_SLUG) reg_code = CourseRegistrationCode.objects.all()[0] student = UserFactory() enrollment = CourseEnrollment.enroll(student, self.course.id) RegistrationCodeRedemption.objects.create(registration_code=reg_code, redeemed_by=student, course_enrollment=enrollment) data = {'registration_code': reg_code.code} response = self.client.get(self.lookup_code_url, data) self.assertEqual(response.status_code, 200) json_dict = json.loads(response.content) self.assertTrue(json_dict['is_registration_code_valid']) self.assertTrue(json_dict['is_registration_code_redeemed']) # now mark that registration code as invalid data = { 'registration_code': reg_code.code, 'action_type': 'invalidate_registration_code' } response = self.client.post(self.registration_code_detail_url, data) self.assertEqual(response.status_code, 200) json_dict = json.loads(response.content) message = _( 'This enrollment code has been canceled. It can no longer be used.' ) self.assertEqual(message, json_dict['message']) # now check that the registration code should be marked as invalid in the db. reg_code = CourseRegistrationCode.objects.get(code=reg_code.code) self.assertEqual(reg_code.is_valid, False) redemption = RegistrationCodeRedemption.get_registration_code_redemption( reg_code.code, self.course.id) self.assertIsNone(redemption) # now the student course enrollment should be false. enrollment = CourseEnrollment.get_enrollment(student, self.course.id) self.assertEqual(enrollment.is_active, False)
def registration_code_details(request, course_id): """ Post handler to mark the registration code as 1) valid 2) invalid 3) Unredeem. """ course_key = CourseKey.from_string(course_id) code = request.POST.get('registration_code') action_type = request.POST.get('action_type') course = get_course_by_id(course_key, depth=0) action_type_messages = { 'invalidate_registration_code': _('This enrollment code has been canceled. It can no longer be used.'), 'unredeem_registration_code': _('This enrollment code has been marked as unused.'), 'validate_registration_code': _('The enrollment code has been restored.') } try: registration_code = CourseRegistrationCode.objects.get(code=code) except CourseRegistrationCode.DoesNotExist: return JsonResponse({ 'message': _(u'The enrollment code ({code}) was not found for the {course_name} course.').format( code=code, course_name=course.display_name )}, status=400) if action_type == 'invalidate_registration_code': registration_code.is_valid = False registration_code.save() if RegistrationCodeRedemption.is_registration_code_redeemed(code): code_redemption = RegistrationCodeRedemption.get_registration_code_redemption(code, course_key) delete_redemption_entry(request, code_redemption, course_key) if action_type == 'validate_registration_code': registration_code.is_valid = True registration_code.save() if action_type == 'unredeem_registration_code': code_redemption = RegistrationCodeRedemption.get_registration_code_redemption(code, course_key) if code_redemption is None: return JsonResponse({ 'message': _(u'The redemption does not exist against enrollment code ({code}).').format( code=code)}, status=400) delete_redemption_entry(request, code_redemption, course_key) return JsonResponse({'message': action_type_messages[action_type]})
def test_lookup_valid_redeemed_registration_code(self): """ test to lookup for the valid and redeemed registration code and then mark that registration code as un_redeemed which will unenroll the user and delete the redemption entry from the database. """ student = UserFactory() self.client.login(username=student.username, password='******') cart = Order.get_cart_for_user(student) cart.order_type = 'business' cart.save() CourseRegCodeItem.add_to_order(cart, self.course.id, 2) cart.purchase() reg_code = CourseRegistrationCode.objects.filter(order=cart)[0] enrollment = CourseEnrollment.enroll(student, self.course.id) RegistrationCodeRedemption.objects.create( registration_code=reg_code, redeemed_by=student, course_enrollment=enrollment ) self.client.login(username=self.instructor.username, password='******') data = { 'registration_code': reg_code.code } response = self.client.get(self.lookup_code_url, data) self.assertEqual(response.status_code, 200) json_dict = json.loads(response.content.decode('utf-8')) self.assertTrue(json_dict['is_registration_code_valid']) self.assertTrue(json_dict['is_registration_code_redeemed']) # now mark the registration code as unredeemed # this will unenroll the user and removed the redemption entry from # the database. data = { 'registration_code': reg_code.code, 'action_type': 'unredeem_registration_code' } response = self.client.post(self.registration_code_detail_url, data) self.assertEqual(response.status_code, 200) json_dict = json.loads(response.content.decode('utf-8')) message = _('This enrollment code has been marked as unused.') self.assertEqual(message, json_dict['message']) redemption = RegistrationCodeRedemption.get_registration_code_redemption(reg_code.code, self.course.id) self.assertIsNone(redemption) # now the student course enrollment should be false. enrollment = CourseEnrollment.get_enrollment(student, self.course.id) self.assertEqual(enrollment.is_active, False)
def test_lookup_valid_redeemed_registration_code(self): """ test to lookup for the valid and redeemed registration code and then mark that registration code as un_redeemed which will unenroll the user and delete the redemption entry from the database. """ student = UserFactory() self.client.login(username=student.username, password='******') cart = Order.get_cart_for_user(student) cart.order_type = 'business' cart.save() CourseRegCodeItem.add_to_order(cart, self.course.id, 2) cart.purchase() reg_code = CourseRegistrationCode.objects.filter(order=cart)[0] enrollment = CourseEnrollment.enroll(student, self.course.id) RegistrationCodeRedemption.objects.create( registration_code=reg_code, redeemed_by=student, course_enrollment=enrollment ) self.client.login(username=self.instructor.username, password='******') data = { 'registration_code': reg_code.code } response = self.client.get(self.lookup_code_url, data) self.assertEqual(response.status_code, 200) json_dict = json.loads(response.content) self.assertTrue(json_dict['is_registration_code_valid']) self.assertTrue(json_dict['is_registration_code_redeemed']) # now mark the registration code as unredeemed # this will unenroll the user and removed the redemption entry from # the database. data = { 'registration_code': reg_code.code, 'action_type': 'unredeem_registration_code' } response = self.client.post(self.registration_code_detail_url, data) self.assertEqual(response.status_code, 200) json_dict = json.loads(response.content) message = _('This enrollment code has been marked as unused.') self.assertEqual(message, json_dict['message']) redemption = RegistrationCodeRedemption.get_registration_code_redemption(reg_code.code, self.course.id) self.assertIsNone(redemption) # now the student course enrollment should be false. enrollment = CourseEnrollment.get_enrollment(student, self.course.id) self.assertEqual(enrollment.is_active, False)
def test_look_up_valid_registration_code(self): """ test lookup for the valid registration code and that registration code has been redeemed by user and then mark the registration code as in_valid when marking as invalidate, it also lookup for registration redemption entry and also delete that redemption entry and un_enroll the student who used that registration code for their enrollment. """ for i in range(2): CourseRegistrationCode.objects.create( code="reg_code{}".format(i), course_id=unicode(self.course.id), created_by=self.instructor, invoice=self.sale_invoice, invoice_item=self.invoice_item, mode_slug="honor", ) reg_code = CourseRegistrationCode.objects.all()[0] student = UserFactory() enrollment = CourseEnrollment.enroll(student, self.course.id) RegistrationCodeRedemption.objects.create( registration_code=reg_code, redeemed_by=student, course_enrollment=enrollment ) data = {"registration_code": reg_code.code} response = self.client.get(self.lookup_code_url, data) self.assertEqual(response.status_code, 200) json_dict = json.loads(response.content) self.assertTrue(json_dict["is_registration_code_valid"]) self.assertTrue(json_dict["is_registration_code_redeemed"]) # now mark that registration code as invalid data = {"registration_code": reg_code.code, "action_type": "invalidate_registration_code"} response = self.client.post(self.registration_code_detail_url, data) self.assertEqual(response.status_code, 200) json_dict = json.loads(response.content) message = _("This enrollment code has been canceled. It can no longer be used.") self.assertEqual(message, json_dict["message"]) # now check that the registration code should be marked as invalid in the db. reg_code = CourseRegistrationCode.objects.get(code=reg_code.code) self.assertEqual(reg_code.is_valid, False) redemption = RegistrationCodeRedemption.get_registration_code_redemption(reg_code.code, self.course.id) self.assertIsNone(redemption) # now the student course enrollment should be false. enrollment = CourseEnrollment.get_enrollment(student, self.course.id) self.assertEqual(enrollment.is_active, False)