def can_receive_discount(user, course, discount_expiration_date=None): """ Check all the business logic about whether this combination of user and course can receive a discount. """ # Always disable discounts until we are ready to enable this feature with impersonate(user): if not DISCOUNT_APPLICABILITY_FLAG.is_enabled(): return False # TODO: Add additional conditions to return False here # anonymous users should never get the discount if user.is_anonymous: return False # Check if discount has expired if not discount_expiration_date: discount_expiration_date = get_discount_expiration_date(user, course) if discount_expiration_date is None: return False if discount_expiration_date < timezone.now(): return False # Course end date needs to be in the future if course.has_ended(): return False # Course needs to have a non-expired verified mode modes_dict = CourseMode.modes_for_course_dict(course=course, include_expired=False) verified_mode = modes_dict.get('verified', None) if not verified_mode: return False # Site, Partner, Course or Course Run not excluded from lms-controlled discounts if DiscountRestrictionConfig.disabled_for_course_stacked_config(course): return False # Don't allow users who have enrolled in any courses in non-upsellable # modes if CourseEnrollment.objects.filter(user=user).exclude(mode__in=CourseMode.UPSELL_TO_VERIFIED_MODES).exists(): return False # Don't allow any users who have entitlements (past or present) if CourseEntitlement.objects.filter(user=user).exists(): return False # We can't import this at Django load time within the openedx tests settings context from openedx.features.enterprise_support.utils import is_enterprise_learner # Don't give discount to enterprise users if is_enterprise_learner(user): return False # Excute holdback if _is_in_holdback(user): return False return True
def can_receive_discount(user, course): # pylint: disable=unused-argument """ Check all the business logic about whether this combination of user and course can receive a discount. """ # Always disable discounts until we are ready to enable this feature if not DISCOUNT_APPLICABILITY_FLAG.is_enabled(): return False # TODO: Add additional conditions to return False here # Course end date needs to be in the future if course.has_ended(): return False # Course needs to have a non-expired verified mode modes_dict = CourseMode.modes_for_course_dict(course=course, include_expired=False) verified_mode = modes_dict.get('verified', None) if not verified_mode: return False # Site, Partner, Course or Course Run not excluded from lms-controlled discounts if DiscountRestrictionConfig.disabled_for_course_stacked_config(course): return False return True
def test_config_overrides(self, global_setting, site_setting, org_setting, course_setting): """ Test that the stacked configuration overrides happen in the correct order and priority. This is tested by exhaustively setting each combination of contexts, and validating that only the lowest level context that is set to not-None is applied. """ # Add a bunch of configuration outside the contexts that are being tested, to make sure # there are no leaks of configuration across contexts non_test_course_disabled = CourseOverviewFactory.create(org='non-test-org-disabled') non_test_course_enabled = CourseOverviewFactory.create(org='non-test-org-enabled') non_test_site_cfg_disabled = SiteConfigurationFactory.create( site_values={'course_org_filter': non_test_course_disabled.org} ) non_test_site_cfg_enabled = SiteConfigurationFactory.create( site_values={'course_org_filter': non_test_course_enabled.org} ) DiscountRestrictionConfig.objects.create(course=non_test_course_disabled, disabled=True) DiscountRestrictionConfig.objects.create(course=non_test_course_enabled, disabled=False) DiscountRestrictionConfig.objects.create(org=non_test_course_disabled.org, disabled=True) DiscountRestrictionConfig.objects.create(org=non_test_course_enabled.org, disabled=False) DiscountRestrictionConfig.objects.create(site=non_test_site_cfg_disabled.site, disabled=True) DiscountRestrictionConfig.objects.create(site=non_test_site_cfg_enabled.site, disabled=False) # Set up test objects test_course = CourseOverviewFactory.create(org='test-org') test_site_cfg = SiteConfigurationFactory.create( site_values={'course_org_filter': test_course.org} ) DiscountRestrictionConfig.objects.create(disabled=global_setting) DiscountRestrictionConfig.objects.create(course=test_course, disabled=course_setting) DiscountRestrictionConfig.objects.create(org=test_course.org, disabled=org_setting) DiscountRestrictionConfig.objects.create(site=test_site_cfg.site, disabled=site_setting) expected_global_setting = self._resolve_settings([global_setting]) expected_site_setting = self._resolve_settings([global_setting, site_setting]) expected_org_setting = self._resolve_settings([global_setting, site_setting, org_setting]) expected_course_setting = self._resolve_settings([global_setting, site_setting, org_setting, course_setting]) self.assertEqual(expected_global_setting, DiscountRestrictionConfig.current().disabled) self.assertEqual(expected_site_setting, DiscountRestrictionConfig.current(site=test_site_cfg.site).disabled) self.assertEqual(expected_org_setting, DiscountRestrictionConfig.current(org=test_course.org).disabled) self.assertEqual(expected_course_setting, DiscountRestrictionConfig.current(course_key=test_course.id).disabled)
def test_disabled_for_course_stacked_config( self, disabled, ): DiscountRestrictionConfig.objects.create( disabled=disabled, course=self.course_overview, ) course_key = self.course_overview.id assert disabled == DiscountRestrictionConfig.current( course_key=course_key).disabled
def can_receive_discount(user, course): # pylint: disable=unused-argument """ Check all the business logic about whether this combination of user and course can receive a discount. """ # Always disable discounts until we are ready to enable this feature with impersonate(user): if not DISCOUNT_APPLICABILITY_FLAG.is_enabled(): return False # TODO: Add additional conditions to return False here # Course end date needs to be in the future if course.has_ended(): return False # Course needs to have a non-expired verified mode modes_dict = CourseMode.modes_for_course_dict(course=course, include_expired=False) verified_mode = modes_dict.get('verified', None) if not verified_mode: return False # Site, Partner, Course or Course Run not excluded from lms-controlled discounts if DiscountRestrictionConfig.disabled_for_course_stacked_config(course): return False # Don't allow users who have enrolled in any courses in non-upsellable # modes if CourseEnrollment.objects.filter(user=user).exclude( mode__in=CourseMode.UPSELL_TO_VERIFIED_MODES).exists(): return False # Don't allow any users who have entitlements (past or present) if CourseEntitlement.objects.filter(user=user).exists(): return False # Excute holdback if _is_in_holdback(user): return False return True