def test_course_registration_features(self): query_features = ['code', 'course_id', 'transaction_group_name', 'created_by', 'redeemed_by'] for i in range(5): course_code = CourseRegistrationCode( code="test_code{}".format(i), course_id=self.course_key.to_deprecated_string(), transaction_group_name='TestName', created_by=self.users[0] ) course_code.save() order = Order(user=self.users[0], status='purchased') order.save() registration_code_redemption = RegistrationCodeRedemption( order=order, registration_code_id=1, redeemed_by=self.users[0] ) registration_code_redemption.save() registration_codes = CourseRegistrationCode.objects.all() course_registration_list = course_registration_features(query_features, registration_codes, csv_type='download') self.assertEqual(len(course_registration_list), len(registration_codes)) for course_registration in course_registration_list: self.assertEqual(set(course_registration.keys()), set(query_features)) self.assertIn(course_registration['code'], [registration_code.code for registration_code in registration_codes]) self.assertIn( course_registration['course_id'], [registration_code.course_id.to_deprecated_string() for registration_code in registration_codes] ) self.assertIn( course_registration['transaction_group_name'], [registration_code.transaction_group_name for registration_code in registration_codes] )
def test_regcode_multi_redemptions(self): """ Asserts the data model around RegistrationCodeRedemption and what happens when we do multiple redemptions by same user """ self.cart.order_type = 'business' self.cart.save() CourseRegCodeItem.add_to_order(self.cart, self.course_key, 2) self.cart.purchase() reg_codes = CourseRegistrationCode.objects.filter(order=self.cart) self.assertEqual(len(reg_codes), 2) enrollment = CourseEnrollment.enroll(self.user, self.course_key) ids = [] for reg_code in reg_codes: redemption = RegistrationCodeRedemption( registration_code=reg_code, redeemed_by=self.user, course_enrollment=enrollment ) redemption.save() ids.append(redemption.id) # pylint: disable=no-member test_redemption = RegistrationCodeRedemption.registration_code_used_for_enrollment(enrollment) self.assertIn(test_redemption.id, ids) # pylint: disable=no-member
def test_course_registration_features(self): query_features = [ 'code', 'redeem_code_url', 'course_id', 'company_name', 'created_by', 'redeemed_by', 'invoice_id', 'purchaser', 'customer_reference_number', 'internal_reference' ] order = Order(user=self.instructor, status='purchased') order.save() registration_code_redemption = RegistrationCodeRedemption( registration_code_id=1, redeemed_by=self.instructor ) registration_code_redemption.save() registration_codes = CourseRegistrationCode.objects.all() course_registration_list = course_registration_features(query_features, registration_codes, csv_type='download') self.assertEqual(len(course_registration_list), len(registration_codes)) for course_registration in course_registration_list: self.assertEqual(set(course_registration.keys()), set(query_features)) self.assertIn(course_registration['code'], [registration_code.code for registration_code in registration_codes]) self.assertIn( course_registration['course_id'], [registration_code.course_id.to_deprecated_string() for registration_code in registration_codes] ) self.assertIn( course_registration['company_name'], [getattr(registration_code.invoice, 'company_name') for registration_code in registration_codes] ) self.assertIn( course_registration['invoice_id'], [registration_code.invoice_id for registration_code in registration_codes] )
def test_course_registration_features(self): query_features = [ 'code', 'course_id', 'company_name', 'created_by', 'redeemed_by', 'invoice_id', 'purchaser', 'customer_reference_number', 'internal_reference' ] order = Order(user=self.instructor, status='purchased') order.save() registration_code_redemption = RegistrationCodeRedemption( order=order, registration_code_id=1, redeemed_by=self.instructor ) registration_code_redemption.save() registration_codes = CourseRegistrationCode.objects.all() course_registration_list = course_registration_features(query_features, registration_codes, csv_type='download') self.assertEqual(len(course_registration_list), len(registration_codes)) for course_registration in course_registration_list: self.assertEqual(set(course_registration.keys()), set(query_features)) self.assertIn(course_registration['code'], [registration_code.code for registration_code in registration_codes]) self.assertIn( course_registration['course_id'], [registration_code.course_id.to_deprecated_string() for registration_code in registration_codes] ) self.assertIn( course_registration['company_name'], [getattr(registration_code.invoice, 'company_name') for registration_code in registration_codes] ) self.assertIn( course_registration['invoice_id'], [registration_code.invoice_id for registration_code in registration_codes] )
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 look_up_registration_code(request, course_id): """ Look for the registration_code in the database. and check if it is still valid, allowed to redeem or not. """ course_key = CourseKey.from_string(course_id) code = request.GET.get('registration_code') course = get_course_by_id(course_key, depth=0) try: registration_code = CourseRegistrationCode.objects.get(code=code) except CourseRegistrationCode.DoesNotExist: return JsonResponse({ 'is_registration_code_exists': False, 'is_registration_code_valid': False, 'is_registration_code_redeemed': False, 'message': _(u'The enrollment code ({code}) was not found for the {course_name} course.').format( code=code, course_name=course.display_name ) }, status=400) # status code 200: OK by default reg_code_already_redeemed = RegistrationCodeRedemption.is_registration_code_redeemed(code) registration_code_detail_url = reverse('registration_code_details', kwargs={'course_id': unicode(course_id)}) return JsonResponse({ 'is_registration_code_exists': True, 'is_registration_code_valid': registration_code.is_valid, 'is_registration_code_redeemed': reg_code_already_redeemed, 'registration_code_detail_url': registration_code_detail_url }) # status code 200: OK by default
def look_up_registration_code(request, course_id): """ Look for the registration_code in the database. and check if it is still valid, allowed to redeem or not. """ course_key = CourseKey.from_string(course_id) code = request.GET.get('registration_code') course = get_course_by_id(course_key, depth=0) try: registration_code = CourseRegistrationCode.objects.get(code=code) except CourseRegistrationCode.DoesNotExist: return JsonResponse({ 'is_registration_code_exists': False, 'is_registration_code_valid': False, 'is_registration_code_redeemed': False, 'message': _('The enrolment code ({code}) was not found for the {course_name} course.').format( code=code, course_name=course.display_name ) }, status=400) # status code 200: OK by default reg_code_already_redeemed = RegistrationCodeRedemption.is_registration_code_redeemed(code) registration_code_detail_url = reverse('registration_code_details', kwargs={'course_id': unicode(course_id)}) return JsonResponse({ 'is_registration_code_exists': True, 'is_registration_code_valid': registration_code.is_valid, 'is_registration_code_redeemed': reg_code_already_redeemed, 'registration_code_detail_url': registration_code_detail_url }) # status code 200: OK by default
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 get_enrollment_info(self, user, course_id): """ Returns the User Enrollment information. """ course = get_course_by_id(course_id, depth=0) is_course_staff = bool(has_access(user, 'staff', course)) manual_enrollment_reason = 'N/A' # check the user enrollment role if user.is_staff: platform_name = configuration_helpers.get_value('platform_name', settings.PLATFORM_NAME) enrollment_role = _('{platform_name} Staff').format(platform_name=platform_name) elif is_course_staff: enrollment_role = _('Course Staff') else: enrollment_role = _('Student') course_enrollment = CourseEnrollment.get_enrollment(user=user, course_key=course_id) if is_course_staff: enrollment_source = _('Staff') else: # get the registration_code_redemption object if exists registration_code_redemption = RegistrationCodeRedemption.registration_code_used_for_enrollment( course_enrollment) # get the paid_course registration item if exists paid_course_reg_item = PaidCourseRegistration.get_course_item_for_user_enrollment( user=user, course_id=course_id, course_enrollment=course_enrollment ) # from where the user get here if registration_code_redemption is not None: enrollment_source = _('Used Registration Code') elif paid_course_reg_item is not None: enrollment_source = _('Credit Card - Individual') else: manual_enrollment = ManualEnrollmentAudit.get_manual_enrollment(course_enrollment) if manual_enrollment is not None: enrollment_source = _( 'manually enrolled by username: {username}' ).format(username=manual_enrollment.enrolled_by.username) manual_enrollment_reason = manual_enrollment.reason else: enrollment_source = _('Manually Enrolled') enrollment_date = course_enrollment.created.strftime("%B %d, %Y") currently_enrolled = course_enrollment.is_active course_enrollment_data = collections.OrderedDict() course_enrollment_data['Enrollment Date'] = enrollment_date course_enrollment_data['Currently Enrolled'] = currently_enrolled course_enrollment_data['Enrollment Source'] = enrollment_source course_enrollment_data['Manual (Un)Enrollment Reason'] = manual_enrollment_reason course_enrollment_data['Enrollment Role'] = enrollment_role return course_enrollment_data
def get_enrollment_info(self, user, course_id): """ Returns the User Enrollment information. """ course = get_course_by_id(course_id, depth=0) is_course_staff = bool(has_access(user, 'staff', course)) # check the user enrollment role if user.is_staff: platform_name = microsite.get_value('platform_name', settings.PLATFORM_NAME) enrollment_role = _('{platform_name} Staff').format( platform_name=platform_name) elif is_course_staff: enrollment_role = _('Course Staff') else: enrollment_role = _('Student') course_enrollment = CourseEnrollment.get_enrollment( user=user, course_key=course_id) if is_course_staff: enrollment_source = _('Staff') else: # get the registration_code_redemption object if exists registration_code_redemption = RegistrationCodeRedemption.registration_code_used_for_enrollment( course_enrollment) # get the paid_course registration item if exists paid_course_reg_item = PaidCourseRegistration.get_course_item_for_user_enrollment( user=user, course_id=course_id, course_enrollment=course_enrollment) # from where the user get here if registration_code_redemption is not None: enrollment_source = _('Used Registration Code') elif paid_course_reg_item is not None: enrollment_source = _('Credit Card - Individual') else: manual_enrollment = ManualEnrollmentAudit.get_manual_enrollment( course_enrollment) if manual_enrollment is not None: enrollment_source = _( 'manually enrolled by user_id {user_id}, enrollment state transition: {transition}' ).format(user_id=manual_enrollment.enrolled_by_id, transition=manual_enrollment.state_transition) else: enrollment_source = _('Manually Enrolled') enrollment_date = course_enrollment.created.strftime("%B %d, %Y") currently_enrolled = course_enrollment.is_active course_enrollment_data = collections.OrderedDict() course_enrollment_data['Enrollment Date'] = enrollment_date course_enrollment_data['Currently Enrolled'] = currently_enrolled course_enrollment_data['Enrollment Source'] = enrollment_source course_enrollment_data['Enrollment Role'] = enrollment_role return course_enrollment_data
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)
def test_regcode_redemptions(self): """ Asserts the data model around RegistrationCodeRedemption """ self.cart.order_type = 'business' self.cart.save() CourseRegCodeItem.add_to_order(self.cart, self.course_key, 2) self.cart.purchase() reg_code = CourseRegistrationCode.objects.filter(order=self.cart)[0] enrollment = CourseEnrollment.enroll(self.user, self.course_key) redemption = RegistrationCodeRedemption( registration_code=reg_code, redeemed_by=self.user, course_enrollment=enrollment ) redemption.save() test_redemption = RegistrationCodeRedemption.registration_code_used_for_enrollment(enrollment) self.assertEqual(test_redemption.id, redemption.id) # pylint: disable=no-member
def get_enrollment_info(self, user, course_id): """ Returns the User Enrollment information. """ course = get_course_by_id(course_id, depth=0) is_course_staff = has_access(user, 'staff', course) # check the user enrollment role if user.is_staff: enrollment_role = _('Edx Staff') elif is_course_staff: enrollment_role = _('Course Staff') else: enrollment_role = _('Student') course_enrollment = CourseEnrollment.get_enrollment( user=user, course_key=course_id) if is_course_staff: enrollment_source = _('Staff') else: # get the registration_code_redemption object if exists registration_code_redemption = RegistrationCodeRedemption.registration_code_used_for_enrollment( course_enrollment) # get the paid_course registration item if exists paid_course_reg_item = PaidCourseRegistration.get_course_item_for_user_enrollment( user=user, course_id=course_id, course_enrollment=course_enrollment) # from where the user get here if registration_code_redemption is not None: enrollment_source = _('Used Registration Code') elif paid_course_reg_item is not None: enrollment_source = _('Credit Card - Individual') else: enrollment_source = _('Manually Enrolled') enrollment_date = course_enrollment.created.strftime("%B %d, %Y") currently_enrolled = course_enrollment.is_active course_enrollment_data = collections.OrderedDict() course_enrollment_data['Enrollment Date'] = enrollment_date course_enrollment_data['Currently Enrolled'] = currently_enrolled course_enrollment_data['Enrollment Source'] = enrollment_source course_enrollment_data['Enrollment Role'] = enrollment_role return course_enrollment_data
def get_enrollment_info(self, user, course_id): """ Returns the User Enrollment information. """ course = get_course_by_id(course_id, depth=0) is_course_staff = has_access(user, 'staff', course) # check the user enrollment role if user.is_staff: enrollment_role = _('Edx Staff') elif is_course_staff: enrollment_role = _('Course Staff') else: enrollment_role = _('Student') course_enrollment = CourseEnrollment.get_enrollment(user=user, course_key=course_id) if is_course_staff: enrollment_source = _('Staff') else: # get the registration_code_redemption object if exists registration_code_redemption = RegistrationCodeRedemption.registration_code_used_for_enrollment( course_enrollment) # get the paid_course registration item if exists paid_course_reg_item = PaidCourseRegistration.get_course_item_for_user_enrollment( user=user, course_id=course_id, course_enrollment=course_enrollment ) # from where the user get here if registration_code_redemption is not None: enrollment_source = _('Used Registration Code') elif paid_course_reg_item is not None: enrollment_source = _('Credit Card - Individual') else: enrollment_source = _('Manually Enrolled') enrollment_date = course_enrollment.created.strftime("%B %d, %Y") currently_enrolled = course_enrollment.is_active course_enrollment_data = collections.OrderedDict() course_enrollment_data['Enrollment Date'] = enrollment_date course_enrollment_data['Currently Enrolled'] = currently_enrolled course_enrollment_data['Enrollment Source'] = enrollment_source course_enrollment_data['Enrollment Role'] = enrollment_role return course_enrollment_data
def get_payment_info(self, user, course_id): """ Returns the User Payment information. """ course_enrollment = CourseEnrollment.get_enrollment( user=user, course_key=course_id) paid_course_reg_item = PaidCourseRegistration.get_course_item_for_user_enrollment( user=user, course_id=course_id, course_enrollment=course_enrollment) payment_data = collections.OrderedDict() # check if the user made a single self purchase scenario # for enrollment in the course. if paid_course_reg_item is not None: coupon_redemption = CouponRedemption.objects.select_related( 'coupon').filter(order_id=paid_course_reg_item.order_id) coupon_codes = [ redemption.coupon.code for redemption in coupon_redemption ] coupon_codes = ", ".join(coupon_codes) registration_code_used = 'N/A' list_price = paid_course_reg_item.get_list_price() payment_amount = paid_course_reg_item.unit_cost coupon_codes_used = coupon_codes payment_status = paid_course_reg_item.status transaction_reference_number = paid_course_reg_item.order_id else: # check if the user used a registration code for the enrollment. registration_code_redemption = RegistrationCodeRedemption.registration_code_used_for_enrollment( course_enrollment) if registration_code_redemption is not None: registration_code = registration_code_redemption.registration_code registration_code_used = registration_code.code if registration_code.invoice_item_id: list_price, payment_amount, payment_status, transaction_reference_number =\ self._get_invoice_data(registration_code_redemption) coupon_codes_used = 'N/A' elif registration_code_redemption.registration_code.order_id: list_price, payment_amount, coupon_codes_used, payment_status, transaction_reference_number = \ self._get_order_data(registration_code_redemption, course_id) else: # this happens when the registration code is not created via invoice or bulk purchase # scenario. list_price = 'N/A' payment_amount = 'N/A' coupon_codes_used = 'N/A' registration_code_used = 'N/A' payment_status = _('Data Integrity Error') transaction_reference_number = 'N/A' else: list_price = 'N/A' payment_amount = 'N/A' coupon_codes_used = 'N/A' registration_code_used = 'N/A' payment_status = _('TBD') transaction_reference_number = 'N/A' payment_data['List Price'] = list_price payment_data['Payment Amount'] = payment_amount payment_data['Coupon Codes Used'] = coupon_codes_used payment_data['Registration Code Used'] = registration_code_used payment_data['Payment Status'] = payment_status payment_data[ 'Transaction Reference Number'] = transaction_reference_number return payment_data
def get_executive_report(course_id): """ Returns dict containing information about the course executive summary. """ single_purchase_total = PaidCourseRegistration.get_total_amount_of_purchased_item( course_id) bulk_purchase_total = CourseRegCodeItem.get_total_amount_of_purchased_item( course_id) paid_invoices_total = InvoiceTransaction.get_total_amount_of_paid_course_invoices( course_id) gross_paid_revenue = single_purchase_total + bulk_purchase_total + paid_invoices_total all_invoices_total = Invoice.get_invoice_total_amount_for_course(course_id) gross_pending_revenue = all_invoices_total - float(paid_invoices_total) gross_revenue = float(gross_paid_revenue) + float(gross_pending_revenue) refunded_self_purchased_seats = PaidCourseRegistration.get_self_purchased_seat_count( course_id, status='refunded') refunded_bulk_purchased_seats = CourseRegCodeItem.get_bulk_purchased_seat_count( course_id, status='refunded') total_seats_refunded = refunded_self_purchased_seats + refunded_bulk_purchased_seats self_purchased_refunds = PaidCourseRegistration.get_total_amount_of_purchased_item( course_id, status='refunded') bulk_purchase_refunds = CourseRegCodeItem.get_total_amount_of_purchased_item( course_id, status='refunded') total_amount_refunded = self_purchased_refunds + bulk_purchase_refunds top_discounted_codes = CouponRedemption.get_top_discount_codes_used( course_id) total_coupon_codes_purchases = CouponRedemption.get_total_coupon_code_purchases( course_id) bulk_purchased_codes = CourseRegistrationCode.order_generated_registration_codes( course_id) unused_registration_codes = 0 for registration_code in bulk_purchased_codes: if not RegistrationCodeRedemption.is_registration_code_redeemed( registration_code.code): unused_registration_codes += 1 self_purchased_seat_count = PaidCourseRegistration.get_self_purchased_seat_count( course_id) bulk_purchased_seat_count = CourseRegCodeItem.get_bulk_purchased_seat_count( course_id) total_invoiced_seats = CourseRegistrationCode.invoice_generated_registration_codes( course_id).count() total_seats = self_purchased_seat_count + bulk_purchased_seat_count + total_invoiced_seats self_purchases_percentage = 0.0 bulk_purchases_percentage = 0.0 invoice_purchases_percentage = 0.0 avg_price_paid = 0.0 if total_seats != 0: self_purchases_percentage = (float(self_purchased_seat_count) / float(total_seats)) * 100 bulk_purchases_percentage = (float(bulk_purchased_seat_count) / float(total_seats)) * 100 invoice_purchases_percentage = (float(total_invoiced_seats) / float(total_seats)) * 100 avg_price_paid = gross_revenue / total_seats course = get_course_by_id(course_id, depth=0) currency = settings.PAID_COURSE_REGISTRATION_CURRENCY[1] return { 'display_name': course.display_name, 'start_date': course.start.strftime("%Y-%m-%d") if course.start is not None else 'N/A', 'end_date': course.end.strftime("%Y-%m-%d") if course.end is not None else 'N/A', 'total_seats': total_seats, 'currency': currency, 'gross_revenue': float(gross_revenue), 'gross_paid_revenue': float(gross_paid_revenue), 'gross_pending_revenue': gross_pending_revenue, 'total_seats_refunded': total_seats_refunded, 'total_amount_refunded': float(total_amount_refunded), 'average_paid_price': float(avg_price_paid), 'discount_codes_data': top_discounted_codes, 'total_seats_using_discount_codes': total_coupon_codes_purchases, 'total_self_purchase_seats': self_purchased_seat_count, 'total_bulk_purchase_seats': bulk_purchased_seat_count, 'total_invoiced_seats': total_invoiced_seats, 'unused_bulk_purchase_code_count': unused_registration_codes, 'self_purchases_percentage': self_purchases_percentage, 'bulk_purchases_percentage': bulk_purchases_percentage, 'invoice_purchases_percentage': invoice_purchases_percentage, }
def get_executive_report(course_id): """ Returns dict containing information about the course executive summary. """ single_purchase_total = PaidCourseRegistration.get_total_amount_of_purchased_item(course_id) bulk_purchase_total = CourseRegCodeItem.get_total_amount_of_purchased_item(course_id) paid_invoices_total = InvoiceTransaction.get_total_amount_of_paid_course_invoices(course_id) gross_paid_revenue = single_purchase_total + bulk_purchase_total + paid_invoices_total all_invoices_total = Invoice.get_invoice_total_amount_for_course(course_id) gross_pending_revenue = all_invoices_total - float(paid_invoices_total) gross_revenue = float(gross_paid_revenue) + float(gross_pending_revenue) refunded_self_purchased_seats = PaidCourseRegistration.get_self_purchased_seat_count( course_id, status='refunded' ) refunded_bulk_purchased_seats = CourseRegCodeItem.get_bulk_purchased_seat_count( course_id, status='refunded' ) total_seats_refunded = refunded_self_purchased_seats + refunded_bulk_purchased_seats self_purchased_refunds = PaidCourseRegistration.get_total_amount_of_purchased_item( course_id, status='refunded' ) bulk_purchase_refunds = CourseRegCodeItem.get_total_amount_of_purchased_item(course_id, status='refunded') total_amount_refunded = self_purchased_refunds + bulk_purchase_refunds top_discounted_codes = CouponRedemption.get_top_discount_codes_used(course_id) total_coupon_codes_purchases = CouponRedemption.get_total_coupon_code_purchases(course_id) bulk_purchased_codes = CourseRegistrationCode.order_generated_registration_codes(course_id) unused_registration_codes = 0 for registration_code in bulk_purchased_codes: if not RegistrationCodeRedemption.is_registration_code_redeemed(registration_code.code): unused_registration_codes += 1 self_purchased_seat_count = PaidCourseRegistration.get_self_purchased_seat_count(course_id) bulk_purchased_seat_count = CourseRegCodeItem.get_bulk_purchased_seat_count(course_id) total_invoiced_seats = CourseRegistrationCode.invoice_generated_registration_codes(course_id).count() total_seats = self_purchased_seat_count + bulk_purchased_seat_count + total_invoiced_seats self_purchases_percentage = 0.0 bulk_purchases_percentage = 0.0 invoice_purchases_percentage = 0.0 avg_price_paid = 0.0 if total_seats != 0: self_purchases_percentage = (float(self_purchased_seat_count) / float(total_seats)) * 100 bulk_purchases_percentage = (float(bulk_purchased_seat_count) / float(total_seats)) * 100 invoice_purchases_percentage = (float(total_invoiced_seats) / float(total_seats)) * 100 avg_price_paid = gross_revenue / total_seats course = get_course_by_id(course_id, depth=0) currency = settings.PAID_COURSE_REGISTRATION_CURRENCY[1] return { 'display_name': course.display_name, 'start_date': course.start.strftime("%Y-%m-%d") if course.start is not None else 'N/A', 'end_date': course.end.strftime("%Y-%m-%d") if course.end is not None else 'N/A', 'total_seats': total_seats, 'currency': currency, 'gross_revenue': float(gross_revenue), 'gross_paid_revenue': float(gross_paid_revenue), 'gross_pending_revenue': gross_pending_revenue, 'total_seats_refunded': total_seats_refunded, 'total_amount_refunded': float(total_amount_refunded), 'average_paid_price': float(avg_price_paid), 'discount_codes_data': top_discounted_codes, 'total_seats_using_discount_codes': total_coupon_codes_purchases, 'total_self_purchase_seats': self_purchased_seat_count, 'total_bulk_purchase_seats': bulk_purchased_seat_count, 'total_invoiced_seats': total_invoiced_seats, 'unused_bulk_purchase_code_count': unused_registration_codes, 'self_purchases_percentage': self_purchases_percentage, 'bulk_purchases_percentage': bulk_purchases_percentage, 'invoice_purchases_percentage': invoice_purchases_percentage, }
def get_payment_info(self, user, course_id): """ Returns the User Payment information. """ course_enrollment = CourseEnrollment.get_enrollment(user=user, course_key=course_id) paid_course_reg_item = PaidCourseRegistration.get_course_item_for_user_enrollment( user=user, course_id=course_id, course_enrollment=course_enrollment ) payment_data = collections.OrderedDict() # check if the user made a single self purchase scenario # for enrollment in the course. if paid_course_reg_item is not None: coupon_redemption = CouponRedemption.objects.select_related('coupon').filter( order_id=paid_course_reg_item.order_id) coupon_codes = [redemption.coupon.code for redemption in coupon_redemption] coupon_codes = ", ".join(coupon_codes) registration_code_used = 'N/A' list_price = paid_course_reg_item.get_list_price() payment_amount = paid_course_reg_item.unit_cost coupon_codes_used = coupon_codes payment_status = paid_course_reg_item.status transaction_reference_number = paid_course_reg_item.order_id else: # check if the user used a registration code for the enrollment. registration_code_redemption = RegistrationCodeRedemption.registration_code_used_for_enrollment( course_enrollment) if registration_code_redemption is not None: registration_code = registration_code_redemption.registration_code registration_code_used = registration_code.code if registration_code.invoice_item_id: list_price, payment_amount, payment_status, transaction_reference_number =\ self._get_invoice_data(registration_code_redemption) coupon_codes_used = 'N/A' elif registration_code_redemption.registration_code.order_id: list_price, payment_amount, coupon_codes_used, payment_status, transaction_reference_number = \ self._get_order_data(registration_code_redemption, course_id) else: # this happens when the registration code is not created via invoice or bulk purchase # scenario. list_price = 'N/A' payment_amount = 'N/A' coupon_codes_used = 'N/A' registration_code_used = 'N/A' payment_status = _('Data Integrity Error') transaction_reference_number = 'N/A' else: list_price = 'N/A' payment_amount = 'N/A' coupon_codes_used = 'N/A' registration_code_used = 'N/A' payment_status = _('TBD') transaction_reference_number = 'N/A' payment_data['List Price'] = list_price payment_data['Payment Amount'] = payment_amount payment_data['Coupon Codes Used'] = coupon_codes_used payment_data['Registration Code Used'] = registration_code_used payment_data['Payment Status'] = payment_status payment_data['Transaction Reference Number'] = transaction_reference_number return payment_data