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
