36e07f6be8
Create a Javascript function to log upsell events to & attach the eventing to the course dashboard upsell button. The revenue squad is looking for more insight into which buttons users are clicking to get to the checkout page.
425 lines
18 KiB
Python
425 lines
18 KiB
Python
"""
|
|
Utilities to facilitate experimentation
|
|
"""
|
|
|
|
|
|
import logging
|
|
from decimal import Decimal
|
|
|
|
import six
|
|
from django.utils.timezone import now
|
|
from opaque_keys import InvalidKeyError
|
|
from opaque_keys.edx.keys import CourseKey
|
|
|
|
from course_modes.models import format_course_price, get_cosmetic_verified_display_price, CourseMode
|
|
from lms.djangoapps.courseware.access import has_staff_access_to_preview_mode
|
|
from lms.djangoapps.courseware.utils import verified_upgrade_deadline_link, can_show_verified_upgrade
|
|
from entitlements.models import CourseEntitlement
|
|
from lms.djangoapps.commerce.utils import EcommerceService
|
|
from openedx.core.djangoapps.catalog.utils import get_programs
|
|
from openedx.core.djangoapps.django_comment_common.models import Role
|
|
from openedx.core.djangoapps.schedules.models import Schedule
|
|
from openedx.core.djangoapps.waffle_utils import WaffleFlag, WaffleFlagNamespace
|
|
from openedx.features.course_duration_limits.access import get_user_course_expiration_date, get_user_course_duration
|
|
from openedx.features.course_duration_limits.models import CourseDurationLimitConfig
|
|
from student.models import CourseEnrollment
|
|
from xmodule.partitions.partitions_service import get_all_partitions_for_course, get_user_partition_groups
|
|
|
|
# Import this for backwards compatibility (so that anyone importing this function from here doesn't break)
|
|
from .stable_bucketing import stable_bucketing_hash_group # pylint: disable=unused-import
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
# TODO: clean up as part of REVEM-199 (START)
|
|
experiments_namespace = WaffleFlagNamespace(name=u'experiments')
|
|
|
|
# .. toggle_name: experiments.add_programs
|
|
# .. toggle_implementation: WaffleFlag
|
|
# .. toggle_default: False
|
|
# .. toggle_description: Toggle for adding the current course's program information to user metadata
|
|
# .. toggle_category: experiments
|
|
# .. toggle_use_cases: monitored_rollout
|
|
# .. toggle_creation_date: 2019-2-25
|
|
# .. toggle_expiration_date: None
|
|
# .. toggle_warnings: None
|
|
# .. toggle_tickets: REVEM-63, REVEM-198
|
|
# .. toggle_status: supported
|
|
PROGRAM_INFO_FLAG = WaffleFlag(
|
|
waffle_namespace=experiments_namespace,
|
|
flag_name=u'add_programs',
|
|
)
|
|
|
|
# .. toggle_name: experiments.add_dashboard_info
|
|
# .. toggle_implementation: WaffleFlag
|
|
# .. toggle_default: False
|
|
# .. toggle_description: Toggle for adding info about each course to the dashboard metadata
|
|
# .. toggle_category: experiments
|
|
# .. toggle_use_cases: monitored_rollout
|
|
# .. toggle_creation_date: 2019-3-28
|
|
# .. toggle_expiration_date: None
|
|
# .. toggle_warnings: None
|
|
# .. toggle_tickets: REVEM-118
|
|
# .. toggle_status: supported
|
|
DASHBOARD_INFO_FLAG = WaffleFlag(experiments_namespace, u'add_dashboard_info')
|
|
# TODO END: clean up as part of REVEM-199 (End)
|
|
|
|
# TODO: Clean up as part of REV-1205 (START)
|
|
# .. toggle_name: experiments.add_upsell_tracking
|
|
# .. toggle_implementation: WaffleFlag
|
|
# .. toggle_default: False
|
|
# .. toggle_description: Make sure upsell tracking JS works as expected.
|
|
# .. toggle_category: experiments
|
|
# .. toggle_use_cases: monitored_rollout
|
|
# .. toggle_creation_date: 2020-7-7
|
|
# .. toggle_expiration_date: None
|
|
# .. toggle_warnings: None
|
|
# .. toggle_tickets: REV-1205
|
|
# .. toggle_status: supported
|
|
UPSELL_TRACKING_FLAG = WaffleFlag(
|
|
waffle_namespace=experiments_namespace,
|
|
flag_name=u'add_upsell_tracking'
|
|
)
|
|
# TODO END: Clean up as part of REV-1205 (End)
|
|
|
|
|
|
def check_and_get_upgrade_link_and_date(user, enrollment=None, course=None):
|
|
"""
|
|
For an authenticated user, return a link to allow them to upgrade
|
|
in the specified course.
|
|
|
|
Returns the upgrade link and upgrade deadline for a user in a given course given
|
|
that the user is within the window to upgrade defined by our dynamic pacing feature;
|
|
otherwise, returns None for both the link and date.
|
|
"""
|
|
if enrollment is None and course is None:
|
|
logger.warning(u'Must specify either an enrollment or a course')
|
|
return (None, None, None)
|
|
|
|
if enrollment:
|
|
if course and enrollment.course_id != course.id:
|
|
logger.warning(u'{} refers to a different course than {} which was supplied. Enrollment course id={}, '
|
|
u'repr={!r}, deprecated={}. Course id={}, repr={!r}, deprecated={}.'
|
|
.format(enrollment,
|
|
course,
|
|
enrollment.course_id,
|
|
enrollment.course_id,
|
|
enrollment.course_id.deprecated,
|
|
course.id,
|
|
course.id,
|
|
course.id.deprecated
|
|
)
|
|
)
|
|
return (None, None, None)
|
|
|
|
if enrollment.user_id != user.id:
|
|
logger.warning(u'{} refers to a different user than {} which was supplied. '
|
|
u'Enrollment user id={}, repr={!r}. '
|
|
u'User id={}, repr={!r}.'.format(enrollment,
|
|
user,
|
|
enrollment.user_id,
|
|
enrollment.user_id,
|
|
user.id,
|
|
user.id,
|
|
)
|
|
)
|
|
return (None, None, None)
|
|
|
|
if enrollment is None:
|
|
enrollment = CourseEnrollment.get_enrollment(user, course.id)
|
|
if enrollment is None:
|
|
return (None, None, None)
|
|
|
|
if user.is_authenticated and can_show_verified_upgrade(user, enrollment, course):
|
|
return (
|
|
verified_upgrade_deadline_link(user, enrollment.course),
|
|
enrollment.upgrade_deadline,
|
|
enrollment.course_upgrade_deadline,
|
|
)
|
|
|
|
return (None, None, enrollment.course_upgrade_deadline)
|
|
|
|
|
|
# TODO: clean up as part of REVEM-199 (START)
|
|
def get_program_price_and_skus(courses):
|
|
"""
|
|
Get the total program price and purchase skus from these courses in the program
|
|
"""
|
|
program_price = 0
|
|
skus = []
|
|
|
|
for course in courses:
|
|
course_price, course_sku = get_course_entitlement_price_and_sku(course)
|
|
if course_price is not None and course_sku is not None:
|
|
program_price = Decimal(program_price) + Decimal(course_price)
|
|
skus.append(course_sku)
|
|
|
|
if program_price <= 0:
|
|
program_price = None
|
|
skus = None
|
|
else:
|
|
program_price = format_course_price(program_price)
|
|
program_price = six.text_type(program_price)
|
|
|
|
return program_price, skus
|
|
|
|
|
|
def get_course_entitlement_price_and_sku(course):
|
|
"""
|
|
Get the entitlement price and sku from this course.
|
|
Try to get them from the first non-expired, verified entitlement that has a price and a sku. If that doesn't work,
|
|
fall back to the first non-expired, verified course run that has a price and a sku.
|
|
"""
|
|
for entitlement in course.get('entitlements', []):
|
|
if entitlement.get('mode') == 'verified' and entitlement['price'] and entitlement['sku']:
|
|
expires = entitlement.get('expires')
|
|
if not expires or expires > now():
|
|
return entitlement['price'], entitlement['sku']
|
|
|
|
course_runs = course.get('course_runs', [])
|
|
published_course_runs = [run for run in course_runs if run['status'] == 'published']
|
|
for published_course_run in published_course_runs:
|
|
for seat in published_course_run['seats']:
|
|
if seat.get('type') == 'verified' and seat['price'] and seat['sku']:
|
|
price = Decimal(seat.get('price'))
|
|
return price, seat.get('sku')
|
|
|
|
return None, None
|
|
|
|
|
|
def get_unenrolled_courses(courses, user_enrollments):
|
|
"""
|
|
Given a list of courses and a list of user enrollments, return the courses in which the user is not enrolled.
|
|
Depending on the enrollments that are passed in, this method can be used to determine the courses in a program in
|
|
which the user has not yet enrolled or the courses in a program for which the user has not yet purchased a
|
|
certificate.
|
|
"""
|
|
# Get the enrollment course ids here, so we don't need to loop through them for every course run
|
|
enrollment_course_ids = {enrollment.course_id for enrollment in user_enrollments}
|
|
unenrolled_courses = []
|
|
|
|
for course in courses:
|
|
if not is_enrolled_in_course(course, enrollment_course_ids):
|
|
unenrolled_courses.append(course)
|
|
return unenrolled_courses
|
|
|
|
|
|
def is_enrolled_in_all_courses(courses, user_enrollments):
|
|
"""
|
|
Determine if the user is enrolled in all of the courses
|
|
"""
|
|
# Get the enrollment course ids here, so we don't need to loop through them for every course run
|
|
enrollment_course_ids = {enrollment.course_id for enrollment in user_enrollments}
|
|
|
|
for course in courses:
|
|
if not is_enrolled_in_course(course, enrollment_course_ids):
|
|
# User is not enrolled in this course, meaning they are not enrolled in all courses in the program
|
|
return False
|
|
# User is enrolled in all courses in the program
|
|
return True
|
|
|
|
|
|
def is_enrolled_in_course(course, enrollment_course_ids):
|
|
"""
|
|
Determine if the user is enrolled in this course
|
|
"""
|
|
course_runs = course.get('course_runs')
|
|
if course_runs:
|
|
for course_run in course_runs:
|
|
if is_enrolled_in_course_run(course_run, enrollment_course_ids):
|
|
return True
|
|
return False
|
|
|
|
|
|
def is_enrolled_in_course_run(course_run, enrollment_course_ids):
|
|
"""
|
|
Determine if the user is enrolled in this course run
|
|
"""
|
|
key = None
|
|
try:
|
|
key = course_run.get('key')
|
|
course_run_key = CourseKey.from_string(key)
|
|
return course_run_key in enrollment_course_ids
|
|
except InvalidKeyError:
|
|
logger.warning(
|
|
u'Unable to determine if user was enrolled since the course key {} is invalid'.format(key)
|
|
)
|
|
return False # Invalid course run key. Assume user is not enrolled.
|
|
|
|
|
|
def get_dashboard_course_info(user, dashboard_enrollments):
|
|
"""
|
|
Given a list of enrollments shown on the dashboard, return a dict of course ids and experiment info for that course
|
|
"""
|
|
course_info = None
|
|
if DASHBOARD_INFO_FLAG.is_enabled():
|
|
# Get the enrollments here since the dashboard filters out those with completed entitlements
|
|
user_enrollments = CourseEnrollment.objects.select_related('course').filter(user_id=user.id)
|
|
|
|
course_info = {
|
|
str(dashboard_enrollment.course): get_base_experiment_metadata_context(dashboard_enrollment.course,
|
|
user,
|
|
dashboard_enrollment,
|
|
user_enrollments)
|
|
for dashboard_enrollment in dashboard_enrollments
|
|
}
|
|
return course_info
|
|
# TODO: clean up as part of REVEM-199 (END)
|
|
|
|
|
|
def get_experiment_user_metadata_context(course, user):
|
|
"""
|
|
Return a context dictionary with the keys used by the user_metadata.html.
|
|
"""
|
|
enrollment = None
|
|
# TODO: clean up as part of REVO-28 (START)
|
|
user_enrollments = None
|
|
audit_enrollments = None
|
|
has_non_audit_enrollments = False
|
|
try:
|
|
user_enrollments = CourseEnrollment.objects.select_related('course', 'schedule').filter(user_id=user.id)
|
|
has_non_audit_enrollments = user_enrollments.exclude(mode__in=CourseMode.UPSELL_TO_VERIFIED_MODES).exists()
|
|
# TODO: clean up as part of REVO-28 (END)
|
|
enrollment = CourseEnrollment.objects.select_related(
|
|
'course', 'schedule'
|
|
).get(user_id=user.id, course_id=course.id)
|
|
except CourseEnrollment.DoesNotExist:
|
|
pass # Not enrolled, use the default values
|
|
|
|
has_entitlements = False
|
|
if user.is_authenticated:
|
|
has_entitlements = CourseEntitlement.objects.filter(user=user).exists()
|
|
|
|
context = get_base_experiment_metadata_context(course, user, enrollment, user_enrollments)
|
|
has_staff_access = has_staff_access_to_preview_mode(user, course.id)
|
|
forum_roles = []
|
|
if user.is_authenticated:
|
|
forum_roles = list(Role.objects.filter(users=user, course_id=course.id).values_list('name').distinct())
|
|
|
|
# get user partition data
|
|
if user.is_authenticated:
|
|
partition_groups = get_all_partitions_for_course(course)
|
|
user_partitions = get_user_partition_groups(course.id, partition_groups, user, 'name')
|
|
else:
|
|
user_partitions = {}
|
|
|
|
# TODO: clean up as part of REVO-28 (START)
|
|
context['has_non_audit_enrollments'] = has_non_audit_enrollments or has_entitlements
|
|
# TODO: clean up as part of REVO-28 (END)
|
|
context['has_staff_access'] = has_staff_access
|
|
context['forum_roles'] = forum_roles
|
|
context['partition_groups'] = user_partitions
|
|
return context
|
|
|
|
|
|
def get_base_experiment_metadata_context(course, user, enrollment, user_enrollments):
|
|
"""
|
|
Return a context dictionary with the keys used by dashboard_metadata.html and user_metadata.html
|
|
"""
|
|
enrollment_mode = None
|
|
enrollment_time = None
|
|
# TODO: clean up as part of REVEM-199 (START)
|
|
program_key = get_program_context(course, user_enrollments)
|
|
# TODO: clean up as part of REVEM-199 (END)
|
|
schedule_start = None
|
|
if enrollment and enrollment.is_active:
|
|
enrollment_mode = enrollment.mode
|
|
enrollment_time = enrollment.created
|
|
|
|
try:
|
|
schedule_start = enrollment.schedule.start_date
|
|
except Schedule.DoesNotExist:
|
|
pass
|
|
|
|
# upgrade_link, dynamic_upgrade_deadline and course_upgrade_deadline should be None
|
|
# if user has passed their dynamic pacing deadline.
|
|
upgrade_link, dynamic_upgrade_deadline, course_upgrade_deadline = check_and_get_upgrade_link_and_date(
|
|
user, enrollment, course
|
|
)
|
|
|
|
deadline, duration = get_audit_access_expiration(user, course)
|
|
|
|
return {
|
|
'upgrade_link': upgrade_link,
|
|
'upgrade_price': six.text_type(get_cosmetic_verified_display_price(course)),
|
|
'enrollment_mode': enrollment_mode,
|
|
'enrollment_time': enrollment_time,
|
|
'schedule_start': schedule_start,
|
|
'pacing_type': 'self_paced' if course.self_paced else 'instructor_paced',
|
|
'dynamic_upgrade_deadline': dynamic_upgrade_deadline,
|
|
'course_upgrade_deadline': course_upgrade_deadline,
|
|
'audit_access_deadline': deadline,
|
|
'course_duration': duration,
|
|
'course_key': course.id,
|
|
'course_start': course.start,
|
|
'course_end': course.end,
|
|
# TODO: clean up as part of REVEM-199 (START)
|
|
'program_key_fields': program_key,
|
|
# TODO: clean up as part of REVEM-199 (END)
|
|
}
|
|
|
|
|
|
def get_audit_access_expiration(user, course):
|
|
"""
|
|
Return the expiration date and course duration for the user's audit access to this course.
|
|
"""
|
|
if not CourseDurationLimitConfig.enabled_for_enrollment(user, course):
|
|
return None, None
|
|
|
|
return get_user_course_expiration_date(user, course), get_user_course_duration(user, course)
|
|
|
|
|
|
# TODO: clean up as part of REVEM-199 (START)
|
|
def get_program_context(course, user_enrollments):
|
|
"""
|
|
Return a context dictionary with program information.
|
|
"""
|
|
program_key = None
|
|
non_audit_enrollments = user_enrollments.exclude(mode__in=CourseMode.UPSELL_TO_VERIFIED_MODES)
|
|
|
|
if PROGRAM_INFO_FLAG.is_enabled():
|
|
programs = get_programs(course=course.id)
|
|
if programs:
|
|
# A course can be in multiple programs, but we're just grabbing the first one
|
|
program = programs[0]
|
|
complete_enrollment = False
|
|
has_courses_left_to_purchase = False
|
|
total_courses = None
|
|
courses = program.get('courses')
|
|
courses_left_to_purchase_price = None
|
|
courses_left_to_purchase_url = None
|
|
program_uuid = program.get('uuid')
|
|
is_eligible_for_one_click_purchase = program.get('is_program_eligible_for_one_click_purchase')
|
|
if courses is not None:
|
|
total_courses = len(courses)
|
|
complete_enrollment = is_enrolled_in_all_courses(courses, user_enrollments)
|
|
|
|
# Get the price and purchase URL of the program courses the user has yet to purchase. Say a
|
|
# program has 3 courses (A, B and C), and the user previously purchased a certificate for A.
|
|
# The user is enrolled in audit mode for B. The "left to purchase price" should be the price of
|
|
# B+C.
|
|
courses_left_to_purchase = get_unenrolled_courses(courses, non_audit_enrollments)
|
|
if courses_left_to_purchase:
|
|
has_courses_left_to_purchase = True
|
|
if courses_left_to_purchase and is_eligible_for_one_click_purchase:
|
|
courses_left_to_purchase_price, courses_left_to_purchase_skus = \
|
|
get_program_price_and_skus(courses_left_to_purchase)
|
|
if courses_left_to_purchase_skus:
|
|
courses_left_to_purchase_url = EcommerceService().get_checkout_page_url(
|
|
*courses_left_to_purchase_skus, program_uuid=program_uuid)
|
|
|
|
program_key = {
|
|
'uuid': program_uuid,
|
|
'title': program.get('title'),
|
|
'marketing_url': program.get('marketing_url'),
|
|
'status': program.get('status'),
|
|
'is_eligible_for_one_click_purchase': is_eligible_for_one_click_purchase,
|
|
'total_courses': total_courses,
|
|
'complete_enrollment': complete_enrollment,
|
|
'has_courses_left_to_purchase': has_courses_left_to_purchase,
|
|
'courses_left_to_purchase_price': courses_left_to_purchase_price,
|
|
'courses_left_to_purchase_url': courses_left_to_purchase_url,
|
|
}
|
|
return program_key
|
|
# TODO: clean up as part of REVEM-199 (START)
|