Revert "emit enrollment event"

This reverts commit 5734cae1.

common/djangoapps/student/models.py

@@ -29,12 +29,6 @@ from django.forms import ModelForm, forms
 from course_modes.models import CourseMode
 import comment_client as cc
 from pytz import UTC
-import crum
-
-from track import contexts
-from track.views import server_track
-from eventtracking import tracker
-
 
 unenroll_done = django.dispatch.Signal(providing_args=["course_enrollment"])
 
@@ -673,11 +667,6 @@ class PendingEmailChange(models.Model):
     activation_key = models.CharField(('activation key'), max_length=32, unique=True, db_index=True)
 
 
-
-EVENT_NAME_ENROLLMENT_ACTIVATED = 'edx.course.enrollment.activated'
-EVENT_NAME_ENROLLMENT_DEACTIVATED = 'edx.course.enrollment.deactivated'
-
-
 class CourseEnrollment(models.Model):
     """
     Represents a Student's Enrollment record for a single Course. You should
@@ -748,55 +737,19 @@ class CourseEnrollment(models.Model):
         if user.id is None:
             user.save()
 
-        enrollment, created = CourseEnrollment.objects.get_or_create(
+        enrollment, _ = CourseEnrollment.objects.get_or_create(
             user=user,
             course_id=course_id,
         )
-
-        activation_changed = False
-        if enrollment.is_active != is_active:
-            enrollment.is_active = is_active
-            activation_changed = True
-
-        mode_changed = False
-        if enrollment.mode != mode:
+        # In case we're reactivating a deactivated enrollment, or changing the
+        # enrollment mode.
+        if enrollment.mode != mode or enrollment.is_active != is_active:
             enrollment.mode = mode
-            mode_changed = True
-
-        if activation_changed or mode_changed:
+            enrollment.is_active = is_active
             enrollment.save()
 
-        if created:
-            if is_active:
-                enrollment.emit_event(EVENT_NAME_ENROLLMENT_ACTIVATED)
-        else:
-            if activation_changed:
-                if is_active:
-                    enrollment.emit_event(EVENT_NAME_ENROLLMENT_ACTIVATED)
-                else:
-                    enrollment.emit_event(EVENT_NAME_ENROLLMENT_DEACTIVATED)
-
         return enrollment
 
-    def emit_event(self, event_name):
-        """
-        Emits an event to explicitly track course enrollment and unenrollment.
-        """
-
-        try:
-            context = contexts.course_context_from_course_id(self.course_id)
-            data = {
-                'user_id': self.user.id,
-                'course_id': self.course_id,
-                'mode': self.mode,
-            }
-
-            with tracker.get_tracker().context(event_name, context):
-                server_track(crum.get_current_request(), event_name, data)
-        except:  # pylint: disable=bare-except
-            if event_name and self.course_id:
-                log.exception('Unable to emit event %s for user %s and course %s', event_name, self.user.username, self.course_id)
-
     @classmethod
     def enroll(cls, user, course_id, mode="honor"):
         """
@@ -872,13 +825,9 @@ class CourseEnrollment(models.Model):
         """
         try:
             record = CourseEnrollment.objects.get(user=user, course_id=course_id)
-            if record.is_active:
-                record.is_active = False
-                record.save()
-
-                record.emit_event(EVENT_NAME_ENROLLMENT_DEACTIVATED)
-                unenroll_done.send(sender=cls, course_enrollment=record)
-
+            record.is_active = False
+            record.save()
+            unenroll_done.send(sender=cls, course_enrollment=record)
         except cls.DoesNotExist:
             err_msg = u"Tried to unenroll student {} from {} but they were not enrolled"
             log.error(err_msg.format(user, course_id))
@@ -969,7 +918,6 @@ class CourseEnrollment(models.Model):
         if not self.is_active:
             self.is_active = True
             self.save()
-            self.emit_event(EVENT_NAME_ENROLLMENT_ACTIVATED)
 
     def deactivate(self):
         """Makes this `CourseEnrollment` record inactive. Saves immediately. An
@@ -978,7 +926,6 @@ class CourseEnrollment(models.Model):
         if self.is_active:
             self.is_active = False
             self.save()
-            self.emit_event(EVENT_NAME_ENROLLMENT_DEACTIVATED)
 
     def refundable(self):
         """

common/djangoapps/student/tests/tests.py

@@ -25,7 +25,7 @@ from xmodule.modulestore.tests.factories import CourseFactory
 from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
 from courseware.tests.tests import TEST_DATA_MIXED_MODULESTORE
 
-from mock import Mock, patch, sentinel
+from mock import Mock, patch
 from textwrap import dedent
 
 from student.models import unique_id_for_user, CourseEnrollment
@@ -276,16 +276,6 @@ class DashboardTest(TestCase):
 class EnrollInCourseTest(TestCase):
     """Tests enrolling and unenrolling in courses."""
 
-    def setUp(self):
-        patcher = patch('student.models.server_track')
-        self.mock_server_track = patcher.start()
-        self.addCleanup(patcher.stop)
-
-        crum_patcher = patch('student.models.crum.get_current_request')
-        self.mock_get_current_request = crum_patcher.start()
-        self.addCleanup(crum_patcher.stop)
-        self.mock_get_current_request.return_value = sentinel.request
-
     def test_enrollment(self):
         user = User.objects.create_user("joe", "joe@joe.com", "password")
         course_id = "edX/Test101/2013"
@@ -299,28 +289,24 @@ class EnrollInCourseTest(TestCase):
         self.assertTrue(CourseEnrollment.is_enrolled(user, course_id))
         self.assertTrue(CourseEnrollment.is_enrolled_by_partial(user,
             course_id_partial))
-        self.assert_enrollment_event_was_emitted(user, course_id)
 
         # Enrolling them again should be harmless
         CourseEnrollment.enroll(user, course_id)
         self.assertTrue(CourseEnrollment.is_enrolled(user, course_id))
         self.assertTrue(CourseEnrollment.is_enrolled_by_partial(user,
             course_id_partial))
-        self.assert_no_events_were_emitted()
 
         # Now unenroll the user
         CourseEnrollment.unenroll(user, course_id)
         self.assertFalse(CourseEnrollment.is_enrolled(user, course_id))
         self.assertFalse(CourseEnrollment.is_enrolled_by_partial(user,
             course_id_partial))
-        self.assert_unenrollment_event_was_emitted(user, course_id)
 
         # Unenrolling them again should also be harmless
         CourseEnrollment.unenroll(user, course_id)
         self.assertFalse(CourseEnrollment.is_enrolled(user, course_id))
         self.assertFalse(CourseEnrollment.is_enrolled_by_partial(user,
             course_id_partial))
-        self.assert_no_events_were_emitted()
 
         # The enrollment record should still exist, just be inactive
         enrollment_record = CourseEnrollment.objects.get(
@@ -329,37 +315,6 @@ class EnrollInCourseTest(TestCase):
         )
         self.assertFalse(enrollment_record.is_active)
 
-    def assert_no_events_were_emitted(self):
-        """Ensures no events were emitted since the last event related assertion"""
-        self.assertFalse(self.mock_server_track.called)
-        self.mock_server_track.reset_mock()
-
-    def assert_enrollment_event_was_emitted(self, user, course_id):
-        """Ensures an enrollment event was emitted since the last event related assertion"""
-        self.mock_server_track.assert_called_once_with(
-            sentinel.request,
-            'edx.course.enrollment.activated',
-            {
-                'course_id': course_id,
-                'user_id': user.pk,
-                'mode': 'honor'
-            }
-        )
-        self.mock_server_track.reset_mock()
-
-    def assert_unenrollment_event_was_emitted(self, user, course_id):
-        """Ensures an unenrollment event was emitted since the last event related assertion"""
-        self.mock_server_track.assert_called_once_with(
-            sentinel.request,
-            'edx.course.enrollment.deactivated',
-            {
-                'course_id': course_id,
-                'user_id': user.pk,
-                'mode': 'honor'
-            }
-        )
-        self.mock_server_track.reset_mock()
-
     def test_enrollment_non_existent_user(self):
         # Testing enrollment of newly unsaved user (i.e. no database entry)
         user = User(username="rusty", email="rusty@fake.edx.org")
@@ -369,13 +324,11 @@ class EnrollInCourseTest(TestCase):
 
         # Unenroll does nothing
         CourseEnrollment.unenroll(user, course_id)
-        self.assert_no_events_were_emitted()
 
         # Implicit save() happens on new User object when enrolling, so this
         # should still work
         CourseEnrollment.enroll(user, course_id)
         self.assertTrue(CourseEnrollment.is_enrolled(user, course_id))
-        self.assert_enrollment_event_was_emitted(user, course_id)
 
     def test_enrollment_by_email(self):
         user = User.objects.create(username="jack", email="jack@fake.edx.org")
@@ -383,13 +336,11 @@ class EnrollInCourseTest(TestCase):
 
         CourseEnrollment.enroll_by_email("jack@fake.edx.org", course_id)
         self.assertTrue(CourseEnrollment.is_enrolled(user, course_id))
-        self.assert_enrollment_event_was_emitted(user, course_id)
 
         # This won't throw an exception, even though the user is not found
         self.assertIsNone(
             CourseEnrollment.enroll_by_email("not_jack@fake.edx.org", course_id)
         )
-        self.assert_no_events_were_emitted()
 
         self.assertRaises(
             User.DoesNotExist,
@@ -398,21 +349,17 @@ class EnrollInCourseTest(TestCase):
             course_id,
             ignore_errors=False
         )
-        self.assert_no_events_were_emitted()
 
         # Now unenroll them by email
         CourseEnrollment.unenroll_by_email("jack@fake.edx.org", course_id)
         self.assertFalse(CourseEnrollment.is_enrolled(user, course_id))
-        self.assert_unenrollment_event_was_emitted(user, course_id)
 
         # Harmless second unenroll
         CourseEnrollment.unenroll_by_email("jack@fake.edx.org", course_id)
         self.assertFalse(CourseEnrollment.is_enrolled(user, course_id))
-        self.assert_no_events_were_emitted()
 
         # Unenroll on non-existent user shouldn't throw an error
         CourseEnrollment.unenroll_by_email("not_jack@fake.edx.org", course_id)
-        self.assert_no_events_were_emitted()
 
     def test_enrollment_multiple_classes(self):
         user = User(username="rusty", email="rusty@fake.edx.org")
@@ -420,19 +367,15 @@ class EnrollInCourseTest(TestCase):
         course_id2 = "MITx/6.003z/2012"
 
         CourseEnrollment.enroll(user, course_id1)
-        self.assert_enrollment_event_was_emitted(user, course_id1)
         CourseEnrollment.enroll(user, course_id2)
-        self.assert_enrollment_event_was_emitted(user, course_id2)
         self.assertTrue(CourseEnrollment.is_enrolled(user, course_id1))
         self.assertTrue(CourseEnrollment.is_enrolled(user, course_id2))
 
         CourseEnrollment.unenroll(user, course_id1)
-        self.assert_unenrollment_event_was_emitted(user, course_id1)
         self.assertFalse(CourseEnrollment.is_enrolled(user, course_id1))
         self.assertTrue(CourseEnrollment.is_enrolled(user, course_id2))
 
         CourseEnrollment.unenroll(user, course_id2)
-        self.assert_unenrollment_event_was_emitted(user, course_id2)
         self.assertFalse(CourseEnrollment.is_enrolled(user, course_id1))
         self.assertFalse(CourseEnrollment.is_enrolled(user, course_id2))
 
@@ -445,33 +388,27 @@ class EnrollInCourseTest(TestCase):
         # (calling CourseEnrollment.enroll() would have)
         enrollment = CourseEnrollment.create_enrollment(user, course_id)
         self.assertFalse(CourseEnrollment.is_enrolled(user, course_id))
-        self.assert_no_events_were_emitted()
 
         # Until you explicitly activate it
         enrollment.activate()
         self.assertTrue(CourseEnrollment.is_enrolled(user, course_id))
-        self.assert_enrollment_event_was_emitted(user, course_id)
 
         # Activating something that's already active does nothing
         enrollment.activate()
         self.assertTrue(CourseEnrollment.is_enrolled(user, course_id))
-        self.assert_no_events_were_emitted()
 
         # Now deactive
         enrollment.deactivate()
         self.assertFalse(CourseEnrollment.is_enrolled(user, course_id))
-        self.assert_unenrollment_event_was_emitted(user, course_id)
 
         # Deactivating something that's already inactive does nothing
         enrollment.deactivate()
         self.assertFalse(CourseEnrollment.is_enrolled(user, course_id))
-        self.assert_no_events_were_emitted()
 
         # A deactivated enrollment should be activated if enroll() is called
         # for that user/course_id combination
         CourseEnrollment.enroll(user, course_id)
         self.assertTrue(CourseEnrollment.is_enrolled(user, course_id))
-        self.assert_enrollment_event_was_emitted(user, course_id)
 
 
 @override_settings(MODULESTORE=TEST_DATA_MIXED_MODULESTORE)

common/djangoapps/track/contexts.py

 """Generates common contexts"""
 
 import re
-import logging
 
-from xmodule.course_module import CourseDescriptor
 
-
-COURSE_REGEX = re.compile(r'^.*?/courses/(?P<course_id>[^/]+/[^/]+/[^/]+)')
-log = logging.getLogger(__name__)
+COURSE_REGEX = re.compile(r'^.*?/courses/(?P<course_id>(?P<org_id>[^/]+)/[^/]+/[^/]+)')
 
 
 def course_context_from_url(url):
     """
-    Extracts the course_id from the given `url` and passes it on to
-    `course_context_from_course_id()`.
-    """
-    url = url or ''
-
-    match = COURSE_REGEX.match(url)
-    course_id = ''
-    if match:
-        course_id = match.group('course_id') or ''
-
-    return course_context_from_course_id(course_id)
-
-
-def course_context_from_course_id(course_id):
-    """
-    Creates a course context from a `course_id`.
+    Extracts the course_id from the given `url.`
 
     Example Returned Context::
 
@@ -37,21 +18,14 @@ def course_context_from_course_id(course_id):
         }
 
     """
+    url = url or ''
 
-    course_id = course_id or ''
     context = {
-        'course_id': course_id,
+        'course_id': '',
         'org_id': ''
     }
-    try:
-        location = CourseDescriptor.id_to_location(course_id)
-        context['org_id'] = location.org
-    except ValueError:
-        log.warning(
-            'Unable to parse course_id "{course_id}"'.format(
-                course_id=course_id
-            ),
-            exc_info=True
-        )
+    match = COURSE_REGEX.match(url)
+    if match:
+        context.update(match.groupdict())
 
     return context

lms/djangoapps/courseware/features/certificates.feature

@@ -8,7 +8,6 @@ Feature: LMS.Verified certificates
         Given I am logged in
         When I select the audit track
         Then I should see the course on my dashboard
-        And a "edx.course.enrollment.activated" server event is emitted
 
     Scenario: I can submit photos to verify my identity
         Given I am logged in
@@ -37,7 +36,6 @@ Feature: LMS.Verified certificates
         Then I see the course on my dashboard
         And I see that I am on the verified track
         And I do not see the upsell link on my dashboard
-        And a "edx.course.enrollment.activated" server event is emitted
 
     # Not easily automated
 #    Scenario: I can re-take photos
@@ -73,7 +71,6 @@ Feature: LMS.Verified certificates
         And the course has an honor mode
         When I give a reason why I cannot pay
         Then I should see the course on my dashboard
-        And a "edx.course.enrollment.activated" server event is emitted
 
     Scenario: The upsell offer is on the dashboard if I am auditing.
         Given I am logged in
@@ -94,5 +91,4 @@ Feature: LMS.Verified certificates
         And I navigate to my dashboard
         Then I see the course on my dashboard
         And I see that I am on the verified track
-        And a "edx.course.enrollment.activated" server event is emitted
 

lms/djangoapps/courseware/features/registration.feature

@@ -10,7 +10,6 @@ Feature: LMS.Register for a course
     And I visit the courses page
     When I register for the course "6.002x"
     Then I should see the course numbered "6.002x" in my dashboard
-    And a "edx.course.enrollment.activated" server event is emitted
 
   Scenario: I can unregister for a course
     Given I am registered for the course "6.002x"
@@ -20,4 +19,3 @@ Feature: LMS.Register for a course
     Then I should be on the dashboard page
     And I should see an empty dashboard message
     And I should NOT see the course numbered "6.002x" in my dashboard
-    And a "edx.course.enrollment.deactivated" server event is emitted