460 lines
17 KiB
Python
460 lines
17 KiB
Python
"""Utilities to assist with commerce tasks."""
|
|
|
|
|
|
import json
|
|
import logging
|
|
from urllib.parse import urlencode, urljoin
|
|
|
|
import requests
|
|
import waffle # lint-amnesty, pylint: disable=invalid-django-waffle-import
|
|
from django.conf import settings
|
|
from django.contrib.auth import get_user_model
|
|
from django.urls import reverse
|
|
from django.utils.translation import gettext as _
|
|
|
|
from common.djangoapps.course_modes.models import CourseMode
|
|
from openedx.core.djangoapps.commerce.utils import (
|
|
get_ecommerce_api_base_url,
|
|
get_ecommerce_api_client,
|
|
is_commerce_service_configured
|
|
)
|
|
from openedx.core.djangoapps.site_configuration import helpers as configuration_helpers
|
|
from openedx.core.djangoapps.theming import helpers as theming_helpers
|
|
|
|
from .models import CommerceConfiguration
|
|
from edx_django_utils.plugins import pluggable_override
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
def is_account_activation_requirement_disabled():
|
|
"""
|
|
Checks to see if the django-waffle switch for disabling the account activation requirement is active
|
|
|
|
Returns:
|
|
Boolean value representing switch status
|
|
"""
|
|
switch_name = configuration_helpers.get_value(
|
|
'DISABLE_ACCOUNT_ACTIVATION_REQUIREMENT_SWITCH',
|
|
settings.DISABLE_ACCOUNT_ACTIVATION_REQUIREMENT_SWITCH
|
|
)
|
|
return waffle.switch_is_active(switch_name)
|
|
|
|
|
|
class EcommerceService:
|
|
""" Helper class for ecommerce service integration. """
|
|
|
|
def __init__(self):
|
|
self.config = CommerceConfiguration.current()
|
|
|
|
@property
|
|
def ecommerce_url_root(self):
|
|
""" Retrieve Ecommerce service public url root. """
|
|
return configuration_helpers.get_value('ECOMMERCE_PUBLIC_URL_ROOT', settings.ECOMMERCE_PUBLIC_URL_ROOT)
|
|
|
|
@pluggable_override('OVERRIDE_GET_ABSOLUTE_ECOMMERCE_URL')
|
|
def get_absolute_ecommerce_url(self, ecommerce_page_url):
|
|
""" Return the absolute URL to the ecommerce page.
|
|
|
|
Args:
|
|
ecommerce_page_url (str): Relative path to the ecommerce page.
|
|
|
|
Returns:
|
|
Absolute path to the ecommerce page.
|
|
"""
|
|
return urljoin(self.ecommerce_url_root, ecommerce_page_url)
|
|
|
|
def get_order_dashboard_url(self):
|
|
""" Return the URL to the ecommerce dashboard orders page.
|
|
|
|
Returns:
|
|
String: order dashboard url.
|
|
"""
|
|
return self.get_absolute_ecommerce_url(CommerceConfiguration.DEFAULT_ORDER_DASHBOARD_URL)
|
|
|
|
def get_receipt_page_url(self, order_number):
|
|
"""
|
|
Gets the URL for the Order Receipt page hosted by the ecommerce service.
|
|
|
|
Args:
|
|
order_number (str): Order number.
|
|
|
|
Returns:
|
|
Receipt page for the specified Order.
|
|
"""
|
|
|
|
return self.get_absolute_ecommerce_url(CommerceConfiguration.DEFAULT_RECEIPT_PAGE_URL + order_number)
|
|
|
|
def is_enabled(self, user):
|
|
"""
|
|
Determines the availability of the EcommerceService based on user activation and service configuration.
|
|
Note: If the user is anonymous we bypass the user activation gate and only look at the service config.
|
|
|
|
Returns:
|
|
Boolean
|
|
"""
|
|
user_is_active = user.is_active or is_account_activation_requirement_disabled()
|
|
allow_user = user_is_active or user.is_anonymous
|
|
return allow_user and self.config.checkout_on_ecommerce_service
|
|
|
|
def payment_page_url(self):
|
|
""" Return the URL for the checkout page.
|
|
|
|
Example:
|
|
http://localhost:8002/basket/add/
|
|
"""
|
|
return self.get_absolute_ecommerce_url(self.config.basket_checkout_page)
|
|
|
|
@pluggable_override('OVERRIDE_GET_CHECKOUT_PAGE_URL')
|
|
def get_checkout_page_url(self, *skus, **kwargs):
|
|
""" Construct the URL to the ecommerce checkout page and include products.
|
|
|
|
Args:
|
|
skus (list): List of SKUs associated with products to be added to basket
|
|
program_uuid (string): The UUID of the program, if applicable
|
|
course_run_keys (list): The course run keys of the products to be added to basket.
|
|
|
|
Returns:
|
|
Absolute path to the ecommerce checkout page showing basket that contains specified products.
|
|
|
|
Example:
|
|
http://localhost:8002/basket/add/?sku=5H3HG5&sku=57FHHD
|
|
http://localhost:8002/basket/add/?sku=5H3HG5&sku=57FHHD&bundle=3bdf1dd1-49be-4a15-9145-38901f578c5a
|
|
"""
|
|
program_uuid = kwargs.get('program_uuid')
|
|
enterprise_catalog_uuid = kwargs.get('catalog')
|
|
query_params = {'sku': skus}
|
|
if enterprise_catalog_uuid:
|
|
query_params.update({'catalog': enterprise_catalog_uuid})
|
|
|
|
url = '{checkout_page_path}?{query_params}'.format(
|
|
checkout_page_path=self.get_absolute_ecommerce_url(self.config.basket_checkout_page),
|
|
query_params=urlencode(query_params, doseq=True),
|
|
)
|
|
if program_uuid:
|
|
url = '{url}&bundle={program_uuid}'.format(
|
|
url=url,
|
|
program_uuid=program_uuid
|
|
)
|
|
return url
|
|
|
|
def upgrade_url(self, user, course_key):
|
|
"""
|
|
Returns the URL for the user to upgrade, or None if not applicable.
|
|
"""
|
|
course_run_key = str(course_key)
|
|
|
|
verified_mode = CourseMode.verified_mode_for_course(course_key)
|
|
if verified_mode:
|
|
if self.is_enabled(user):
|
|
return self.get_checkout_page_url(verified_mode.sku, course_run_keys=[course_run_key])
|
|
else:
|
|
return reverse('dashboard')
|
|
return None
|
|
|
|
|
|
def refund_entitlement(course_entitlement):
|
|
"""
|
|
Attempt a refund of a course entitlement. Verify the User before calling this refund method
|
|
|
|
Returns:
|
|
bool: True if the Refund is successfully processed.
|
|
"""
|
|
user_model = get_user_model()
|
|
enrollee = course_entitlement.user
|
|
entitlement_uuid = str(course_entitlement.uuid)
|
|
|
|
if not is_commerce_service_configured():
|
|
log.error(
|
|
'Ecommerce service is not configured, cannot refund for user [%s], course entitlement [%s].',
|
|
enrollee.id,
|
|
entitlement_uuid
|
|
)
|
|
return False
|
|
|
|
service_user = user_model.objects.get(username=settings.ECOMMERCE_SERVICE_WORKER_USERNAME)
|
|
api_client = get_ecommerce_api_client(service_user)
|
|
|
|
log.info(
|
|
'Attempting to create a refund for user [%s], course entitlement [%s]...',
|
|
enrollee.id,
|
|
entitlement_uuid
|
|
)
|
|
|
|
try:
|
|
refunds_url = urljoin(f"{get_ecommerce_api_base_url()}/", "refunds/")
|
|
refunds_response = api_client.post(
|
|
refunds_url,
|
|
data={
|
|
'order_number': course_entitlement.order_number,
|
|
'username': enrollee.username,
|
|
'entitlement_uuid': entitlement_uuid,
|
|
}
|
|
)
|
|
refunds_response.raise_for_status()
|
|
refund_ids = refunds_response.json()
|
|
except Exception as exc: # pylint: disable=broad-except
|
|
# Catch any possible exceptions from the Ecommerce service to ensure we fail gracefully
|
|
log.exception(
|
|
"Unexpected exception while attempting to initiate refund for user [%s], "
|
|
"course entitlement [%s] message: [%s]",
|
|
enrollee.id,
|
|
course_entitlement.uuid,
|
|
str(exc)
|
|
)
|
|
return False
|
|
|
|
if refund_ids:
|
|
log.info(
|
|
'Refund successfully opened for user [%s], course entitlement [%s]: %r',
|
|
enrollee.id,
|
|
entitlement_uuid,
|
|
refund_ids,
|
|
)
|
|
|
|
return _process_refund(
|
|
refund_ids=refund_ids,
|
|
api_client=api_client,
|
|
mode=course_entitlement.mode,
|
|
user=enrollee,
|
|
always_notify=True,
|
|
)
|
|
else:
|
|
log.warning('No refund opened for user [%s], course entitlement [%s]', enrollee.id, entitlement_uuid)
|
|
return False
|
|
|
|
|
|
@pluggable_override('OVERRIDE_REFUND_SEAT')
|
|
def refund_seat(course_enrollment, change_mode=False):
|
|
"""
|
|
Attempt to initiate a refund for any orders associated with the seat being unenrolled,
|
|
using the commerce service.
|
|
|
|
Arguments:
|
|
course_enrollment (CourseEnrollment): a student enrollment
|
|
change_mode (Boolean): change the course mode to free mode or not
|
|
|
|
Returns:
|
|
A list of the external service's IDs for any refunds that were initiated
|
|
(may be empty).
|
|
|
|
Raises:
|
|
requests.exceptions.RequestException: for any unhandled HTTP error during communication with
|
|
the E-Commerce Service.
|
|
requests.exceptions.Timeout: if the attempt to reach the commerce service timed out.
|
|
"""
|
|
User = get_user_model() # pylint:disable=invalid-name
|
|
course_key_str = str(course_enrollment.course_id)
|
|
enrollee = course_enrollment.user
|
|
|
|
service_user = User.objects.get(username=settings.ECOMMERCE_SERVICE_WORKER_USERNAME)
|
|
api_client = get_ecommerce_api_client(service_user)
|
|
|
|
log.info('Attempting to create a refund for user [%s], course [%s]...', enrollee.id, course_key_str)
|
|
|
|
refunds_url = urljoin(f"{get_ecommerce_api_base_url()}/", "refunds/")
|
|
refunds_response = api_client.post(
|
|
refunds_url,
|
|
data={'course_id': course_key_str, 'username': enrollee.username}
|
|
)
|
|
refunds_response.raise_for_status()
|
|
refund_ids = refunds_response.json() if refunds_response.content else None
|
|
|
|
if refund_ids:
|
|
log.info('Refund successfully opened for user [%s], course [%s]: %r', enrollee.id, course_key_str, refund_ids)
|
|
|
|
_process_refund(
|
|
refund_ids=refund_ids,
|
|
api_client=api_client,
|
|
mode=course_enrollment.mode,
|
|
user=enrollee,
|
|
)
|
|
if change_mode:
|
|
auto_enroll(course_enrollment)
|
|
else:
|
|
log.info('No refund opened for user [%s], course [%s]', enrollee.id, course_key_str)
|
|
|
|
return refund_ids
|
|
|
|
|
|
def auto_enroll(course_enrollment):
|
|
"""
|
|
Helper method to update an enrollment to a default course mode.
|
|
|
|
Arguments:
|
|
course_enrollment (CourseEnrollment): The course_enrollment to update.
|
|
|
|
Returns:
|
|
bool: True if auto-enroll is successful. False if auto-enroll is not applicable.
|
|
"""
|
|
enrollment_course_id = course_enrollment.course_id
|
|
|
|
if CourseMode.can_auto_enroll(course_id=enrollment_course_id):
|
|
auto_enroll_mode = CourseMode.auto_enroll_mode(course_id=enrollment_course_id)
|
|
course_enrollment.update_enrollment(mode=auto_enroll_mode, is_active=False, skip_refund=True)
|
|
course_enrollment.save()
|
|
log.info(
|
|
'Auto-enrolled user [%s], course [%s] in mode [%s].',
|
|
course_enrollment.user_id,
|
|
enrollment_course_id,
|
|
auto_enroll_mode
|
|
)
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
|
|
def _process_refund(refund_ids, api_client, mode, user, always_notify=False):
|
|
"""
|
|
Helper method to process a refund for a given course_product. This method assumes that the User has already
|
|
been unenrolled.
|
|
|
|
Arguments:
|
|
refund_ids: List of refund ids to be processed
|
|
api_client: The API Client used in the processing of refunds
|
|
mode: The mode that the refund should be processed for
|
|
user: The user that the refund is being processed for
|
|
always_notify (bool): This will enable always notifying support with Zendesk tickets when
|
|
an approval is required
|
|
|
|
Returns:
|
|
bool: True if the refund process was successful, False if there are any Errors that are not handled
|
|
"""
|
|
config = CommerceConfiguration.current()
|
|
|
|
if config.enable_automatic_refund_approval:
|
|
refunds_requiring_approval = []
|
|
|
|
for refund_id in refund_ids:
|
|
try:
|
|
# NOTE: The following assumes that the user has already been unenrolled.
|
|
# We are then able to approve payment. Additionally, this ensures we don't tie up an
|
|
# additional web worker when the E-Commerce Service tries to unenroll the learner.
|
|
base_url = get_ecommerce_api_base_url()
|
|
api_url = urljoin(f"{base_url}/", f"refunds/{refund_id}/process/")
|
|
response = api_client.put(api_url, json={'action': 'approve_payment_only'})
|
|
response.raise_for_status()
|
|
log.info('Refund [%d] successfully approved.', refund_id)
|
|
except: # pylint: disable=bare-except
|
|
# Push the refund to Support to process
|
|
log.exception('Failed to automatically approve refund [%d]!', refund_id)
|
|
refunds_requiring_approval.append(refund_id)
|
|
else:
|
|
refunds_requiring_approval = refund_ids
|
|
|
|
if refunds_requiring_approval:
|
|
# XCOM-371: this is a temporary measure to suppress refund-related email
|
|
# notifications to students and support for free enrollments. This
|
|
# condition should be removed when the CourseEnrollment.refundable() logic
|
|
# is updated to be more correct, or when we implement better handling (and
|
|
# notifications) in Otto for handling reversal of $0 transactions.
|
|
if mode != 'verified' and not always_notify:
|
|
# 'verified' is the only enrollment mode that should presently
|
|
# result in opening a refund request.
|
|
log.info(
|
|
'Skipping refund support notification for non-verified mode for user [%s], mode: [%s]',
|
|
user.id,
|
|
mode,
|
|
)
|
|
else:
|
|
try:
|
|
return _send_refund_notification(user, refunds_requiring_approval)
|
|
except: # pylint: disable=bare-except
|
|
# Unable to send notification to Support, do not break as this method is used by Signals
|
|
log.warning('Could not send support notification for refund.', exc_info=True)
|
|
return False
|
|
return True
|
|
|
|
|
|
def _send_refund_notification(user, refund_ids):
|
|
"""
|
|
Notify the support team of the refund request.
|
|
|
|
Returns:
|
|
bool: True if we are able to send the notification. In this case that means we were able to create
|
|
a ZenDesk ticket
|
|
"""
|
|
|
|
tags = ['auto_refund']
|
|
|
|
if theming_helpers.is_request_in_themed_site():
|
|
# this is not presently supported with the external service.
|
|
raise NotImplementedError("Unable to send refund processing emails to support teams.")
|
|
|
|
# Build the information for the ZenDesk ticket
|
|
student = user
|
|
subject = _("[Refund] User-Requested Refund")
|
|
body = _generate_refund_notification_body(student, refund_ids)
|
|
requester_name = student.profile.name or student.username
|
|
|
|
return create_zendesk_ticket(requester_name, student.email, subject, body, tags)
|
|
|
|
|
|
def _generate_refund_notification_body(student, refund_ids):
|
|
""" Returns a refund notification message body. """
|
|
msg = _(
|
|
'A refund request has been initiated for {username} ({email}). '
|
|
'To process this request, please visit the link(s) below.'
|
|
).format(username=student.username, email=student.email)
|
|
|
|
ecommerce_url_root = configuration_helpers.get_value(
|
|
'ECOMMERCE_PUBLIC_URL_ROOT', settings.ECOMMERCE_PUBLIC_URL_ROOT,
|
|
)
|
|
refund_urls = [urljoin(ecommerce_url_root, f'/dashboard/refunds/{refund_id}/')
|
|
for refund_id in refund_ids]
|
|
|
|
# emails contained in this message could contain unicode characters so encode as such
|
|
return '{msg}\n\n{urls}'.format(msg=msg, urls='\n'.join(refund_urls))
|
|
|
|
|
|
def create_zendesk_ticket(requester_name, requester_email, subject, body, tags=None):
|
|
"""
|
|
Create a Zendesk ticket via API.
|
|
|
|
Returns:
|
|
bool: False if we are unable to create the ticket for any reason
|
|
"""
|
|
if not (settings.ZENDESK_URL and settings.ZENDESK_USER and settings.ZENDESK_API_KEY):
|
|
log.error('Zendesk is not configured. Cannot create a ticket.')
|
|
return False
|
|
|
|
# Copy the tags to avoid modifying the original list.
|
|
tags = set(tags or [])
|
|
tags.add('LMS')
|
|
tags = list(tags)
|
|
|
|
data = {
|
|
'ticket': {
|
|
'requester': {
|
|
'name': requester_name,
|
|
'email': str(requester_email)
|
|
},
|
|
'subject': subject,
|
|
'comment': {'body': body},
|
|
'tags': tags
|
|
}
|
|
}
|
|
|
|
# Encode the data to create a JSON payload
|
|
payload = json.dumps(data)
|
|
|
|
# Set the request parameters
|
|
url = urljoin(settings.ZENDESK_URL, '/api/v2/tickets.json')
|
|
user = f'{settings.ZENDESK_USER}/token'
|
|
pwd = settings.ZENDESK_API_KEY
|
|
headers = {'content-type': 'application/json'}
|
|
|
|
try:
|
|
response = requests.post(url, data=payload, auth=(user, pwd), headers=headers)
|
|
|
|
# Check for HTTP codes other than 201 (Created)
|
|
if response.status_code != 201:
|
|
log.error('Failed to create ticket. Status: [%d], Body: [%s]', response.status_code, response.content)
|
|
return False
|
|
else:
|
|
log.debug('Successfully created ticket.')
|
|
except Exception: # pylint: disable=broad-except
|
|
log.exception('Failed to create ticket.')
|
|
return False
|
|
return True
|