Merge pull request #1827 from edx/db/remove-mitx-from-features

settings.MITX_FEATURES => settings.FEATURES

CHANGELOG.rst

@@ -5,6 +5,10 @@ These are notable changes in edx-platform.  This is a rolling list of changes,
 in roughly chronological order, most recent first.  Add your entries at or near
 the top.  Include a label indicating the component affected.
 
+Common: Switch over from MITX_FEATURES to just FEATURES. To override items in
+  the FEATURES dict, the environment variable you must set to do so is also
+  now called FEATURES instead of MITX_FEATURES.
+
 Blades: Fix Numerical input to support mathematical operations. BLD-525.
 
 Blades: Improve calculator's tooltip accessibility. Add possibility to navigate

cms/djangoapps/auth/authz.py

@@ -261,11 +261,11 @@ def is_user_in_creator_group(user):
         return True
 
     # On edx, we only allow edX staff to create courses. This may be relaxed in the future.
-    if settings.MITX_FEATURES.get('DISABLE_COURSE_CREATION', False):
+    if settings.FEATURES.get('DISABLE_COURSE_CREATION', False):
         return False
 
     # Feature flag for using the creator group setting. Will be removed once the feature is complete.
-    if settings.MITX_FEATURES.get('ENABLE_CREATOR_GROUP', False):
+    if settings.FEATURES.get('ENABLE_CREATOR_GROUP', False):
         return user.groups.filter(name=COURSE_CREATOR_GROUP_NAME).count() > 0
 
     return True

cms/djangoapps/auth/tests/test_authz.py

@@ -33,7 +33,7 @@ class CreatorGroupTest(TestCase):
 
     def test_creator_group_enabled_but_empty(self):
         """ Tests creator group feature on, but group empty. """
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {"ENABLE_CREATOR_GROUP": True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {"ENABLE_CREATOR_GROUP": True}):
             self.assertFalse(is_user_in_creator_group(self.user))
 
             # Make user staff. This will cause is_user_in_creator_group to return True.
@@ -42,7 +42,7 @@ class CreatorGroupTest(TestCase):
 
     def test_creator_group_enabled_nonempty(self):
         """ Tests creator group feature on, user added. """
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {"ENABLE_CREATOR_GROUP": True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {"ENABLE_CREATOR_GROUP": True}):
             self.assertTrue(add_user_to_creator_group(self.admin, self.user))
             self.assertTrue(is_user_in_creator_group(self.user))
 
@@ -70,7 +70,7 @@ class CreatorGroupTest(TestCase):
 
     def test_course_creation_disabled(self):
         """ Tests that the COURSE_CREATION_DISABLED flag overrides course creator group settings. """
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES',
+        with mock.patch.dict('django.conf.settings.FEATURES',
                              {'DISABLE_COURSE_CREATION': True, "ENABLE_CREATOR_GROUP": True}):
             # Add user to creator group.
             self.assertTrue(add_user_to_creator_group(self.admin, self.user))

cms/djangoapps/contentstore/tests/test_contentstore.py

@@ -1504,31 +1504,31 @@ class ContentStoreTest(ModuleStoreTestCase):
 
     def test_create_course_with_course_creation_disabled_staff(self):
         """Test new course creation -- course creation disabled, but staff access."""
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'DISABLE_COURSE_CREATION': True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'DISABLE_COURSE_CREATION': True}):
             self.assert_created_course()
 
     def test_create_course_with_course_creation_disabled_not_staff(self):
         """Test new course creation -- error path for course creation disabled, not staff access."""
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'DISABLE_COURSE_CREATION': True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'DISABLE_COURSE_CREATION': True}):
             self.user.is_staff = False
             self.user.save()
             self.assert_course_permission_denied()
 
     def test_create_course_no_course_creators_staff(self):
         """Test new course creation -- course creation group enabled, staff, group is empty."""
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_CREATOR_GROUP': True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'ENABLE_CREATOR_GROUP': True}):
             self.assert_created_course()
 
     def test_create_course_no_course_creators_not_staff(self):
         """Test new course creation -- error path for course creator group enabled, not staff, group is empty."""
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {"ENABLE_CREATOR_GROUP": True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {"ENABLE_CREATOR_GROUP": True}):
             self.user.is_staff = False
             self.user.save()
             self.assert_course_permission_denied()
 
     def test_create_course_with_course_creator(self):
         """Test new course creation -- use course creator group"""
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {"ENABLE_CREATOR_GROUP": True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {"ENABLE_CREATOR_GROUP": True}):
             add_user_to_creator_group(self.user, self.user)
             self.assert_created_course()
 

cms/djangoapps/contentstore/tests/test_course_settings.py

@@ -106,7 +106,7 @@ class CourseDetailsTestCase(CourseTestCase):
     def test_marketing_site_fetch(self):
         settings_details_url = self.course_locator.url_reverse('settings/details/')
 
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_MKTG_SITE': True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'ENABLE_MKTG_SITE': True}):
             response = self.client.get_html(settings_details_url)
             self.assertNotContains(response, "Course Summary Page")
             self.assertNotContains(response, "Send a note to students via email")
@@ -127,7 +127,7 @@ class CourseDetailsTestCase(CourseTestCase):
     def test_regular_site_fetch(self):
         settings_details_url = self.course_locator.url_reverse('settings/details/')
 
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_MKTG_SITE': False}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'ENABLE_MKTG_SITE': False}):
             response = self.client.get_html(settings_details_url)
             self.assertContains(response, "Course Summary Page")
             self.assertContains(response, "Send a note to students via email")

cms/djangoapps/contentstore/tests/test_request_event.py

@@ -20,7 +20,7 @@ class CMSLogTest(TestCase):
             {"event": "my_event", "event_type": "my_event_type", "page": "my_page"},
             {"event": "{'json': 'object'}", "event_type": unichr(512), "page": "my_page"}
         ]
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_SQL_TRACKING_LOGS': True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'ENABLE_SQL_TRACKING_LOGS': True}):
             for request_params in requests:
                 response = self.client.post(reverse(cms_user_track), request_params)
                 self.assertEqual(response.status_code, 204)
@@ -34,7 +34,7 @@ class CMSLogTest(TestCase):
             {"event": "my_event", "event_type": "my_event_type", "page": "my_page"},
             {"event": "{'json': 'object'}", "event_type": unichr(512), "page": "my_page"}
         ]
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_SQL_TRACKING_LOGS': True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'ENABLE_SQL_TRACKING_LOGS': True}):
             for request_params in requests:
                 response = self.client.get(reverse(cms_user_track), request_params)
                 self.assertEqual(response.status_code, 204)

cms/djangoapps/contentstore/tests/test_utils.py

@@ -28,33 +28,33 @@ class LMSLinksTestCase(TestCase):
     @override_settings(MKTG_URLS={'ROOT': 'dummy-root'})
     def about_page_marketing_site_test(self):
         """ Get URL for about page, marketing root present. """
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_MKTG_SITE': True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'ENABLE_MKTG_SITE': True}):
             self.assertEquals(self.get_about_page_link(), "//dummy-root/courses/mitX/101/test/about")
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_MKTG_SITE': False}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'ENABLE_MKTG_SITE': False}):
             self.assertEquals(self.get_about_page_link(), "//localhost:8000/courses/mitX/101/test/about")
 
     @override_settings(MKTG_URLS={'ROOT': 'http://www.dummy'})
     def about_page_marketing_site_remove_http_test(self):
         """ Get URL for about page, marketing root present, remove http://. """
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_MKTG_SITE': True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'ENABLE_MKTG_SITE': True}):
             self.assertEquals(self.get_about_page_link(), "//www.dummy/courses/mitX/101/test/about")
 
     @override_settings(MKTG_URLS={'ROOT': 'https://www.dummy'})
     def about_page_marketing_site_remove_https_test(self):
         """ Get URL for about page, marketing root present, remove https://. """
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_MKTG_SITE': True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'ENABLE_MKTG_SITE': True}):
             self.assertEquals(self.get_about_page_link(), "//www.dummy/courses/mitX/101/test/about")
 
     @override_settings(MKTG_URLS={'ROOT': 'www.dummyhttps://x'})
     def about_page_marketing_site_https__edge_test(self):
         """ Get URL for about page, only remove https:// at the beginning of the string. """
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_MKTG_SITE': True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'ENABLE_MKTG_SITE': True}):
             self.assertEquals(self.get_about_page_link(), "//www.dummyhttps://x/courses/mitX/101/test/about")
 
     @override_settings(MKTG_URLS={})
     def about_page_marketing_urls_not_set_test(self):
         """ Error case. ENABLE_MKTG_SITE is True, but there is either no MKTG_URLS, or no MKTG_URLS Root property. """
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_MKTG_SITE': True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'ENABLE_MKTG_SITE': True}):
             self.assertEquals(self.get_about_page_link(), None)
 
     @override_settings(LMS_BASE=None)

cms/djangoapps/contentstore/utils.py

@@ -136,7 +136,7 @@ def get_lms_link_for_item(location, preview=False, course_id=None):
 
     if settings.LMS_BASE is not None:
         if preview:
-            lms_base = settings.MITX_FEATURES.get('PREVIEW_LMS_BASE')
+            lms_base = settings.FEATURES.get('PREVIEW_LMS_BASE')
         else:
             lms_base = settings.LMS_BASE
 
@@ -155,7 +155,7 @@ def get_lms_link_for_about_page(location):
     """
     Returns the url to the course about page from the location tuple.
     """
-    if settings.MITX_FEATURES.get('ENABLE_MKTG_SITE', False):
+    if settings.FEATURES.get('ENABLE_MKTG_SITE', False):
         if not hasattr(settings, 'MKTG_URLS'):
             log.exception("ENABLE_MKTG_SITE is True, but MKTG_URLS is not defined.")
             about_base = None

cms/djangoapps/contentstore/views/component.py

@@ -252,7 +252,7 @@ def unit_handler(request, tag=None, course_id=None, branch=None, version_guid=No
                 break
             index = index + 1
 
-        preview_lms_base = settings.MITX_FEATURES.get('PREVIEW_LMS_BASE')
+        preview_lms_base = settings.FEATURES.get('PREVIEW_LMS_BASE')
 
         preview_lms_link = (
             '//{preview_lms_base}/courses/{org}/{course}/'

cms/djangoapps/contentstore/views/course.py

@@ -423,7 +423,7 @@ def settings_handler(request, tag=None, course_id=None, branch=None, version_gui
             'lms_link_for_about_page': utils.get_lms_link_for_about_page(course_old_location),
             'course_image_url': utils.course_image_url(course_module),
             'details_url': locator.url_reverse('/settings/details/'),
-            'about_page_editable': not settings.MITX_FEATURES.get(
+            'about_page_editable': not settings.FEATURES.get(
                 'ENABLE_MKTG_SITE', False
             ),
             'upload_asset_url': upload_asset_url
@@ -822,9 +822,9 @@ def _get_course_creator_status(user):
     """
     if user.is_staff:
         course_creator_status = 'granted'
-    elif settings.MITX_FEATURES.get('DISABLE_COURSE_CREATION', False):
+    elif settings.FEATURES.get('DISABLE_COURSE_CREATION', False):
         course_creator_status = 'disallowed_for_this_site'
-    elif settings.MITX_FEATURES.get('ENABLE_CREATOR_GROUP', False):
+    elif settings.FEATURES.get('ENABLE_CREATOR_GROUP', False):
         course_creator_status = get_course_creator_status(user)
         if course_creator_status is None:
             # User not grandfathered in as an existing user, has not previously visited the dashboard page.

cms/djangoapps/course_creators/admin.py

@@ -91,7 +91,7 @@ def send_user_notification_callback(sender, **kwargs):
     user = kwargs['user']
     updated_state = kwargs['state']
 
-    studio_request_email = settings.MITX_FEATURES.get('STUDIO_REQUEST_EMAIL', '')
+    studio_request_email = settings.FEATURES.get('STUDIO_REQUEST_EMAIL', '')
     context = {'studio_request_email': studio_request_email}
 
     subject = render_to_string('emails/course_creator_subject.txt', context)
@@ -118,7 +118,7 @@ def send_admin_notification_callback(sender, **kwargs):
     """
     user = kwargs['user']
 
-    studio_request_email = settings.MITX_FEATURES.get('STUDIO_REQUEST_EMAIL', '')
+    studio_request_email = settings.FEATURES.get('STUDIO_REQUEST_EMAIL', '')
     context = {'user_name': user.username, 'user_email': user.email}
 
     subject = render_to_string('emails/course_creator_admin_subject.txt', context)

cms/djangoapps/course_creators/tests/test_admin.py

@@ -69,7 +69,7 @@ class CourseCreatorAdminTest(TestCase):
                 self.studio_request_email
             )
 
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', self.enable_creator_group_patch):
+        with mock.patch.dict('django.conf.settings.FEATURES', self.enable_creator_group_patch):
 
             # User is initially unrequested.
             self.assertFalse(is_user_in_creator_group(self.user))
@@ -119,7 +119,7 @@ class CourseCreatorAdminTest(TestCase):
             else:
                 self.assertEquals(base_num_emails, len(mail.outbox))
 
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', self.enable_creator_group_patch):
+        with mock.patch.dict('django.conf.settings.FEATURES', self.enable_creator_group_patch):
             # E-mail message should be sent to admin only when new state is PENDING, regardless of what
             # previous state was (unless previous state was already PENDING).
             # E-mail message sent to user only on transition into and out of GRANTED state.
@@ -159,7 +159,7 @@ class CourseCreatorAdminTest(TestCase):
         self.assertFalse(self.creator_admin.has_change_permission(self.request))
 
     def test_rate_limit_login(self):
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_CREATOR_GROUP': True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'ENABLE_CREATOR_GROUP': True}):
             post_params = {'username': self.user.username, 'password': 'wrong_password'}
             # try logging in 30 times, the default limit in the number of failed
             # login attempts in one 5 minute period before the rate gets limited

cms/djangoapps/course_creators/tests/test_views.py

@@ -46,7 +46,7 @@ class CourseCreatorView(TestCase):
         self.assertEqual('unrequested', get_course_creator_status(self.user))
 
     def test_add_granted(self):
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {"ENABLE_CREATOR_GROUP": True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {"ENABLE_CREATOR_GROUP": True}):
             # Calling add_user_with_status_granted impacts is_user_in_course_group_role.
             self.assertFalse(is_user_in_creator_group(self.user))
 
@@ -60,7 +60,7 @@ class CourseCreatorView(TestCase):
             self.assertTrue(is_user_in_creator_group(self.user))
 
     def test_update_creator_group(self):
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {"ENABLE_CREATOR_GROUP": True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {"ENABLE_CREATOR_GROUP": True}):
             self.assertFalse(is_user_in_creator_group(self.user))
             update_course_creator_group(self.admin, self.user, True)
             self.assertTrue(is_user_in_creator_group(self.user))

cms/envs/acceptance.py

@@ -87,7 +87,7 @@ PIPELINE = True
 STATICFILES_FINDERS += ('pipeline.finders.PipelineFinder', )
 
 # Use the auto_auth workflow for creating users and logging them in
-MITX_FEATURES['AUTOMATIC_AUTH_FOR_TESTING'] = True
+FEATURES['AUTOMATIC_AUTH_FOR_TESTING'] = True
 
 # HACK
 # Setting this flag to false causes imports to not load correctly in the lettuce python files

cms/envs/aws.py

@@ -106,7 +106,7 @@ if STATIC_ROOT_BASE:
 EMAIL_BACKEND = ENV_TOKENS.get('EMAIL_BACKEND', EMAIL_BACKEND)
 EMAIL_FILE_PATH = ENV_TOKENS.get('EMAIL_FILE_PATH', None)
 LMS_BASE = ENV_TOKENS.get('LMS_BASE')
-# Note that MITX_FEATURES['PREVIEW_LMS_BASE'] gets read in from the environment file.
+# Note that FEATURES['PREVIEW_LMS_BASE'] gets read in from the environment file.
 
 SITE_NAME = ENV_TOKENS['SITE_NAME']
 
@@ -138,8 +138,9 @@ COURSES_WITH_UNSAFE_CODE = ENV_TOKENS.get("COURSES_WITH_UNSAFE_CODE", [])
 TIME_ZONE = ENV_TOKENS.get('TIME_ZONE', TIME_ZONE)
 
 
-for feature, value in ENV_TOKENS.get('MITX_FEATURES', {}).items():
-    MITX_FEATURES[feature] = value
+ENV_FEATURES = ENV_TOKENS.get('FEATURES', ENV_TOKENS.get('MITX_FEATURES', {}))
+for feature, value in ENV_FEATURES.items():
+    FEATURES[feature] = value
 
 LOGGING = get_logger_config(LOG_DIR,
                             logging_env=ENV_TOKENS['LOGGING_ENV'],
@@ -164,7 +165,7 @@ with open(CONFIG_ROOT / CONFIG_PREFIX + "auth.json") as auth_file:
 # Note that this is the Studio key. There is a separate key for the LMS.
 SEGMENT_IO_KEY = AUTH_TOKENS.get('SEGMENT_IO_KEY')
 if SEGMENT_IO_KEY:
-    MITX_FEATURES['SEGMENT_IO'] = ENV_TOKENS.get('SEGMENT_IO', False)
+    FEATURES['SEGMENT_IO'] = ENV_TOKENS.get('SEGMENT_IO', False)
 
 AWS_ACCESS_KEY_ID = AUTH_TOKENS["AWS_ACCESS_KEY_ID"]
 if AWS_ACCESS_KEY_ID == "":

cms/envs/common.py

@@ -2,7 +2,7 @@
 This is the common settings file, intended to set sane defaults. If you have a
 piece of configuration that's dependent on a set of feature flags being set,
 then create a function that returns the calculated value based on the value of
-MITX_FEATURES[...]. Modules that extend this one can change the feature
+FEATURES[...]. Modules that extend this one can change the feature
 configuration in an environment specific config file and re-calculate those
 values.
 
@@ -14,7 +14,7 @@ Longer TODO:
 1. Right now our treatment of static content in general and in particular
    course-specific static content is haphazard.
 2. We should have a more disciplined approach to feature flagging, even if it
-   just means that we stick them in a dict called MITX_FEATURES.
+   just means that we stick them in a dict called FEATURES.
 3. We need to handle configuration for multiple courses. This could be as
    multiple sites, but we do need a way to map their data assets.
 """
@@ -36,7 +36,7 @@ from dealer.git import git
 
 ############################ FEATURE CONFIGURATION #############################
 
-MITX_FEATURES = {
+FEATURES = {
     'USE_DJANGO_PIPELINE': True,
 
     'GITHUB_PUSH': False,

cms/envs/dev.py

@@ -76,7 +76,7 @@ DATABASES = {
 }
 
 LMS_BASE = "localhost:8000"
-MITX_FEATURES['PREVIEW_LMS_BASE'] = "localhost:8000"
+FEATURES['PREVIEW_LMS_BASE'] = "localhost:8000"
 
 REPOS = {
     'edx4edx': {
@@ -178,10 +178,10 @@ DEBUG_TOOLBAR_CONFIG = {
 DEBUG_TOOLBAR_MONGO_STACKTRACES = False
 
 # disable NPS survey in dev mode
-MITX_FEATURES['STUDIO_NPS_SURVEY'] = False
+FEATURES['STUDIO_NPS_SURVEY'] = False
 
 # Enable URL that shows information about the status of variuous services
-MITX_FEATURES['ENABLE_SERVICE_STATUS'] = True
+FEATURES['ENABLE_SERVICE_STATUS'] = True
 
 ############################# SEGMENT-IO ##################################
 
@@ -190,7 +190,7 @@ MITX_FEATURES['ENABLE_SERVICE_STATUS'] = True
 import os
 SEGMENT_IO_KEY = os.environ.get('SEGMENT_IO_KEY')
 if SEGMENT_IO_KEY:
-    MITX_FEATURES['SEGMENT_IO'] = True
+    FEATURES['SEGMENT_IO'] = True
 
 
 #####################################################################

cms/envs/dev_ike.py

@@ -9,8 +9,8 @@
 from .common import *
 from .dev import *
 
-MITX_FEATURES['AUTH_USE_MIT_CERTIFICATES'] = True
+FEATURES['AUTH_USE_MIT_CERTIFICATES'] = True
 
-MITX_FEATURES['USE_DJANGO_PIPELINE'] = False      # don't recompile scss
+FEATURES['USE_DJANGO_PIPELINE'] = False      # don't recompile scss
 
 SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTOCOL', 'https')  	# django 1.4 for nginx ssl proxy

cms/envs/dev_shared_preview.py

@@ -9,4 +9,4 @@ the same process between preview and published
 
 from .dev import *
 
-MITX_FEATURES['PREVIEW_LMS_BASE'] = "preview.localhost:8000"
+FEATURES['PREVIEW_LMS_BASE'] = "preview.localhost:8000"

cms/envs/devstack.py

@@ -24,7 +24,7 @@ EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
 ################################# LMS INTEGRATION #############################
 
 LMS_BASE = "localhost:8000"
-MITX_FEATURES['PREVIEW_LMS_BASE'] = "preview." + LMS_BASE
+FEATURES['PREVIEW_LMS_BASE'] = "preview." + LMS_BASE
 
 ################################# CELERY ######################################
 

cms/envs/test.py

@@ -109,7 +109,7 @@ DATABASES = {
 }
 
 LMS_BASE = "localhost:8000"
-MITX_FEATURES['PREVIEW_LMS_BASE'] = "preview"
+FEATURES['PREVIEW_LMS_BASE'] = "preview"
 
 CACHES = {
     # This is the cache used for most things. Askbot will not work without a
@@ -161,9 +161,9 @@ PASSWORD_HASHERS = (
 SEGMENT_IO_KEY = '***REMOVED***'
 
 # disable NPS survey in test mode
-MITX_FEATURES['STUDIO_NPS_SURVEY'] = False
+FEATURES['STUDIO_NPS_SURVEY'] = False
 
-MITX_FEATURES['ENABLE_SERVICE_STATUS'] = True
+FEATURES['ENABLE_SERVICE_STATUS'] = True
 
 # This is to disable a test under the common directory that will not pass when run under CMS
-MITX_FEATURES['DISABLE_PASSWORD_RESET_EMAIL_TEST'] = True
+FEATURES['DISABLE_PASSWORD_RESET_EMAIL_TEST'] = True

cms/templates/index.html

@@ -45,8 +45,8 @@ require(["domReady!", "jquery", "jquery.form", "js/index"], function(doc, $) {
           % if course_creator_status=='granted':
           <a href="#" class="button new-button new-course-button"><i class="icon-plus icon-inline"></i>
               ${_("New Course")}</a>
-          % elif course_creator_status=='disallowed_for_this_site' and settings.MITX_FEATURES.get('STUDIO_REQUEST_EMAIL',''):
-          <a href="mailto:${settings.MITX_FEATURES.get('STUDIO_REQUEST_EMAIL','')}">${_("Email staff to create course")}</a>
+          % elif course_creator_status=='disallowed_for_this_site' and settings.FEATURES.get('STUDIO_REQUEST_EMAIL',''):
+          <a href="mailto:${settings.FEATURES.get('STUDIO_REQUEST_EMAIL','')}">${_("Email staff to create course")}</a>
           % endif
         </li>
       </ul>
@@ -290,10 +290,10 @@ require(["domReady!", "jquery", "jquery.form", "js/index"], function(doc, $) {
         </ol>
       </div>
 
-      % if course_creator_status=='disallowed_for_this_site' and settings.MITX_FEATURES.get('STUDIO_REQUEST_EMAIL',''):
+      % if course_creator_status=='disallowed_for_this_site' and settings.FEATURES.get('STUDIO_REQUEST_EMAIL',''):
       <div class="bit">
         <h3 class="title title-3">${_('Can I create courses in Studio?')}</h3>
-        <p>${_('In order to create courses in Studio, you must')} <a href="mailto:${settings.MITX_FEATURES.get('STUDIO_REQUEST_EMAIL','')}">${_("contact edX staff to help you create a course")}</a></p>
+        <p>${_('In order to create courses in Studio, you must')} <a href="mailto:${settings.FEATURES.get('STUDIO_REQUEST_EMAIL','')}">${_("contact edX staff to help you create a course")}</a></p>
       </div>
       % endif
 

cms/templates/widgets/qualaroo.html

-% if settings.MITX_FEATURES.get('STUDIO_NPS_SURVEY'):
+% if settings.FEATURES.get('STUDIO_NPS_SURVEY'):
     <!-- Qualaroo is used for net promoter score surveys -->
     <script type="text/javascript">
         % if user.is_authenticated():

cms/templates/widgets/segment-io.html

@@ -9,7 +9,7 @@ from xmodule.modulestore.django import loc_mapper
 %>
 % endif
 
-% if settings.MITX_FEATURES.get('SEGMENT_IO'):
+% if settings.FEATURES.get('SEGMENT_IO'):
 <!-- begin Segment.io -->
 <script type="text/javascript">
   // if inside course, inject the course location into the JS namespace

cms/urls.py

@@ -101,7 +101,7 @@ urlpatterns += patterns('',
     url(r'^i18n.js$', 'django.views.i18n.javascript_catalog', js_info_dict),
 )
 
-if settings.MITX_FEATURES.get('ENABLE_SERVICE_STATUS'):
+if settings.FEATURES.get('ENABLE_SERVICE_STATUS'):
     urlpatterns += patterns('',
         url(r'^status/', include('service_status.urls')),
     )
@@ -109,7 +109,7 @@ if settings.MITX_FEATURES.get('ENABLE_SERVICE_STATUS'):
 urlpatterns += patterns('', url(r'^admin/', include(admin.site.urls)),)
 
 # enable automatic login
-if settings.MITX_FEATURES.get('AUTOMATIC_AUTH_FOR_TESTING'):
+if settings.FEATURES.get('AUTOMATIC_AUTH_FOR_TESTING'):
     urlpatterns += (
         url(r'^auto_auth$', 'student.views.auto_auth'),
     )

common/djangoapps/edxmako/shortcuts.py

@@ -35,13 +35,13 @@ def marketing_link(name):
     # link_map maps URLs from the marketing site to the old equivalent on
     # the Django site
     link_map = settings.MKTG_URL_LINK_MAP
-    if settings.MITX_FEATURES.get('ENABLE_MKTG_SITE') and name in settings.MKTG_URLS:
+    if settings.FEATURES.get('ENABLE_MKTG_SITE') and name in settings.MKTG_URLS:
         # special case for when we only want the root marketing URL
         if name == 'ROOT':
             return settings.MKTG_URLS.get('ROOT')
         return settings.MKTG_URLS.get('ROOT') + settings.MKTG_URLS.get(name)
     # only link to the old pages when the marketing site isn't on
-    elif not settings.MITX_FEATURES.get('ENABLE_MKTG_SITE') and name in link_map:
+    elif not settings.FEATURES.get('ENABLE_MKTG_SITE') and name in link_map:
         # don't try to reverse disabled marketing links
         if link_map[name] is not None:
             return reverse(link_map[name])

common/djangoapps/edxmako/tests.py

@@ -14,12 +14,12 @@ class ShortcutsTests(UrlResetMixin, TestCase):
     @override_settings(MKTG_URL_LINK_MAP={'ABOUT': 'login'})
     def test_marketing_link(self):
         # test marketing site on
-        with patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_MKTG_SITE': True}):
+        with patch.dict('django.conf.settings.FEATURES', {'ENABLE_MKTG_SITE': True}):
             expected_link = 'dummy-root/about-us'
             link = marketing_link('ABOUT')
             self.assertEquals(link, expected_link)
         # test marketing site off
-        with patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_MKTG_SITE': False}):
+        with patch.dict('django.conf.settings.FEATURES', {'ENABLE_MKTG_SITE': False}):
             # we are using login because it is common across both cms and lms
             expected_link = reverse('login')
             link = marketing_link('ABOUT')

common/djangoapps/external_auth/tests/test_openid_provider.py

@@ -72,8 +72,8 @@ class OpenIdProviderTest(TestCase):
     Tests of the OpenId login
     """
 
-    @skipUnless(settings.MITX_FEATURES.get('AUTH_USE_OPENID') or
-                settings.MITX_FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
+    @skipUnless(settings.FEATURES.get('AUTH_USE_OPENID') or
+                settings.FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
     def test_begin_login_with_xrds_url(self):
 
         # the provider URL must be converted to an absolute URL in order to be
@@ -100,8 +100,8 @@ class OpenIdProviderTest(TestCase):
                              "got code {0} for url '{1}'. Expected code {2}"
                              .format(resp.status_code, url, code))
 
-    @skipUnless(settings.MITX_FEATURES.get('AUTH_USE_OPENID') or
-                settings.MITX_FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
+    @skipUnless(settings.FEATURES.get('AUTH_USE_OPENID') or
+                settings.FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
     def test_begin_login_with_login_url(self):
 
         # the provider URL must be converted to an absolute URL in order to be
@@ -183,21 +183,21 @@ class OpenIdProviderTest(TestCase):
                          "got code {0} for url '{1}'. Expected code {2}"
                          .format(resp.status_code, url, code))
 
-    @skipUnless(settings.MITX_FEATURES.get('AUTH_USE_OPENID') or
-                settings.MITX_FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
+    @skipUnless(settings.FEATURES.get('AUTH_USE_OPENID') or
+                settings.FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
     def test_open_id_setup(self):
         """ Attempt a standard successful login """
         self.attempt_login(200)
 
-    @skipUnless(settings.MITX_FEATURES.get('AUTH_USE_OPENID') or
-                settings.MITX_FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
+    @skipUnless(settings.FEATURES.get('AUTH_USE_OPENID') or
+                settings.FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
     def test_invalid_namespace(self):
         """ Test for 403 error code when the namespace of the request is invalid"""
         self.attempt_login(403, ns="http%3A%2F%2Fspecs.openid.net%2Fauth%2F2.0")
 
     @override_settings(OPENID_PROVIDER_TRUSTED_ROOTS=['http://apps.cs50.edx.org'])
-    @skipUnless(settings.MITX_FEATURES.get('AUTH_USE_OPENID') or
-                settings.MITX_FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
+    @skipUnless(settings.FEATURES.get('AUTH_USE_OPENID') or
+                settings.FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
     def test_invalid_return_url(self):
         """ Test for 403 error code when the url"""
         self.attempt_login(403, return_to="http://apps.cs50.edx.or")
@@ -224,15 +224,15 @@ class OpenIdProviderTest(TestCase):
         response = provider_login(request)
         return response
 
-    @skipUnless(settings.MITX_FEATURES.get('AUTH_USE_OPENID') or
-                settings.MITX_FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
+    @skipUnless(settings.FEATURES.get('AUTH_USE_OPENID') or
+                settings.FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
     def test_login_openid_handle_redirection(self):
         """ Test to see that we can handle login redirection properly"""
         response = self._send_bad_redirection_login()
         self.assertEquals(response.status_code, 302)
 
-    @skipUnless(settings.MITX_FEATURES.get('AUTH_USE_OPENID') or
-                settings.MITX_FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
+    @skipUnless(settings.FEATURES.get('AUTH_USE_OPENID') or
+                settings.FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
     def test_login_openid_handle_redirection_ratelimited(self):
         # try logging in 30 times, the default limit in the number of failed
         # log in attempts before the rate gets limited
@@ -254,8 +254,8 @@ class OpenIdProviderLiveServerTest(LiveServerTestCase):
     Here we do the former.
     """
 
-    @skipUnless(settings.MITX_FEATURES.get('AUTH_USE_OPENID') or
-                settings.MITX_FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
+    @skipUnless(settings.FEATURES.get('AUTH_USE_OPENID') or
+                settings.FEATURES.get('AUTH_USE_OPENID_PROVIDER'), True)
     def test_begin_login(self):
         # the provider URL must be converted to an absolute URL in order to be
         # used as an openid provider.

common/djangoapps/external_auth/tests/test_shib.py

@@ -81,7 +81,7 @@ class ShibSPTest(ModuleStoreTestCase):
     def setUp(self):
         self.store = editable_modulestore()
 
-    @unittest.skipUnless(settings.MITX_FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
+    @unittest.skipUnless(settings.FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
     def test_exception_shib_login(self):
         """
         Tests that we get the error page when there is no REMOTE_USER
@@ -107,7 +107,7 @@ class ShibSPTest(ModuleStoreTestCase):
         self.assertIn(u'logged in via Shibboleth', args[0])
         self.assertEquals(remote_user, args[1])
 
-    @unittest.skipUnless(settings.MITX_FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
+    @unittest.skipUnless(settings.FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
     def test_shib_login(self):
         """
         Tests that:
@@ -207,7 +207,7 @@ class ShibSPTest(ModuleStoreTestCase):
                     # no audit logging calls
                     self.assertEquals(len(audit_log_calls), 0)
 
-    @unittest.skipUnless(settings.MITX_FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
+    @unittest.skipUnless(settings.FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
     def test_registration_form(self):
         """
         Tests the registration form showing up with the proper parameters.
@@ -237,7 +237,7 @@ class ShibSPTest(ModuleStoreTestCase):
             # clean up b/c we don't want existing ExternalAuthMap for the next run
             client.session['ExternalAuthMap'].delete()
 
-    @unittest.skipUnless(settings.MITX_FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
+    @unittest.skipUnless(settings.FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
     def test_registration_form_submit(self):
         """
         Tests user creation after the registration form that pops is submitted.  If there is no shib
@@ -319,7 +319,7 @@ class ShibSPTest(ModuleStoreTestCase):
             Registration.objects.filter(user=user).delete()
             user.delete()
 
-    @unittest.skipUnless(settings.MITX_FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
+    @unittest.skipUnless(settings.FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
     def test_course_specific_login_and_reg(self):
         """
         Tests that the correct course specific login and registration urls work for shib
@@ -391,7 +391,7 @@ class ShibSPTest(ModuleStoreTestCase):
                              '?course_id=DNE/DNE/DNE' +
                              '&enrollment_action=enroll')
 
-    @unittest.skipUnless(settings.MITX_FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
+    @unittest.skipUnless(settings.FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
     def test_enrollment_limit_by_domain(self):
         """
             Tests that the enrollmentDomain setting is properly limiting enrollment to those who have
@@ -455,7 +455,7 @@ class ShibSPTest(ModuleStoreTestCase):
                     self.assertEqual(response.status_code, 400)
                     self.assertFalse(CourseEnrollment.is_enrolled(student, course.id))
 
-    @unittest.skipUnless(settings.MITX_FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
+    @unittest.skipUnless(settings.FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
     def test_shib_login_enrollment(self):
         """
             A functionality test that a student with an existing shib login

common/djangoapps/external_auth/tests/test_ssl.py

@@ -17,13 +17,13 @@ from django.test.utils import override_settings
 from external_auth.models import ExternalAuthMap
 import external_auth.views
 
-MITX_FEATURES_WITH_SSL_AUTH = settings.MITX_FEATURES.copy()
-MITX_FEATURES_WITH_SSL_AUTH['AUTH_USE_MIT_CERTIFICATES'] = True
-MITX_FEATURES_WITH_SSL_AUTH_IMMEDIATE_SIGNUP = MITX_FEATURES_WITH_SSL_AUTH.copy()
-MITX_FEATURES_WITH_SSL_AUTH_IMMEDIATE_SIGNUP['AUTH_USE_MIT_CERTIFICATES_IMMEDIATE_SIGNUP'] = True
+FEATURES_WITH_SSL_AUTH = settings.FEATURES.copy()
+FEATURES_WITH_SSL_AUTH['AUTH_USE_MIT_CERTIFICATES'] = True
+FEATURES_WITH_SSL_AUTH_IMMEDIATE_SIGNUP = FEATURES_WITH_SSL_AUTH.copy()
+FEATURES_WITH_SSL_AUTH_IMMEDIATE_SIGNUP['AUTH_USE_MIT_CERTIFICATES_IMMEDIATE_SIGNUP'] = True
 
 
-@override_settings(MITX_FEATURES=MITX_FEATURES_WITH_SSL_AUTH)
+@override_settings(FEATURES=FEATURES_WITH_SSL_AUTH)
 class SSLClientTest(TestCase):
     """
     Tests SSL Authentication code sections of external_auth
@@ -94,7 +94,7 @@ class SSLClientTest(TestCase):
             User.objects.get(email=self.USER_EMAIL)
 
     @unittest.skipUnless(settings.ROOT_URLCONF == 'lms.urls', 'Test only valid in lms')
-    @override_settings(MITX_FEATURES=MITX_FEATURES_WITH_SSL_AUTH_IMMEDIATE_SIGNUP)
+    @override_settings(FEATURES=FEATURES_WITH_SSL_AUTH_IMMEDIATE_SIGNUP)
     def test_ssl_login_without_signup_lms(self):
         """
         Test IMMEDIATE_SIGNUP feature flag and ensure the user account is automatically created
@@ -114,7 +114,7 @@ class SSLClientTest(TestCase):
             self.fail('User did not get properly added to internal users, exception was {0}'.format(str(ex)))
 
     @unittest.skipUnless(settings.ROOT_URLCONF == 'cms.urls', 'Test only valid in cms')
-    @override_settings(MITX_FEATURES=MITX_FEATURES_WITH_SSL_AUTH_IMMEDIATE_SIGNUP)
+    @override_settings(FEATURES=FEATURES_WITH_SSL_AUTH_IMMEDIATE_SIGNUP)
     @unittest.skip
     def test_ssl_login_without_signup_cms(self):
         """

common/djangoapps/external_auth/views.py

@@ -18,7 +18,7 @@ from django.core.urlresolvers import reverse
 from django.core.validators import validate_email
 from django.core.exceptions import ValidationError
 
-if settings.MITX_FEATURES.get('AUTH_USE_CAS'):
+if settings.FEATURES.get('AUTH_USE_CAS'):
     from django_cas.views import login as django_cas_login
 
 from student.models import UserProfile
@@ -150,7 +150,7 @@ def _external_login_or_signup(request,
         eamap.save()
 
     log.info(u"External_Auth login_or_signup for %s : %s : %s : %s", external_domain, external_id, email, fullname)
-    uses_shibboleth = settings.MITX_FEATURES.get('AUTH_USE_SHIB') and external_domain.startswith(SHIBBOLETH_DOMAIN_PREFIX)
+    uses_shibboleth = settings.FEATURES.get('AUTH_USE_SHIB') and external_domain.startswith(SHIBBOLETH_DOMAIN_PREFIX)
     internal_user = eamap.user
     if internal_user is None:
         if uses_shibboleth:
@@ -250,7 +250,7 @@ def _signup(request, eamap):
     # save this for use by student.views.create_account
     request.session['ExternalAuthMap'] = eamap
 
-    if settings.MITX_FEATURES.get('AUTH_USE_MIT_CERTIFICATES_IMMEDIATE_SIGNUP', ''):
+    if settings.FEATURES.get('AUTH_USE_MIT_CERTIFICATES_IMMEDIATE_SIGNUP', ''):
         # do signin immediately, by calling create_account, instead of asking
         # student to fill in form.  MIT students already have information filed.
         username = eamap.external_email.split('@', 1)[0]
@@ -278,9 +278,9 @@ def _signup(request, eamap):
 
     # Some openEdX instances can't have terms of service for shib users, like
     # according to Stanford's Office of General Counsel
-    uses_shibboleth = (settings.MITX_FEATURES.get('AUTH_USE_SHIB') and
+    uses_shibboleth = (settings.FEATURES.get('AUTH_USE_SHIB') and
                        eamap.external_domain.startswith(SHIBBOLETH_DOMAIN_PREFIX))
-    if uses_shibboleth and settings.MITX_FEATURES.get('SHIB_DISABLE_TOS'):
+    if uses_shibboleth and settings.FEATURES.get('SHIB_DISABLE_TOS'):
         context['ask_for_tos'] = False
 
     # detect if full name is blank and ask for it from user
@@ -349,7 +349,7 @@ def ssl_login_shortcut(fn):
     based on existing ExternalAuth record and MIT ssl certificate.
     """
     def wrapped(*args, **kwargs):
-        if not settings.MITX_FEATURES['AUTH_USE_MIT_CERTIFICATES']:
+        if not settings.FEATURES['AUTH_USE_MIT_CERTIFICATES']:
             return fn(*args, **kwargs)
         request = args[0]
         cert = _ssl_get_cert_from_request(request)
@@ -372,7 +372,7 @@ def ssl_login_shortcut(fn):
 def ssl_login(request):
     """
     This is called by branding.views.index when
-    MITX_FEATURES['AUTH_USE_MIT_CERTIFICATES'] = True
+    FEATURES['AUTH_USE_MIT_CERTIFICATES'] = True
 
     Used for MIT user authentication.  This presumes the web server
     (nginx) has been configured to require specific client
@@ -386,7 +386,7 @@ def ssl_login(request):
     Else continues on with student.views.index, and no authentication.
     """
     # Just to make sure we're calling this only at MIT:
-    if not settings.MITX_FEATURES['AUTH_USE_MIT_CERTIFICATES']:
+    if not settings.FEATURES['AUTH_USE_MIT_CERTIFICATES']:
         return HttpResponseForbidden()
 
     cert = _ssl_get_cert_from_request(request)
@@ -540,7 +540,7 @@ def course_specific_login(request, course_id):
         return _redirect_with_get_querydict('signin_user', request.GET)
 
     # now the dispatching conditionals.  Only shib for now
-    if settings.MITX_FEATURES.get('AUTH_USE_SHIB') and course.enrollment_domain.startswith(SHIBBOLETH_DOMAIN_PREFIX):
+    if settings.FEATURES.get('AUTH_USE_SHIB') and course.enrollment_domain.startswith(SHIBBOLETH_DOMAIN_PREFIX):
         return _redirect_with_get_querydict('shib-login', request.GET)
 
     # Default fallthrough to normal signin page
@@ -559,7 +559,7 @@ def course_specific_register(request, course_id):
         return _redirect_with_get_querydict('register_user', request.GET)
 
     # now the dispatching conditionals.  Only shib for now
-    if settings.MITX_FEATURES.get('AUTH_USE_SHIB') and course.enrollment_domain.startswith(SHIBBOLETH_DOMAIN_PREFIX):
+    if settings.FEATURES.get('AUTH_USE_SHIB') and course.enrollment_domain.startswith(SHIBBOLETH_DOMAIN_PREFIX):
         # shib-login takes care of both registration and login flows
         return _redirect_with_get_querydict('shib-login', request.GET)
 

common/djangoapps/pipeline_mako/templates/static_content.html

@@ -11,7 +11,7 @@ except:
 %>${url}</%def>
 
 <%def name='css(group)'>
-  % if settings.MITX_FEATURES['USE_DJANGO_PIPELINE']:
+  % if settings.FEATURES['USE_DJANGO_PIPELINE']:
     ${compressed_css(group)}
   % else:
     % for filename in settings.PIPELINE_CSS[group]['source_filenames']:
@@ -20,7 +20,7 @@ except:
   %endif
 </%def>
 <%def name='js(group)'>
-  % if settings.MITX_FEATURES['USE_DJANGO_PIPELINE']:
+  % if settings.FEATURES['USE_DJANGO_PIPELINE']:
     ${compressed_js(group)}
   % else:
     % for filename in settings.PIPELINE_JS[group]['source_filenames']:

common/djangoapps/student/models.py

@@ -695,7 +695,7 @@ def add_user_to_default_group(user, group):
 
 @receiver(post_save, sender=User)
 def update_user_information(sender, instance, created, **kwargs):
-    if not settings.MITX_FEATURES['ENABLE_DISCUSSION_SERVICE']:
+    if not settings.FEATURES['ENABLE_DISCUSSION_SERVICE']:
         # Don't try--it won't work, and it will fill the logs with lots of errors
         return
     try:

common/djangoapps/student/tests/test_auto_auth.py

@@ -11,9 +11,9 @@ class AutoAuthEnabledTestCase(UrlResetMixin, TestCase):
     Tests for the Auto auth view that we have for load testing.
     """
 
-    @patch.dict("django.conf.settings.MITX_FEATURES", {"AUTOMATIC_AUTH_FOR_TESTING": True})
+    @patch.dict("django.conf.settings.FEATURES", {"AUTOMATIC_AUTH_FOR_TESTING": True})
     def setUp(self):
-        # Patching the settings.MITX_FEATURES['AUTOMATIC_AUTH_FOR_TESTING']
+        # Patching the settings.FEATURES['AUTOMATIC_AUTH_FOR_TESTING']
         # value affects the contents of urls.py,
         # so we need to call super.setUp() which reloads urls.py (because
         # of the UrlResetMixin)
@@ -78,7 +78,7 @@ class AutoAuthEnabledTestCase(UrlResetMixin, TestCase):
         self.assertEqual(user1.email, 'USER_1_dummy_test@mitx.mit.edu')
         self.assertEqual(qset[1].username, 'USER_2')
 
-    @patch.dict("django.conf.settings.MITX_FEATURES", {"MAX_AUTO_AUTH_USERS": 1})
+    @patch.dict("django.conf.settings.FEATURES", {"MAX_AUTO_AUTH_USERS": 1})
     def test_login_already_created_user(self):
         """
         Test that when we have reached the limit for automatic users
@@ -102,9 +102,9 @@ class AutoAuthDisabledTestCase(UrlResetMixin, TestCase):
     Test that the page is inaccessible with default settings
     """
 
-    @patch.dict("django.conf.settings.MITX_FEATURES", {"AUTOMATIC_AUTH_FOR_TESTING": False})
+    @patch.dict("django.conf.settings.FEATURES", {"AUTOMATIC_AUTH_FOR_TESTING": False})
     def setUp(self):
-        # Patching the settings.MITX_FEATURES['AUTOMATIC_AUTH_FOR_TESTING']
+        # Patching the settings.FEATURES['AUTOMATIC_AUTH_FOR_TESTING']
         # value affects the contents of urls.py,
         # so we need to call super.setUp() which reloads urls.py (because
         # of the UrlResetMixin)

common/djangoapps/student/tests/test_bulk_email_settings.py

@@ -56,19 +56,19 @@ class TestStudentDashboardEmailView(ModuleStoreTestCase):
         """
         patch.stopall()
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
     def test_email_flag_true(self):
         # Assert that the URL for the email view is in the response
         response = self.client.get(self.url)
         self.assertTrue(self.email_modal_link in response.content)
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False})
     def test_email_flag_false(self):
         # Assert that the URL for the email view is not in the response
         response = self.client.get(self.url)
         self.assertFalse(self.email_modal_link in response.content)
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
     def test_email_unauthorized(self):
         # Assert that instructor email is not enabled for this course
         self.assertFalse(CourseAuthorization.instructor_email_enabled(self.course.id))
@@ -77,7 +77,7 @@ class TestStudentDashboardEmailView(ModuleStoreTestCase):
         response = self.client.get(self.url)
         self.assertFalse(self.email_modal_link in response.content)
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
     def test_email_authorized(self):
         # Authorize the course to use email
         cauth = CourseAuthorization(course_id=self.course.id, email_enabled=True)
@@ -120,14 +120,14 @@ class TestStudentDashboardEmailViewXMLBacked(ModuleStoreTestCase):
              )
         )
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
     def test_email_flag_true_xml_store(self):
         # The flag is enabled, and since REQUIRE_COURSE_EMAIL_AUTH is False, all courses should
         # be authorized to use email. But the course is not Mongo-backed (should not work)
         response = self.client.get(self.url)
         self.assertFalse(self.email_modal_link in response.content)
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False, 'REQUIRE_COURSE_EMAIL_AUTH': False})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False, 'REQUIRE_COURSE_EMAIL_AUTH': False})
     def test_email_flag_false_xml_store(self):
         # Email disabled, shouldn't see link.
         response = self.client.get(self.url)

common/djangoapps/student/tests/test_login.py

@@ -216,7 +216,7 @@ class ExternalAuthShibTest(ModuleStoreTestCase):
         self.user_wo_map = UserFactory.create(email='womap@gmail.com')
         self.user_wo_map.save()
 
-    @unittest.skipUnless(settings.MITX_FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
+    @unittest.skipUnless(settings.FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
     def test_login_page_redirect(self):
         """
         Tests that when a shib user types their email address into the login page, they get redirected
@@ -226,7 +226,7 @@ class ExternalAuthShibTest(ModuleStoreTestCase):
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.content, json.dumps({'success': False, 'redirect': reverse('shib-login')}))
 
-    @unittest.skipUnless(settings.MITX_FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
+    @unittest.skipUnless(settings.FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
     def test__get_course_enrollment_domain(self):
         """
         Tests the _get_course_enrollment_domain utility function
@@ -235,7 +235,7 @@ class ExternalAuthShibTest(ModuleStoreTestCase):
         self.assertIsNone(_get_course_enrollment_domain(self.course.id))
         self.assertEqual(self.shib_course.enrollment_domain, _get_course_enrollment_domain(self.shib_course.id))
 
-    @unittest.skipUnless(settings.MITX_FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
+    @unittest.skipUnless(settings.FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
     def test_login_required_dashboard(self):
         """
         Tests redirects to when @login_required to dashboard, which should always be the normal login,
@@ -245,7 +245,7 @@ class ExternalAuthShibTest(ModuleStoreTestCase):
         self.assertEqual(response.status_code, 302)
         self.assertEqual(response['Location'], 'http://testserver/accounts/login?next=/dashboard')
 
-    @unittest.skipUnless(settings.MITX_FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
+    @unittest.skipUnless(settings.FEATURES.get('AUTH_USE_SHIB'), "AUTH_USE_SHIB not set")
     def test_externalauth_login_required_course_context(self):
         """
         Tests the redirects when visiting course-specific URL with @login_required.

common/djangoapps/student/tests/tests.py

@@ -82,7 +82,7 @@ class ResetPasswordTests(TestCase):
         self.assertEquals(bad_email_resp.content, json.dumps({'success': True,
                                                               'value': "('registration/password_reset_done.html', [])"}))
 
-    @unittest.skipUnless(not settings.MITX_FEATURES.get('DISABLE_PASSWORD_RESET_EMAIL_TEST', False),
+    @unittest.skipUnless(not settings.FEATURES.get('DISABLE_PASSWORD_RESET_EMAIL_TEST', False),
                          dedent("""Skipping Test because CMS has not provided necessary templates for password reset.
                                 If LMS tests print this message, that needs to be fixed."""))
     @patch('django.core.mail.send_mail')
@@ -512,7 +512,7 @@ class PaidRegistrationTest(ModuleStoreTestCase):
         self.assertIsNotNone(self.course)
         self.user = User.objects.create(username="jack", email="jack@fake.edx.org")
 
-    @unittest.skipUnless(settings.MITX_FEATURES.get('ENABLE_SHOPPING_CART'), "Shopping Cart not enabled in settings")
+    @unittest.skipUnless(settings.FEATURES.get('ENABLE_SHOPPING_CART'), "Shopping Cart not enabled in settings")
     def test_change_enrollment_add_to_cart(self):
         request = self.req_factory.post(reverse('change_enrollment'), {'course_id': self.course.id,
                                                                        'enrollment_action': 'add_to_cart'})

common/djangoapps/student/views.py

@@ -100,7 +100,7 @@ def index(request, extra_context={}, user=None):
     """
 
     # The course selection work is done in courseware.courses.
-    domain = settings.MITX_FEATURES.get('FORCE_UNIVERSITY_DOMAIN')  # normally False
+    domain = settings.FEATURES.get('FORCE_UNIVERSITY_DOMAIN')  # normally False
     # do explicit check, because domain=None is valid
     if domain is False:
         domain = request.META.get('HTTP_HOST')
@@ -331,7 +331,7 @@ def dashboard(request):
     # only show email settings for Mongo course and when bulk email is turned on
     show_email_settings_for = frozenset(
         course.id for course, _enrollment in course_enrollment_pairs if (
-            settings.MITX_FEATURES['ENABLE_INSTRUCTOR_EMAIL'] and
+            settings.FEATURES['ENABLE_INSTRUCTOR_EMAIL'] and
             modulestore().get_modulestore_type(course.id) == MONGO_MODULESTORE_TYPE and
             CourseAuthorization.instructor_email_enabled(course.id)
         )
@@ -516,7 +516,7 @@ def accounts_login(request):
     This view is mainly used as the redirect from the @login_required decorator.  I don't believe that
     the login path linked from the homepage uses it.
     """
-    if settings.MITX_FEATURES.get('AUTH_USE_CAS'):
+    if settings.FEATURES.get('AUTH_USE_CAS'):
         return redirect(reverse('cas-login'))
     # see if the "next" parameter has been set, whether it has a course context, and if so, whether
     # there is a course-specific place to redirect
@@ -547,7 +547,7 @@ def login_user(request, error=""):
     # check if the user has a linked shibboleth account, if so, redirect the user to shib-login
     # This behavior is pretty much like what gmail does for shibboleth.  Try entering some @stanford.edu
     # address into the Gmail login.
-    if settings.MITX_FEATURES.get('AUTH_USE_SHIB') and user:
+    if settings.FEATURES.get('AUTH_USE_SHIB') and user:
         try:
             eamap = ExternalAuthMap.objects.get(user=user)
             if eamap.external_domain.startswith(external_auth.views.SHIBBOLETH_DOMAIN_PREFIX):
@@ -634,7 +634,7 @@ def logout_user(request):
     # We do not log here, because we have a handler registered
     # to perform logging on successful logouts.
     logout(request)
-    if settings.MITX_FEATURES.get('AUTH_USE_CAS'):
+    if settings.FEATURES.get('AUTH_USE_CAS'):
         target = reverse('cas-logout')
     else:
         target = '/'
@@ -832,8 +832,8 @@ def create_account(request, post_override=None):
         return HttpResponse(json.dumps(js))
 
     # Can't have terms of service for certain SHIB users, like at Stanford
-    tos_not_required = (settings.MITX_FEATURES.get("AUTH_USE_SHIB") and
-                        settings.MITX_FEATURES.get('SHIB_DISABLE_TOS') and
+    tos_not_required = (settings.FEATURES.get("AUTH_USE_SHIB") and
+                        settings.FEATURES.get('SHIB_DISABLE_TOS') and
                         DoExternalAuth and
                         eamap.external_domain.startswith(external_auth.views.SHIBBOLETH_DOMAIN_PREFIX))
 
@@ -896,10 +896,10 @@ def create_account(request, post_override=None):
     message = render_to_string('emails/activation_email.txt', d)
 
     # don't send email if we are doing load testing or random user generation for some reason
-    if not (settings.MITX_FEATURES.get('AUTOMATIC_AUTH_FOR_TESTING')):
+    if not (settings.FEATURES.get('AUTOMATIC_AUTH_FOR_TESTING')):
         try:
-            if settings.MITX_FEATURES.get('REROUTE_ACTIVATION_EMAIL'):
-                dest_addr = settings.MITX_FEATURES['REROUTE_ACTIVATION_EMAIL']
+            if settings.FEATURES.get('REROUTE_ACTIVATION_EMAIL'):
+                dest_addr = settings.FEATURES['REROUTE_ACTIVATION_EMAIL']
                 message = ("Activation for %s (%s): %s\n" % (user, user.email, profile.name) +
                            '-' * 80 + '\n\n' + message)
                 send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [dest_addr], fail_silently=False)
@@ -929,7 +929,7 @@ def create_account(request, post_override=None):
         AUDIT_LOG.info("User registered with external_auth %s", post_vars['username'])
         AUDIT_LOG.info('Updated ExternalAuthMap for %s to be %s', post_vars['username'], eamap)
 
-        if settings.MITX_FEATURES.get('BYPASS_ACTIVATION_EMAIL_FOR_EXTAUTH'):
+        if settings.FEATURES.get('BYPASS_ACTIVATION_EMAIL_FOR_EXTAUTH'):
             log.info('bypassing activation email')
             login_user.is_active = True
             login_user.save()
@@ -969,7 +969,7 @@ def auto_auth(request):
     """
     Automatically logs the user in with a generated random credentials
     This view is only accessible when
-    settings.MITX_SETTINGS['AUTOMATIC_AUTH_FOR_TESTING'] is true.
+    settings.FEATURES['AUTOMATIC_AUTH_FOR_TESTING'] is true.
     """
 
     def get_dummy_post_data(username, password, email, name):
@@ -988,7 +988,7 @@ def auto_auth(request):
     name_base = 'USER_'
     pass_base = 'PASS_'
 
-    max_users = settings.MITX_FEATURES.get('MAX_AUTO_AUTH_USERS', 200)
+    max_users = settings.FEATURES.get('MAX_AUTO_AUTH_USERS', 200)
     number = random.randint(1, max_users)
 
     # Get the params from the request to override default user attributes if specified

common/djangoapps/track/tests.py

@@ -22,7 +22,7 @@ class TrackingTest(TestCase):
             {"event": "my_event", "event_type": "my_event_type", "page": "my_page"},
             {"event": "{'json': 'object'}", "event_type": unichr(512), "page": "my_page"}
         ]
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_SQL_TRACKING_LOGS': True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'ENABLE_SQL_TRACKING_LOGS': True}):
             for request_params in requests:
                 try:  # because /event maps to two different views in lms and cms, we're only going to test lms here
                     response = self.client.post(reverse(user_track), request_params)
@@ -45,7 +45,7 @@ class TrackingTest(TestCase):
             {"event": "my_event", "event_type": "my_event_type", "page": "my_page"},
             {"event": "{'json': 'object'}", "event_type": unichr(512), "page": "my_page"}
         ]
-        with mock.patch.dict('django.conf.settings.MITX_FEATURES', {'ENABLE_SQL_TRACKING_LOGS': True}):
+        with mock.patch.dict('django.conf.settings.FEATURES', {'ENABLE_SQL_TRACKING_LOGS': True}):
             for request_params in requests:
                 try:  # because /event maps to two different views in lms and cms, we're only going to test lms here
                     response = self.client.get(reverse(user_track), request_params)

common/djangoapps/util/tests/test_submit_feedback.py

@@ -12,7 +12,7 @@ import json
 import mock
 
 
-@mock.patch.dict("django.conf.settings.MITX_FEATURES", {"ENABLE_FEEDBACK_SUBMISSION": True})
+@mock.patch.dict("django.conf.settings.FEATURES", {"ENABLE_FEEDBACK_SUBMISSION": True})
 @override_settings(ZENDESK_URL="dummy", ZENDESK_USER="dummy", ZENDESK_API_KEY="dummy")
 @mock.patch("util.views.dog_stats_api")
 @mock.patch("util.views._ZendeskApi", autospec=True)
@@ -282,7 +282,7 @@ class SubmitFeedbackTest(TestCase):
         self.assertEqual(resp.status_code, 200)
         self._assert_datadog_called(datadog_mock, with_tags=True)
 
-    @mock.patch.dict("django.conf.settings.MITX_FEATURES", {"ENABLE_FEEDBACK_SUBMISSION": False})
+    @mock.patch.dict("django.conf.settings.FEATURES", {"ENABLE_FEEDBACK_SUBMISSION": False})
     def test_not_enabled(self, zendesk_mock_class, datadog_mock):
         """
         Test for Zendesk submission not enabled in `settings`.

common/djangoapps/util/views.py

@@ -151,7 +151,7 @@ def submit_feedback(request):
     will be returned with no body; if ticket creation succeeds, an empty
     successful response (200) will be returned.
     """
-    if not settings.MITX_FEATURES.get('ENABLE_FEEDBACK_SUBMISSION', False):
+    if not settings.FEATURES.get('ENABLE_FEEDBACK_SUBMISSION', False):
         raise Http404()
     if request.method != "POST":
         return HttpResponseNotAllowed(["POST"])

common/djangoapps/xmodule_modifiers.py

@@ -163,7 +163,7 @@ def add_histogram(user, block, view, frag, context):  # pylint: disable=unused-a
         histogram = None
         render_histogram = False
 
-    if settings.MITX_FEATURES.get('ENABLE_LMS_MIGRATION'):
+    if settings.FEATURES.get('ENABLE_LMS_MIGRATION'):
         [filepath, filename] = getattr(block, 'xml_attributes', {}).get('filename', ['', None])
         osfs = block.system.filestore
         if filename is not None and osfs.exists(filename):
@@ -201,7 +201,7 @@ def add_histogram(user, block, view, frag, context):  # pylint: disable=unused-a
                      'element_id': block.location.html_id().replace('-', '_'),
                      'edit_link': edit_link,
                      'user': user,
-                     'xqa_server': settings.MITX_FEATURES.get('USE_XQA_SERVER', 'http://xqa:server@content-qa.mitx.mit.edu/xqa'),
+                     'xqa_server': settings.FEATURES.get('USE_XQA_SERVER', 'http://xqa:server@content-qa.mitx.mit.edu/xqa'),
                      'histogram': json.dumps(histogram),
                      'render_histogram': render_histogram,
                      'block_content': frag.content,

common/lib/xmodule/xmodule/video_module.py

@@ -187,7 +187,7 @@ class VideoModule(VideoFields, XModule):
             'show_captions': json.dumps(self.show_captions),
             'start': self.start_time.total_seconds(),
             'end': self.end_time.total_seconds(),
-            'autoplay': settings.MITX_FEATURES.get('AUTOPLAY_VIDEOS', False),
+            'autoplay': settings.FEATURES.get('AUTOPLAY_VIDEOS', False),
             # TODO: Later on the value 1500 should be taken from some global
             # configuration setting field.
             'yt_test_timeout': 1500,

docs/internal/development.md

@@ -116,5 +116,5 @@ course content can be setup to trigger an automatic reload when changes are push
 
 Note that the gitreload-based workflow is not meant for deployments on AWS (or elsewhere) which use collectstatic, since collectstatic is not run by a gitreload event.
 
-Also, the gitreload feature needs MITX_FEATURES['ENABLE_LMS_MIGRATION'] = True in the django settings.
+Also, the gitreload feature needs FEATURES['ENABLE_LMS_MIGRATION'] = True in the django settings.
 

docs/internal/remote_gradebook.md

@@ -10,7 +10,7 @@ An "xserver" is a web-based server that is part of the MITx eco system.  There a
 
 The remote gradebook xserver should be specified in the lms.envs configuration using
 
-    MITX_FEATURES[REMOTE_GRADEBOOK_URL]
+    FEATURES[REMOTE_GRADEBOOK_URL]
 
 Each course, in addition, should define the name of the gradebook being used.  A class "section" may also be specified.  This goes in the policy.json file, eg:
 

lms/djangoapps/branding/__init__.py

@@ -20,7 +20,7 @@ def get_visible_courses(domain=None):
                if isinstance(c, CourseDescriptor)]
     courses = sorted(courses, key=lambda course: course.number)
 
-    if domain and settings.MITX_FEATURES.get('SUBDOMAIN_COURSE_LISTINGS'):
+    if domain and settings.FEATURES.get('SUBDOMAIN_COURSE_LISTINGS'):
         subdomain = pick_subdomain(domain, settings.COURSE_LISTINGS.keys())
         visible_ids = frozenset(settings.COURSE_LISTINGS[subdomain])
         return [course for course in courses if course.id in visible_ids]
@@ -33,7 +33,7 @@ def get_university(domain=None):
     Return the university name specified for the domain, or None
     if no university was specified
     """
-    if not settings.MITX_FEATURES['SUBDOMAIN_BRANDING'] or domain is None:
+    if not settings.FEATURES['SUBDOMAIN_BRANDING'] or domain is None:
         return None
 
     subdomain = pick_subdomain(domain, settings.SUBDOMAIN_BRANDING.keys())

lms/djangoapps/branding/tests.py

@@ -12,10 +12,10 @@ from xmodule.modulestore.tests.factories import CourseFactory
 from courseware.tests.tests import TEST_DATA_MONGO_MODULESTORE
 import student.views
 
-MITX_FEATURES_WITH_STARTDATE = settings.MITX_FEATURES.copy()
-MITX_FEATURES_WITH_STARTDATE['DISABLE_START_DATES'] = False
-MITX_FEATURES_WO_STARTDATE = settings.MITX_FEATURES.copy()
-MITX_FEATURES_WO_STARTDATE['DISABLE_START_DATES'] = True
+FEATURES_WITH_STARTDATE = settings.FEATURES.copy()
+FEATURES_WITH_STARTDATE['DISABLE_START_DATES'] = False
+FEATURES_WO_STARTDATE = settings.FEATURES.copy()
+FEATURES_WO_STARTDATE['DISABLE_START_DATES'] = True
 
 
 @override_settings(MODULESTORE=TEST_DATA_MONGO_MODULESTORE)
@@ -31,7 +31,7 @@ class AnonymousIndexPageTest(ModuleStoreTestCase):
         self.course.enrollment_start = datetime.datetime.now(UTC) + datetime.timedelta(days=3)
         self.store.save_xmodule(self.course)
 
-    @override_settings(MITX_FEATURES=MITX_FEATURES_WITH_STARTDATE)
+    @override_settings(FEATURES=FEATURES_WITH_STARTDATE)
     def test_none_user_index_access_with_startdate_fails(self):
         """
         This was a "before" test for a bugfix.  If someone fixes the bug another way in the future
@@ -40,12 +40,12 @@ class AnonymousIndexPageTest(ModuleStoreTestCase):
         with self.assertRaisesRegexp(AttributeError, "'NoneType' object has no attribute 'is_authenticated'"):
             student.views.index(self.factory.get('/'), user=None)  # pylint: disable=E1101
 
-    @override_settings(MITX_FEATURES=MITX_FEATURES_WITH_STARTDATE)
+    @override_settings(FEATURES=FEATURES_WITH_STARTDATE)
     def test_anon_user_with_startdate_index(self):
         response = self.client.get('/')
         self.assertEqual(response.status_code, 200)
 
-    @override_settings(MITX_FEATURES=MITX_FEATURES_WO_STARTDATE)
+    @override_settings(FEATURES=FEATURES_WO_STARTDATE)
     def test_anon_user_no_startdate_index(self):
         response = self.client.get('/')
         self.assertEqual(response.status_code, 200)

lms/djangoapps/branding/views.py

@@ -22,10 +22,10 @@ def index(request):
     if settings.COURSEWARE_ENABLED and request.user.is_authenticated():
         return redirect(reverse('dashboard'))
 
-    if settings.MITX_FEATURES.get('AUTH_USE_MIT_CERTIFICATES'):
+    if settings.FEATURES.get('AUTH_USE_MIT_CERTIFICATES'):
         from external_auth.views import ssl_login
         return ssl_login(request)
-    if settings.MITX_FEATURES.get('ENABLE_MKTG_SITE'):
+    if settings.FEATURES.get('ENABLE_MKTG_SITE'):
         return redirect(settings.MKTG_URLS.get('ROOT'))
 
     university = branding.get_university(request.META.get('HTTP_HOST'))
@@ -46,10 +46,10 @@ def courses(request):
     to that. Otherwise, if subdomain branding is on, this is the university
     profile page. Otherwise, it's the edX courseware.views.courses page
     """
-    if settings.MITX_FEATURES.get('ENABLE_MKTG_SITE', False):
+    if settings.FEATURES.get('ENABLE_MKTG_SITE', False):
         return redirect(marketing_link('COURSES'), permanent=True)
 
-    if not settings.MITX_FEATURES.get('COURSES_ARE_BROWSABLE'):        
+    if not settings.FEATURES.get('COURSES_ARE_BROWSABLE'):
         raise Http404
 
     #  we do not expect this case to be reached in cases where

lms/djangoapps/bulk_email/models.py

@@ -231,9 +231,9 @@ class CourseAuthorization(models.Model):
 
         If email has not been explicitly enabled, returns False.
         """
-        # If settings.MITX_FEATURES['REQUIRE_COURSE_EMAIL_AUTH'] is
+        # If settings.FEATURES['REQUIRE_COURSE_EMAIL_AUTH'] is
         # set to False, then we enable email for every course.
-        if not settings.MITX_FEATURES['REQUIRE_COURSE_EMAIL_AUTH']:
+        if not settings.FEATURES['REQUIRE_COURSE_EMAIL_AUTH']:
             return True
 
         try:

lms/djangoapps/bulk_email/tests/test_course_optout.py

@@ -59,7 +59,7 @@ class TestOptoutCourseEmails(ModuleStoreTestCase):
         selected_email_link = '<a href="#" onclick="goto(\'Email\')" class="selectedmode">Email</a>'
         self.assertTrue(selected_email_link in response.content)
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
     def test_optout_course(self):
         """
         Make sure student does not receive course email after opting out.
@@ -88,7 +88,7 @@ class TestOptoutCourseEmails(ModuleStoreTestCase):
         # Assert that self.student.email not in mail.to, outbox should be empty
         self.assertEqual(len(mail.outbox), 0)
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
     def test_optin_course(self):
         """
         Make sure student receives course email after opting in.

lms/djangoapps/bulk_email/tests/test_email.py

@@ -46,7 +46,7 @@ class TestEmailSendFromDashboard(ModuleStoreTestCase):
     Test that emails send correctly.
     """
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
     def setUp(self):
         self.course = CourseFactory.create()
 

lms/djangoapps/bulk_email/tests/test_forms.py

@@ -32,7 +32,7 @@ class CourseAuthorizationFormTest(ModuleStoreTestCase):
         """
         patch.stopall()
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
     def test_authorize_mongo_course(self):
         # Initially course shouldn't be authorized
         self.assertFalse(CourseAuthorization.instructor_email_enabled(self.course.id))
@@ -45,7 +45,7 @@ class CourseAuthorizationFormTest(ModuleStoreTestCase):
         # Check that this course is authorized
         self.assertTrue(CourseAuthorization.instructor_email_enabled(self.course.id))
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
     def test_form_typo(self):
         # Munge course id
         bad_id = self.course.id + '_typo'
@@ -63,7 +63,7 @@ class CourseAuthorizationFormTest(ModuleStoreTestCase):
         with self.assertRaisesRegexp(ValueError, "The CourseAuthorization could not be created because the data didn't validate."):
             form.save()
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
     def test_course_name_only(self):
         # Munge course id - common
         bad_id = self.course.id.split('/')[-1]
@@ -86,7 +86,7 @@ class CourseAuthorizationFormTest(ModuleStoreTestCase):
 class CourseAuthorizationXMLFormTest(ModuleStoreTestCase):
     """Check that XML courses cannot be authorized for email."""
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
     def test_xml_course_authorization(self):
         course_id = 'edX/toy/2012_Fall'
         # Assert this is an XML course

lms/djangoapps/bulk_email/tests/test_models.py

@@ -107,7 +107,7 @@ class CourseEmailTemplateTest(TestCase):
 class CourseAuthorizationTest(TestCase):
     """Test the CourseAuthorization model."""
 
-    @patch.dict(settings.MITX_FEATURES, {'REQUIRE_COURSE_EMAIL_AUTH': True})
+    @patch.dict(settings.FEATURES, {'REQUIRE_COURSE_EMAIL_AUTH': True})
     def test_creation_auth_on(self):
         course_id = 'abc/123/doremi'
         # Test that course is not authorized by default
@@ -133,7 +133,7 @@ class CourseAuthorizationTest(TestCase):
             "Course 'abc/123/doremi': Instructor Email Not Enabled"
         )
 
-    @patch.dict(settings.MITX_FEATURES, {'REQUIRE_COURSE_EMAIL_AUTH': False})
+    @patch.dict(settings.FEATURES, {'REQUIRE_COURSE_EMAIL_AUTH': False})
     def test_creation_auth_off(self):
         course_id = 'blahx/blah101/ehhhhhhh'
         # Test that course is authorized by default, since auth is turned off

lms/djangoapps/courseware/access.py

@@ -134,7 +134,7 @@ def _has_access_course_desc(user, course, action):
         (staff can always enroll)
         """
         # if using registration method to restrict (say shibboleth)
-        if settings.MITX_FEATURES.get('RESTRICT_ENROLL_BY_REG_METHOD') and course.enrollment_domain:
+        if settings.FEATURES.get('RESTRICT_ENROLL_BY_REG_METHOD') and course.enrollment_domain:
             if user is not None and user.is_authenticated() and \
                 ExternalAuthMap.objects.filter(user=user, external_domain=course.enrollment_domain):
                 debug("Allow: external_auth of " + course.enrollment_domain)
@@ -173,7 +173,7 @@ def _has_access_course_desc(user, course, action):
         # VS[compat] -- this setting should go away once all courses have
         # properly configured enrollment_start times (if course should be
         # staff-only, set enrollment_start far in the future.)
-        if settings.MITX_FEATURES.get('ACCESS_REQUIRE_STAFF_FOR_COURSE'):
+        if settings.FEATURES.get('ACCESS_REQUIRE_STAFF_FOR_COURSE'):
             # if this feature is on, only allow courses that have ispublic set to be
             # seen by non-staff
             if course.ispublic:
@@ -234,7 +234,7 @@ def _has_access_descriptor(user, descriptor, action, course_context=None):
         don't have to hit the enrollments table on every module load.
         """
         # If start dates are off, can always load
-        if settings.MITX_FEATURES['DISABLE_START_DATES'] and not is_masquerading_as_student(user):
+        if settings.FEATURES['DISABLE_START_DATES'] and not is_masquerading_as_student(user):
             debug("Allow: DISABLE_START_DATES")
             return True
 
@@ -361,7 +361,7 @@ def _adjust_start_date_for_beta_testers(user, descriptor, course_context=None):
     the user is looking at.  Once we have proper usages and definitions per the XBlock
     design, this should use the course the usage is in.
 
-    NOTE: If testing manually, make sure MITX_FEATURES['DISABLE_START_DATES'] = False
+    NOTE: If testing manually, make sure FEATURES['DISABLE_START_DATES'] = False
     in envs/dev.py!
     """
     if descriptor.days_early_for_beta is None:

lms/djangoapps/courseware/masquerade.py

@@ -40,7 +40,7 @@ def setup_masquerade(request, staff_access=False):
     if request.user is None:
         return None
 
-    if not settings.MITX_FEATURES.get('ENABLE_MASQUERADE', False):
+    if not settings.FEATURES.get('ENABLE_MASQUERADE', False):
         return None
 
     if not staff_access:  # can masquerade only if user has staff access to course

lms/djangoapps/courseware/module_render.py

@@ -363,7 +363,7 @@ def get_module_for_descriptor_internal(user, descriptor, field_data_cache, cours
         reverse('jump_to_id', kwargs={'course_id': course_id, 'module_id': ''}),
     ))
 
-    if settings.MITX_FEATURES.get('DISPLAY_HISTOGRAMS_TO_STAFF'):
+    if settings.FEATURES.get('DISPLAY_HISTOGRAMS_TO_STAFF'):
         if has_access(user, descriptor, 'staff', course_id):
             block_wrappers.append(partial(add_histogram, user))
 
@@ -423,7 +423,7 @@ def get_module_for_descriptor_internal(user, descriptor, field_data_cache, cours
 
     # pass position specified in URL to module through ModuleSystem
     system.set('position', position)
-    if settings.MITX_FEATURES.get('ENABLE_PSYCHOMETRICS'):
+    if settings.FEATURES.get('ENABLE_PSYCHOMETRICS'):
         system.set(
             'psychometrics_handler',  # set callback for updating PsychometricsData
             make_psychometrics_data_update_handler(course_id, user, descriptor.location.url())

lms/djangoapps/courseware/tabs.py

@@ -100,7 +100,7 @@ def _discussion(tab, user, course, active_page, request):
     """
     This tab format only supports the new Berkeley discussion forums.
     """
-    if settings.MITX_FEATURES.get('ENABLE_DISCUSSION_SERVICE'):
+    if settings.FEATURES.get('ENABLE_DISCUSSION_SERVICE'):
         link = reverse('django_comment_client.forum.views.forum_form_discussion',
                               args=[course.id])
         return [CourseTab(tab['name'], link, active_page == 'discussion')]
@@ -129,7 +129,7 @@ def _textbooks(tab, user, course, active_page, request):
     """
     Generates one tab per textbook.  Only displays if user is authenticated.
     """
-    if user.is_authenticated() and settings.MITX_FEATURES.get('ENABLE_TEXTBOOK'):
+    if user.is_authenticated() and settings.FEATURES.get('ENABLE_TEXTBOOK'):
         # since there can be more than one textbook, active_page is e.g. "book/0".
         return [CourseTab(textbook.title, reverse('book', args=[course.id, index]),
                           active_page == "textbook/{0}".format(index))
@@ -211,7 +211,7 @@ def _combined_open_ended_grading(tab, user, course, active_page, request):
 
 
 def _notes_tab(tab, user, course, active_page, request):
-    if user.is_authenticated() and settings.MITX_FEATURES.get('ENABLE_STUDENT_NOTES'):
+    if user.is_authenticated() and settings.FEATURES.get('ENABLE_STUDENT_NOTES'):
         link = reverse('notes', args=[course.id])
         return [CourseTab(tab['name'], link, active_page == 'notes')]
     return []
@@ -349,7 +349,7 @@ def get_discussion_link(course):
     """
     if course.discussion_link:
         return course.discussion_link
-    elif not settings.MITX_FEATURES.get('ENABLE_DISCUSSION_SERVICE'):
+    elif not settings.FEATURES.get('ENABLE_DISCUSSION_SERVICE'):
         return None
     elif hasattr(course, 'tabs') and course.tabs and not any([tab['type'] == 'discussion' for tab in course.tabs]):
         return None

lms/djangoapps/courseware/tests/test_tabs.py

@@ -166,7 +166,7 @@ class TextbooksTestCase(TestCase):
         self.textbook_1 = 'textbook/1'
         self.prohibited_page = 'you_shouldnt_be_seein_this'
 
-    @override_settings(MITX_FEATURES={'ENABLE_TEXTBOOK': True})
+    @override_settings(FEATURES={'ENABLE_TEXTBOOK': True})
     def test_textbooks1(self):
 
         tab_list = tab_constructor(
@@ -211,7 +211,7 @@ class TextbooksTestCase(TestCase):
         )
         self.assertEqual(tab_list[1].is_active, False)
 
-    @override_settings(MITX_FEATURES={'ENABLE_TEXTBOOK': False})
+    @override_settings(FEATURES={'ENABLE_TEXTBOOK': False})
     def test_textbooks0(self):
 
         tab_list = tab_constructor(
@@ -304,34 +304,34 @@ class DiscussionLinkTestCase(ModuleStoreTestCase):
                 return None
         return patch("courseware.tabs.reverse", patched_reverse)
 
-    @patch.dict("django.conf.settings.MITX_FEATURES", {"ENABLE_DISCUSSION_SERVICE": False})
+    @patch.dict("django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": False})
     def test_explicit_discussion_link(self):
         """Test that setting discussion_link overrides everything else"""
         course = CourseFactory.create(discussion_link="other_discussion_link", tabs=self.tabs_with_discussion)
         self.assertEqual(tabs.get_discussion_link(course), "other_discussion_link")
 
-    @patch.dict("django.conf.settings.MITX_FEATURES", {"ENABLE_DISCUSSION_SERVICE": False})
+    @patch.dict("django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": False})
     def test_discussions_disabled(self):
         """Test that other cases return None with discussions disabled"""
         for i, t in enumerate([None, self.tabs_with_discussion, self.tabs_without_discussion]):
             course = CourseFactory.create(tabs=t, number=str(i))
             self.assertEqual(tabs.get_discussion_link(course), None)
 
-    @patch.dict("django.conf.settings.MITX_FEATURES", {"ENABLE_DISCUSSION_SERVICE": True})
+    @patch.dict("django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True})
     def test_no_tabs(self):
         """Test a course without tabs configured"""
         course = CourseFactory.create(tabs=None)
         with self._patch_reverse(course):
             self.assertEqual(tabs.get_discussion_link(course), "default_discussion_link")
 
-    @patch.dict("django.conf.settings.MITX_FEATURES", {"ENABLE_DISCUSSION_SERVICE": True})
+    @patch.dict("django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True})
     def test_tabs_with_discussion(self):
         """Test a course with a discussion tab configured"""
         course = CourseFactory.create(tabs=self.tabs_with_discussion)
         with self._patch_reverse(course):
             self.assertEqual(tabs.get_discussion_link(course), "default_discussion_link")
 
-    @patch.dict("django.conf.settings.MITX_FEATURES", {"ENABLE_DISCUSSION_SERVICE": True})
+    @patch.dict("django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True})
     def test_tabs_without_discussion(self):
         """Test a course with tabs configured but without a discussion tab"""
         course = CourseFactory.create(tabs=self.tabs_without_discussion)

lms/djangoapps/courseware/tests/test_video_mongo.py

@@ -53,7 +53,7 @@ class TestVideo(BaseTestXmodule):
             'sub': u'a_sub_file.srt.sjson',
             'track': '',
             'youtube_streams': _create_youtube_string(self.item_module),
-            'autoplay': settings.MITX_FEATURES.get('AUTOPLAY_VIDEOS', False),
+            'autoplay': settings.FEATURES.get('AUTOPLAY_VIDEOS', False),
             'yt_test_timeout': 1500,
             'yt_test_url': 'https://gdata.youtube.com/feeds/api/videos/'
         }
@@ -107,7 +107,7 @@ class TestVideoNonYouTube(TestVideo):
             'sub': u'a_sub_file.srt.sjson',
             'track': '',
             'youtube_streams': '1.00:OEoXaMPEzfM',
-            'autoplay': settings.MITX_FEATURES.get('AUTOPLAY_VIDEOS', True),
+            'autoplay': settings.FEATURES.get('AUTOPLAY_VIDEOS', True),
             'yt_test_timeout': 1500,
             'yt_test_url': 'https://gdata.youtube.com/feeds/api/videos/'
         }

lms/djangoapps/courseware/tests/test_video_xml.py

@@ -88,7 +88,7 @@ class VideoModuleUnitTest(unittest.TestCase):
             'sources': sources,
             'youtube_streams': _create_youtube_string(module),
             'track': '',
-            'autoplay': settings.MITX_FEATURES.get('AUTOPLAY_VIDEOS', False),
+            'autoplay': settings.FEATURES.get('AUTOPLAY_VIDEOS', False),
             'yt_test_timeout': 1500,
             'yt_test_url': 'https://gdata.youtube.com/feeds/api/videos/'
         }

lms/djangoapps/courseware/tests/test_view_authentication.py

@@ -253,7 +253,7 @@ class TestViewAuth(ModuleStoreTestCase, LoginEnrollmentTestCase):
         for url in urls:
             check_for_get_code(self, 200, url)
 
-    @patch.dict('courseware.access.settings.MITX_FEATURES', {'DISABLE_START_DATES': False})
+    @patch.dict('courseware.access.settings.FEATURES', {'DISABLE_START_DATES': False})
     def test_dark_launch_enrolled_student(self):
         """
         Make sure that before course start, students can't access course
@@ -280,7 +280,7 @@ class TestViewAuth(ModuleStoreTestCase, LoginEnrollmentTestCase):
         self._check_non_staff_light(self.test_course)
         self._check_non_staff_dark(self.test_course)
 
-    @patch.dict('courseware.access.settings.MITX_FEATURES', {'DISABLE_START_DATES': False})
+    @patch.dict('courseware.access.settings.FEATURES', {'DISABLE_START_DATES': False})
     def test_dark_launch_instructor(self):
         """
         Make sure that before course start instructors can access the
@@ -303,7 +303,7 @@ class TestViewAuth(ModuleStoreTestCase, LoginEnrollmentTestCase):
         self._check_non_staff_dark(self.test_course)
         self._check_staff(self.course)
 
-    @patch.dict('courseware.access.settings.MITX_FEATURES', {'DISABLE_START_DATES': False})
+    @patch.dict('courseware.access.settings.FEATURES', {'DISABLE_START_DATES': False})
     def test_dark_launch_global_staff(self):
         """
         Make sure that before course start staff can access
@@ -324,7 +324,7 @@ class TestViewAuth(ModuleStoreTestCase, LoginEnrollmentTestCase):
         self._check_staff(self.course)
         self._check_staff(self.test_course)
 
-    @patch.dict('courseware.access.settings.MITX_FEATURES', {'DISABLE_START_DATES': False})
+    @patch.dict('courseware.access.settings.FEATURES', {'DISABLE_START_DATES': False})
     def test_enrollment_period(self):
         """
         Check that enrollment periods work.
@@ -371,7 +371,7 @@ class TestBetatesterAccess(ModuleStoreTestCase):
         self.normal_student = UserFactory()
         self.beta_tester = BetaTesterFactory(course=self.course.location)
 
-    @patch.dict('courseware.access.settings.MITX_FEATURES', {'DISABLE_START_DATES': False})
+    @patch.dict('courseware.access.settings.FEATURES', {'DISABLE_START_DATES': False})
     def test_course_beta_period(self):
         """
         Check that beta-test access works for courses.
@@ -384,7 +384,7 @@ class TestBetatesterAccess(ModuleStoreTestCase):
         # now the student should see it
         self.assertTrue(has_access(self.beta_tester, self.course, 'load'))
 
-    @patch.dict('courseware.access.settings.MITX_FEATURES', {'DISABLE_START_DATES': False})
+    @patch.dict('courseware.access.settings.FEATURES', {'DISABLE_START_DATES': False})
     def test_content_beta_period(self):
         """
         Check that beta-test access works for content.

lms/djangoapps/courseware/tests/test_views.py

@@ -86,8 +86,8 @@ class ViewsTestCase(TestCase):
         chapter = 'Overview'
         self.chapter_url = '%s/%s/%s' % ('/courses', self.course_id, chapter)
 
-    @unittest.skipUnless(settings.MITX_FEATURES.get('ENABLE_SHOPPING_CART'), "Shopping Cart not enabled in settings")
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_PAID_COURSE_REGISTRATION': True})
+    @unittest.skipUnless(settings.FEATURES.get('ENABLE_SHOPPING_CART'), "Shopping Cart not enabled in settings")
+    @patch.dict(settings.FEATURES, {'ENABLE_PAID_COURSE_REGISTRATION': True})
     def test_course_about_in_cart(self):
         in_cart_span = '<span class="add-to-cart">'
         # don't mock this course due to shopping cart existence checking

lms/djangoapps/courseware/views.py

@@ -263,12 +263,12 @@ def index(request, course_id, chapter=None, section=None,
             'fragment': Fragment(),
             'staff_access': staff_access,
             'masquerade': masq,
-            'xqa_server': settings.MITX_FEATURES.get('USE_XQA_SERVER', 'http://xqa:server@content-qa.mitx.mit.edu/xqa')
+            'xqa_server': settings.FEATURES.get('USE_XQA_SERVER', 'http://xqa:server@content-qa.mitx.mit.edu/xqa')
             }
 
         # Only show the chat if it's enabled by the course and in the
         # settings.
-        show_chat = course.show_chat and settings.MITX_FEATURES['ENABLE_CHAT']
+        show_chat = course.show_chat and settings.FEATURES['ENABLE_CHAT']
         if show_chat:
             context['chat'] = chat_settings(course, user)
             # If we couldn't load the chat settings, then don't show
@@ -514,7 +514,7 @@ def registered_for_course(course, user):
 @ensure_csrf_cookie
 @cache_if_anonymous
 def course_about(request, course_id):
-    if settings.MITX_FEATURES.get('ENABLE_MKTG_SITE', False):
+    if settings.FEATURES.get('ENABLE_MKTG_SITE', False):
         raise Http404
 
     course = get_course_with_access(request.user, course_id, 'see_exists')
@@ -526,14 +526,14 @@ def course_about(request, course_id):
         course_target = reverse('about_course', args=[course.id])
 
     show_courseware_link = (has_access(request.user, course, 'load') or
-                            settings.MITX_FEATURES.get('ENABLE_LMS_MIGRATION'))
+                            settings.FEATURES.get('ENABLE_LMS_MIGRATION'))
 
     # Note: this is a flow for payment for course registration, not the Verified Certificate flow.
     registration_price = 0
     in_cart = False
     reg_then_add_to_cart_link = ""
-    if (settings.MITX_FEATURES.get('ENABLE_SHOPPING_CART') and
-        settings.MITX_FEATURES.get('ENABLE_PAID_COURSE_REGISTRATION')):
+    if (settings.FEATURES.get('ENABLE_SHOPPING_CART') and
+        settings.FEATURES.get('ENABLE_PAID_COURSE_REGISTRATION')):
         registration_price = CourseMode.min_course_price_for_currency(course_id,
                                                                       settings.PAID_COURSE_REGISTRATION_CURRENCY[0])
         if request.user.is_authenticated():
@@ -579,7 +579,7 @@ def mktg_course_about(request, course_id):
     allow_registration = has_access(request.user, course, 'enroll')
 
     show_courseware_link = (has_access(request.user, course, 'load') or
-                            settings.MITX_FEATURES.get('ENABLE_LMS_MIGRATION'))
+                            settings.FEATURES.get('ENABLE_LMS_MIGRATION'))
     course_modes = CourseMode.modes_for_course(course.id)
 
     return render_to_response(

lms/djangoapps/django_comment_client/base/tests.py

@@ -21,7 +21,7 @@ log = logging.getLogger(__name__)
 @patch('lms.lib.comment_client.utils.requests.request')
 class ViewsTestCase(UrlResetMixin, ModuleStoreTestCase):
 
-    @patch.dict("django.conf.settings.MITX_FEATURES", {"ENABLE_DISCUSSION_SERVICE": True})
+    @patch.dict("django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True})
     def setUp(self):
 
         # Patching the ENABLE_DISCUSSION_SERVICE value affects the contents of urls.py,

lms/djangoapps/django_comment_client/forum/tests.py

@@ -18,7 +18,7 @@ log = logging.getLogger(__name__)
 @override_settings(MODULESTORE=TEST_DATA_MIXED_MODULESTORE)
 class ViewsExceptionTestCase(UrlResetMixin, ModuleStoreTestCase):
 
-    @patch.dict("django.conf.settings.MITX_FEATURES", {"ENABLE_DISCUSSION_SERVICE": True})
+    @patch.dict("django.conf.settings.FEATURES", {"ENABLE_DISCUSSION_SERVICE": True})
     def setUp(self):
 
         # Patching the ENABLE_DISCUSSION_SERVICE value affects the contents of urls.py,

lms/djangoapps/instructor/hint_manager.py

@@ -4,7 +4,7 @@ Views for hint management.
 Get to these views through courseurl/hint_manager.
 For example: https://courses.edx.org/courses/MITx/2.01x/2013_Spring/hint_manager
 
-These views will only be visible if MITX_FEATURES['ENABLE_HINTER_INSTRUCTOR_VIEW'] = True
+These views will only be visible if FEATURES['ENABLE_HINTER_INSTRUCTOR_VIEW'] = True
 """
 
 import json

lms/djangoapps/instructor/tests/test_email.py

@@ -47,7 +47,7 @@ class TestNewInstructorDashboardEmailViewMongoBacked(ModuleStoreTestCase):
     # In order for bulk email to work, we must have both the ENABLE_INSTRUCTOR_EMAIL_FLAG
     # set to True and for the course to be Mongo-backed.
     # The flag is enabled and the course is Mongo-backed (should work)
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
     def test_email_flag_true_mongo_true(self):
         # Assert that instructor email is enabled for this course - since REQUIRE_COURSE_EMAIL_AUTH is False,
         # all courses should be authorized to use email.
@@ -61,14 +61,14 @@ class TestNewInstructorDashboardEmailViewMongoBacked(ModuleStoreTestCase):
         self.assertEqual(response.status_code, 200)
 
     # The course is Mongo-backed but the flag is disabled (should not work)
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False})
     def test_email_flag_false_mongo_true(self):
         # Assert that the URL for the email view is not in the response
         response = self.client.get(self.url)
         self.assertFalse(self.email_link in response.content)
 
     # Flag is enabled, but we require course auth and haven't turned it on for this course
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
     def test_course_not_authorized(self):
         # Assert that instructor email is not enabled for this course
         self.assertFalse(CourseAuthorization.instructor_email_enabled(self.course.id))
@@ -77,7 +77,7 @@ class TestNewInstructorDashboardEmailViewMongoBacked(ModuleStoreTestCase):
         self.assertFalse(self.email_link in response.content)
 
     # Flag is enabled, we require course auth and turn it on for this course
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
     def test_course_authorized(self):
         # Assert that instructor email is not enabled for this course
         self.assertFalse(CourseAuthorization.instructor_email_enabled(self.course.id))
@@ -96,7 +96,7 @@ class TestNewInstructorDashboardEmailViewMongoBacked(ModuleStoreTestCase):
         self.assertTrue(self.email_link in response.content)
 
     # Flag is disabled, but course is authorized
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False, 'REQUIRE_COURSE_EMAIL_AUTH': True})
     def test_course_authorized_feature_off(self):
         # Authorize the course to use email
         cauth = CourseAuthorization(course_id=self.course.id, email_enabled=True)
@@ -128,13 +128,13 @@ class TestNewInstructorDashboardEmailViewXMLBacked(ModuleStoreTestCase):
 
     # The flag is enabled, and since REQUIRE_COURSE_EMAIL_AUTH is False, all courses should
     # be authorized to use email. But the course is not Mongo-backed (should not work)
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
     def test_email_flag_true_mongo_false(self):
         response = self.client.get(self.url)
         self.assertFalse(self.email_link in response.content)
 
     # The flag is disabled and the course is not Mongo-backed (should not work)
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False, 'REQUIRE_COURSE_EMAIL_AUTH': False})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False, 'REQUIRE_COURSE_EMAIL_AUTH': False})
     def test_email_flag_false_mongo_false(self):
         response = self.client.get(self.url)
         self.assertFalse(self.email_link in response.content)

lms/djangoapps/instructor/tests/test_legacy_email.py

@@ -42,7 +42,7 @@ class TestInstructorDashboardEmailView(ModuleStoreTestCase):
         """
         patch.stopall()
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': False})
     def test_email_flag_true(self):
         # Assert that the URL for the email view is in the response
         response = self.client.get(self.url)
@@ -60,14 +60,14 @@ class TestInstructorDashboardEmailView(ModuleStoreTestCase):
         send_to_label = '<label for="id_to">Send to:</label>'
         self.assertTrue(send_to_label in response.content)
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
     def test_email_flag_unauthorized(self):
         # Assert that the URL for the email view is not in the response
         # email is enabled, but this course is not authorized to send email
         response = self.client.get(self.url)
         self.assertFalse(self.email_link in response.content)
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True, 'REQUIRE_COURSE_EMAIL_AUTH': True})
     def test_email_flag_authorized(self):
         # Assert that the URL for the email view is in the response
         # email is enabled, and this course is authorized to send email
@@ -86,13 +86,13 @@ class TestInstructorDashboardEmailView(ModuleStoreTestCase):
         response = self.client.get(self.url)
         self.assertTrue(self.email_link in response.content)
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': False})
     def test_email_flag_false(self):
         # Assert that the URL for the email view is not in the response
         response = self.client.get(self.url)
         self.assertFalse(self.email_link in response.content)
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_INSTRUCTOR_EMAIL': True})
     def test_email_flag_true_xml_store(self):
         # If the enable email setting is enabled, but this is an XML backed course,
         # the email view shouldn't be available on the instructor dashboard.

lms/djangoapps/instructor/views/instructor_dashboard.py

@@ -56,7 +56,7 @@ def instructor_dashboard_2(request, course_id):
     ]
 
     # Gate access to course email by feature flag & by course-specific authorization
-    if settings.MITX_FEATURES['ENABLE_INSTRUCTOR_EMAIL'] and \
+    if settings.FEATURES['ENABLE_INSTRUCTOR_EMAIL'] and \
        is_studio_course and CourseAuthorization.instructor_email_enabled(course_id):
         sections.append(_section_send_email(course_id, access, course))
 
@@ -66,7 +66,7 @@ def instructor_dashboard_2(request, course_id):
 
     enrollment_count = sections[0]['enrollment_count']
     disable_buttons = False
-    max_enrollment_for_buttons = settings.MITX_FEATURES.get("MAX_ENROLLMENT_INSTR_BUTTONS")
+    max_enrollment_for_buttons = settings.FEATURES.get("MAX_ENROLLMENT_INSTR_BUTTONS")
     if max_enrollment_for_buttons is not None:
         disable_buttons = enrollment_count > max_enrollment_for_buttons
 

lms/djangoapps/instructor/views/legacy.py

@@ -180,7 +180,7 @@ def instructor_dashboard(request, course_id):
     action = request.POST.get('action', '')
     use_offline = request.POST.get('use_offline_grades', False)
 
-    if settings.MITX_FEATURES['ENABLE_MANUAL_GIT_RELOAD']:
+    if settings.FEATURES['ENABLE_MANUAL_GIT_RELOAD']:
         if 'GIT pull' in action:
             data_dir = course.data_dir
             log.debug('git pull {0}'.format(data_dir))
@@ -766,7 +766,7 @@ def instructor_dashboard(request, course_id):
         msg += "<br/><font color='orange'>Grades from %s</font>" % offline_grades_available(course_id)
 
     # generate list of pending background tasks
-    if settings.MITX_FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
+    if settings.FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
         instructor_tasks = get_running_instructor_tasks(course_id)
     else:
         instructor_tasks = None
@@ -794,7 +794,7 @@ def instructor_dashboard(request, course_id):
     # 1. Feature flag is on
     # 2. We have explicitly enabled email for the given course via django-admin
     # 3. It is NOT an XML course
-    if settings.MITX_FEATURES['ENABLE_INSTRUCTOR_EMAIL'] and \
+    if settings.FEATURES['ENABLE_INSTRUCTOR_EMAIL'] and \
        CourseAuthorization.instructor_email_enabled(course_id) and is_studio_course:
         show_email_tab = True
 
@@ -805,7 +805,7 @@ def instructor_dashboard(request, course_id):
 
     # disable buttons for large courses
     disable_buttons = False
-    max_enrollment_for_buttons = settings.MITX_FEATURES.get("MAX_ENROLLMENT_INSTR_BUTTONS")
+    max_enrollment_for_buttons = settings.FEATURES.get("MAX_ENROLLMENT_INSTR_BUTTONS")
     if max_enrollment_for_buttons is not None:
         disable_buttons = enrollment_number > max_enrollment_for_buttons
 
@@ -841,7 +841,7 @@ def instructor_dashboard(request, course_id):
         'disable_buttons': disable_buttons
     }
 
-    if settings.MITX_FEATURES.get('ENABLE_INSTRUCTOR_BETA_DASHBOARD'):
+    if settings.FEATURES.get('ENABLE_INSTRUCTOR_BETA_DASHBOARD'):
         context['beta_dashboard_url'] = reverse('instructor_dashboard_2', kwargs={'course_id': course_id})
 
     return render_to_response('courseware/instructor_dashboard.html', context)
@@ -856,9 +856,9 @@ def _do_remote_gradebook(user, course, action, args=None, files=None):
         msg = "No remote gradebook defined in course metadata"
         return msg, {}
 
-    rgurl = settings.MITX_FEATURES.get('REMOTE_GRADEBOOK_URL', '')
+    rgurl = settings.FEATURES.get('REMOTE_GRADEBOOK_URL', '')
     if not rgurl:
-        msg = "No remote gradebook url defined in settings.MITX_FEATURES"
+        msg = "No remote gradebook url defined in settings.FEATURES"
         return msg, {}
 
     rgname = rg.get('name', '')

lms/djangoapps/notes/utils.py

@@ -7,11 +7,11 @@ def notes_enabled_for_course(course):
     Returns True if the notes app is enabled for the course, False otherwise.
 
     In order for the app to be enabled it must be:
-        1) enabled globally via MITX_FEATURES.
+        1) enabled globally via FEATURES.
         2) present in the course tab configuration.
     '''
 
     tab_found = next((True for t in course.tabs if t['type'] == 'notes'), False)
-    feature_enabled = settings.MITX_FEATURES.get('ENABLE_STUDENT_NOTES')
+    feature_enabled = settings.FEATURES.get('ENABLE_STUDENT_NOTES')
 
     return feature_enabled and tab_found

lms/djangoapps/shoppingcart/context_processor.py

@@ -17,7 +17,7 @@ def user_has_cart_context_processor(request):
     """
     return {'display_shopping_cart': (
         request.user.is_authenticated() and                                # user is logged in and
-        settings.MITX_FEATURES.get('ENABLE_PAID_COURSE_REGISTRATION') and  # settings enable paid course reg and
-        settings.MITX_FEATURES.get('ENABLE_SHOPPING_CART') and             # settings enable shopping cart and
+        settings.FEATURES.get('ENABLE_PAID_COURSE_REGISTRATION') and  # settings enable paid course reg and
+        settings.FEATURES.get('ENABLE_SHOPPING_CART') and             # settings enable shopping cart and
         shoppingcart.models.Order.user_cart_has_items(request.user)        # user's cart has items
     )}

lms/djangoapps/shoppingcart/models.py

@@ -143,7 +143,7 @@ class Order(models.Model):
         self.bill_to_state = state
         self.bill_to_country = country
         self.bill_to_postalcode = postalcode
-        if settings.MITX_FEATURES['STORE_BILLING_INFO']:
+        if settings.FEATURES['STORE_BILLING_INFO']:
             self.bill_to_street1 = street1
             self.bill_to_street2 = street2
             self.bill_to_ccnum = ccnum
@@ -164,7 +164,7 @@ class Order(models.Model):
         message = render_to_string('emails/order_confirmation_email.txt', {
             'order': self,
             'order_items': orderitems,
-            'has_billing_info': settings.MITX_FEATURES['STORE_BILLING_INFO']
+            'has_billing_info': settings.FEATURES['STORE_BILLING_INFO']
         })
         try:
             send_mail(subject, message,

lms/djangoapps/shoppingcart/tests/test_context_processor.py

@@ -33,27 +33,27 @@ class UserCartContextProcessorUnitTest(ModuleStoreTestCase):
         cart = Order.get_cart_for_user(self.user)
         PaidCourseRegistration.add_to_order(cart, course.id)
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_SHOPPING_CART': False, 'ENABLE_PAID_COURSE_REGISTRATION': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_SHOPPING_CART': False, 'ENABLE_PAID_COURSE_REGISTRATION': True})
     def test_no_enable_shoppingcart(self):
         """
-        Tests when MITX_FEATURES['ENABLE_SHOPPING_CART'] is not set
+        Tests when FEATURES['ENABLE_SHOPPING_CART'] is not set
         """
         self.add_to_cart()
         self.request.user = self.user
         context = user_has_cart_context_processor(self.request)
         self.assertFalse(context['display_shopping_cart'])
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_SHOPPING_CART': True, 'ENABLE_PAID_COURSE_REGISTRATION': False})
+    @patch.dict(settings.FEATURES, {'ENABLE_SHOPPING_CART': True, 'ENABLE_PAID_COURSE_REGISTRATION': False})
     def test_no_enable_paid_course_registration(self):
         """
-        Tests when MITX_FEATURES['ENABLE_PAID_COURSE_REGISTRATION'] is not set
+        Tests when FEATURES['ENABLE_PAID_COURSE_REGISTRATION'] is not set
         """
         self.add_to_cart()
         self.request.user = self.user
         context = user_has_cart_context_processor(self.request)
         self.assertFalse(context['display_shopping_cart'])
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_SHOPPING_CART': True, 'ENABLE_PAID_COURSE_REGISTRATION': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_SHOPPING_CART': True, 'ENABLE_PAID_COURSE_REGISTRATION': True})
     def test_anonymous_user(self):
         """
         Tests when request.user is anonymous
@@ -62,7 +62,7 @@ class UserCartContextProcessorUnitTest(ModuleStoreTestCase):
         context = user_has_cart_context_processor(self.request)
         self.assertFalse(context['display_shopping_cart'])
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_SHOPPING_CART': True, 'ENABLE_PAID_COURSE_REGISTRATION': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_SHOPPING_CART': True, 'ENABLE_PAID_COURSE_REGISTRATION': True})
     def test_no_items_in_cart(self):
         """
         Tests when request.user doesn't have a cart with items
@@ -71,7 +71,7 @@ class UserCartContextProcessorUnitTest(ModuleStoreTestCase):
         context = user_has_cart_context_processor(self.request)
         self.assertFalse(context['display_shopping_cart'])
 
-    @patch.dict(settings.MITX_FEATURES, {'ENABLE_SHOPPING_CART': True, 'ENABLE_PAID_COURSE_REGISTRATION': True})
+    @patch.dict(settings.FEATURES, {'ENABLE_SHOPPING_CART': True, 'ENABLE_PAID_COURSE_REGISTRATION': True})
     def test_items_in_cart(self):
         """
         Tests when request.user has a cart with items

lms/djangoapps/shoppingcart/tests/test_models.py

@@ -161,7 +161,7 @@ class OrderTest(ModuleStoreTestCase):
         )
 
     @patch('shoppingcart.models.render_to_string')
-    @patch.dict(settings.MITX_FEATURES, {'STORE_BILLING_INFO': True})
+    @patch.dict(settings.FEATURES, {'STORE_BILLING_INFO': True})
     def test_billing_info_storage_on(self, render):
         cart = Order.get_cart_for_user(self.user)
         self.purchase_with_data(cart)
@@ -179,7 +179,7 @@ class OrderTest(ModuleStoreTestCase):
         self.assertTrue(context['has_billing_info'])
 
     @patch('shoppingcart.models.render_to_string')
-    @patch.dict(settings.MITX_FEATURES, {'STORE_BILLING_INFO': False})
+    @patch.dict(settings.FEATURES, {'STORE_BILLING_INFO': False})
     def test_billing_info_storage_off(self, render):
         cart = Order.get_cart_for_user(self.user)
         self.purchase_with_data(cart)

lms/djangoapps/shoppingcart/urls.py

@@ -5,7 +5,7 @@ urlpatterns = patterns('shoppingcart.views',  # nopep8
     url(r'^postpay_callback/$', 'postpay_callback'),  # Both the ~accept and ~reject callback pages are handled here
     url(r'^receipt/(?P<ordernum>[0-9]*)/$', 'show_receipt'),
 )
-if settings.MITX_FEATURES['ENABLE_SHOPPING_CART']:
+if settings.FEATURES['ENABLE_SHOPPING_CART']:
     urlpatterns += patterns(
         'shoppingcart.views',
         url(r'^$', 'show_cart'),
@@ -15,7 +15,7 @@ if settings.MITX_FEATURES['ENABLE_SHOPPING_CART']:
         url(r'^csv_report/$', 'csv_report', name='payment_csv_report'),
     )
 
-if settings.MITX_FEATURES.get('ENABLE_PAYMENT_FAKE'):
+if settings.FEATURES.get('ENABLE_PAYMENT_FAKE'):
     from shoppingcart.tests.payment_fake import PaymentFakeView
     urlpatterns += patterns(
         'shoppingcart.tests.payment_fake',

lms/djangoapps/verify_student/models.py

@@ -477,7 +477,7 @@ class SoftwareSecurePhotoVerification(PhotoVerification):
         # developing and aren't interested in working on student identity
         # verification functionality. If you do want to work on it, you have to
         # explicitly enable these in your private settings.
-        if settings.MITX_FEATURES.get('AUTOMATIC_VERIFY_STUDENT_IDENTITY_FOR_TESTING'):
+        if settings.FEATURES.get('AUTOMATIC_VERIFY_STUDENT_IDENTITY_FOR_TESTING'):
             return
 
         aes_key_str = settings.VERIFY_STUDENT["SOFTWARE_SECURE"]["FACE_IMAGE_AES_KEY"]
@@ -502,7 +502,7 @@ class SoftwareSecurePhotoVerification(PhotoVerification):
         # developing and aren't interested in working on student identity
         # verification functionality. If you do want to work on it, you have to
         # explicitly enable these in your private settings.
-        if settings.MITX_FEATURES.get('AUTOMATIC_VERIFY_STUDENT_IDENTITY_FOR_TESTING'):
+        if settings.FEATURES.get('AUTOMATIC_VERIFY_STUDENT_IDENTITY_FOR_TESTING'):
             return
 
         aes_key = random_aes_key()
@@ -670,7 +670,7 @@ class SoftwareSecurePhotoVerification(PhotoVerification):
         # create the message because that would require encryption and message
         # signing that rely on settings.VERIFY_STUDENT values that aren't set
         # in dev. So we just pretend like we successfully posted
-        if settings.MITX_FEATURES.get('AUTOMATIC_VERIFY_STUDENT_IDENTITY_FOR_TESTING'):
+        if settings.FEATURES.get('AUTOMATIC_VERIFY_STUDENT_IDENTITY_FOR_TESTING'):
             fake_response = requests.Response()
             fake_response.status_code = 200
             return fake_response

lms/djangoapps/verify_student/tests/test_views.py

@@ -99,7 +99,7 @@ class TestReverifyView(TestCase):
         self.assertIn('photo_reverification', template)
         self.assertTrue(context['error'])
 
-    @patch.dict(settings.MITX_FEATURES, {'AUTOMATIC_VERIFY_STUDENT_IDENTITY_FOR_TESTING': True})
+    @patch.dict(settings.FEATURES, {'AUTOMATIC_VERIFY_STUDENT_IDENTITY_FOR_TESTING': True})
     def test_reverify_post_success(self):
         url = reverse('verify_student_reverify')
         response = self.client.post(url, {'face_image': ',',

lms/envs/acceptance.py

@@ -93,21 +93,21 @@ BULK_EMAIL_DEFAULT_FROM_EMAIL = "test@test.org"
 
 # Forums are disabled in test.py to speed up unit tests, but we do not have
 # per-test control for acceptance tests
-MITX_FEATURES['ENABLE_DISCUSSION_SERVICE'] = True
+FEATURES['ENABLE_DISCUSSION_SERVICE'] = True
 
 # Use the auto_auth workflow for creating users and logging them in
-MITX_FEATURES['AUTOMATIC_AUTH_FOR_TESTING'] = True
+FEATURES['AUTOMATIC_AUTH_FOR_TESTING'] = True
 
 # Enable fake payment processing page
-MITX_FEATURES['ENABLE_PAYMENT_FAKE'] = True
+FEATURES['ENABLE_PAYMENT_FAKE'] = True
 
 # Enable email on the instructor dash
-MITX_FEATURES['ENABLE_INSTRUCTOR_EMAIL'] = True
-MITX_FEATURES['REQUIRE_COURSE_EMAIL_AUTH'] = False
+FEATURES['ENABLE_INSTRUCTOR_EMAIL'] = True
+FEATURES['REQUIRE_COURSE_EMAIL_AUTH'] = False
 
 # Don't actually send any requests to Software Secure for student identity
 # verification.
-MITX_FEATURES['AUTOMATIC_VERIFY_STUDENT_IDENTITY_FOR_TESTING'] = True
+FEATURES['AUTOMATIC_VERIFY_STUDENT_IDENTITY_FOR_TESTING'] = True
 
 # Configure the payment processor to use the fake processing page
 # Since both the fake payment page and the shoppingcart app are using
@@ -128,7 +128,7 @@ CC_PROCESSOR['CyberSource']['PURCHASE_ENDPOINT'] = "/shoppingcart/payment_fake"
 # We do not yet understand why this occurs. Setting this to true is a stopgap measure
 USE_I18N = True
 
-MITX_FEATURES['ENABLE_FEEDBACK_SUBMISSION'] = True
+FEATURES['ENABLE_FEEDBACK_SUBMISSION'] = True
 FEEDBACK_SUBMISSION_EMAIL = 'dummy@example.com'
 
 # Include the lettuce app for acceptance testing, including the 'harvest' django-admin command

lms/envs/aws.py

@@ -44,7 +44,7 @@ SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
 DEFAULT_FILE_STORAGE = 'storages.backends.s3boto.S3BotoStorage'
 
 # Enable Berkeley forums
-MITX_FEATURES['ENABLE_DISCUSSION_SERVICE'] = True
+FEATURES['ENABLE_DISCUSSION_SERVICE'] = True
 
 # IMPORTANT: With this enabled, the server must always be behind a proxy that
 # strips the header HTTP_X_FORWARDED_PROTO from client requests. Otherwise,
@@ -210,8 +210,9 @@ USE_I18N = ENV_TOKENS.get('USE_I18N', USE_I18N)
 for app in ENV_TOKENS.get('ADDL_INSTALLED_APPS', []):
     INSTALLED_APPS += (app,)
 
-for feature, value in ENV_TOKENS.get('MITX_FEATURES', {}).items():
-    MITX_FEATURES[feature] = value
+ENV_FEATURES = ENV_TOKENS.get('FEATURES', ENV_TOKENS.get('MITX_FEATURES', {}))
+for feature, value in ENV_FEATURES.items():
+    FEATURES[feature] = value
 
 WIKI_ENABLED = ENV_TOKENS.get('WIKI_ENABLED', WIKI_ENABLED)
 local_loglevel = ENV_TOKENS.get('LOCAL_LOGLEVEL', 'INFO')
@@ -258,7 +259,7 @@ with open(CONFIG_ROOT / CONFIG_PREFIX + "auth.json") as auth_file:
 # If Segment.io key specified, load it and enable Segment.io if the feature flag is set
 SEGMENT_IO_LMS_KEY = AUTH_TOKENS.get('SEGMENT_IO_LMS_KEY')
 if SEGMENT_IO_LMS_KEY:
-    MITX_FEATURES['SEGMENT_IO_LMS'] = ENV_TOKENS.get('SEGMENT_IO_LMS', False)
+    FEATURES['SEGMENT_IO_LMS'] = ENV_TOKENS.get('SEGMENT_IO_LMS', False)
 
 CC_PROCESSOR = AUTH_TOKENS.get('CC_PROCESSOR', CC_PROCESSOR)
 

lms/envs/cms/acceptance.py

@@ -20,7 +20,7 @@ MIDDLEWARE_CLASSES = tuple(e for e in MIDDLEWARE_CLASSES \
 
 
 ########################### LETTUCE TESTING ##########################
-MITX_FEATURES['DISPLAY_TOY_COURSES'] = True
+FEATURES['DISPLAY_TOY_COURSES'] = True
 
 INSTALLED_APPS += ('lettuce.django',)
 # INSTALLED_APPS += ('portal',)

lms/envs/cms/dev.py

@@ -8,7 +8,7 @@ Settings for the LMS that runs alongside the CMS on AWS
 
 from ..dev import *
 
-MITX_FEATURES['AUTH_USE_MIT_CERTIFICATES'] = False
+FEATURES['AUTH_USE_MIT_CERTIFICATES'] = False
 
 SUBDOMAIN_BRANDING['edge'] = 'edge'
 SUBDOMAIN_BRANDING['preview.edge'] = 'edge'
@@ -18,7 +18,7 @@ VIRTUAL_UNIVERSITIES = ['edge']
 # modules. Since - for now - those links point to github (for XML based authoring), it seems broken
 # to people using it. Once we can update those links to properly link back to Studio,
 # then we can turn this flag back on, as well as enabling in aws.py configurations.
-MITX_FEATURES['ENABLE_LMS_MIGRATION'] = False
+FEATURES['ENABLE_LMS_MIGRATION'] = False
 
 META_UNIVERSITIES = {}
 

lms/envs/common.py

@@ -2,7 +2,7 @@
 This is the common settings file, intended to set sane defaults. If you have a
 piece of configuration that's dependent on a set of feature flags being set,
 then create a function that returns the calculated value based on the value of
-MITX_FEATURES[...]. Modules that extend this one can change the feature
+FEATURES[...]. Modules that extend this one can change the feature
 configuration in an environment specific config file and re-calculate those
 values.
 
@@ -14,7 +14,7 @@ Longer TODO:
 1. Right now our treatment of static content in general and in particular
    course-specific static content is haphazard.
 2. We should have a more disciplined approach to feature flagging, even if it
-   just means that we stick them in a dict called MITX_FEATURES.
+   just means that we stick them in a dict called FEATURES.
 3. We need to handle configuration for multiple courses. This could be as
    multiple sites, but we do need a way to map their data assets.
 """
@@ -50,7 +50,7 @@ DISCUSSION_SETTINGS = {
 
 
 # Features
-MITX_FEATURES = {
+FEATURES = {
     'SAMPLE': False,
     'USE_DJANGO_PIPELINE': True,
     'DISPLAY_HISTOGRAMS_TO_STAFF': True,
@@ -360,7 +360,7 @@ TRACKING_BACKENDS = {
 
 # Backwards compatibility with ENABLE_SQL_TRACKING_LOGS feature flag.
 # In the future, adding the backend to TRACKING_BACKENDS enough.
-if MITX_FEATURES.get('ENABLE_SQL_TRACKING_LOGS'):
+if FEATURES.get('ENABLE_SQL_TRACKING_LOGS'):
     TRACKING_BACKENDS.update({
         'sql': {
             'ENGINE': 'track.backends.django.DjangoBackend'
@@ -1034,7 +1034,7 @@ def enable_theme(theme_name):
     THEME_NAME = "stanford"
     enable_theme(THEME_NAME)
     """
-    MITX_FEATURES['USE_CUSTOM_THEME'] = True
+    FEATURES['USE_CUSTOM_THEME'] = True
 
     # Calculate the location of the theme's files
     theme_root = ENV_ROOT / "themes" / theme_name
@@ -1055,7 +1055,7 @@ VERIFY_STUDENT = {
 
 ######################## CAS authentication ###########################
 
-if MITX_FEATURES.get('AUTH_USE_CAS'):
+if FEATURES.get('AUTH_USE_CAS'):
     CAS_SERVER_URL = 'https://provide_your_cas_url_here'
     AUTHENTICATION_BACKENDS = (
         'django.contrib.auth.backends.ModelBackend',

lms/envs/dev.py

@@ -24,23 +24,23 @@ LANGUAGES = (
 TEMPLATE_DEBUG = True
 
 
-MITX_FEATURES['DISABLE_START_DATES'] = False
-MITX_FEATURES['ENABLE_SQL_TRACKING_LOGS'] = True
-MITX_FEATURES['SUBDOMAIN_COURSE_LISTINGS'] = False  # Enable to test subdomains--otherwise, want all courses to show up
-MITX_FEATURES['SUBDOMAIN_BRANDING'] = True
-MITX_FEATURES['FORCE_UNIVERSITY_DOMAIN'] = None		# show all university courses if in dev (ie don't use HTTP_HOST)
-MITX_FEATURES['ENABLE_MANUAL_GIT_RELOAD'] = True
-MITX_FEATURES['ENABLE_PSYCHOMETRICS'] = False    # real-time psychometrics (eg item response theory analysis in instructor dashboard)
-MITX_FEATURES['ENABLE_INSTRUCTOR_ANALYTICS'] = True
-MITX_FEATURES['ENABLE_SERVICE_STATUS'] = True
-MITX_FEATURES['ENABLE_INSTRUCTOR_EMAIL'] = True     # Enable email for all Studio courses
-MITX_FEATURES['REQUIRE_COURSE_EMAIL_AUTH'] = False  # Give all courses email (don't require django-admin perms)
-MITX_FEATURES['ENABLE_HINTER_INSTRUCTOR_VIEW'] = True
-MITX_FEATURES['ENABLE_INSTRUCTOR_BETA_DASHBOARD'] = True
-MITX_FEATURES['MULTIPLE_ENROLLMENT_ROLES'] = True
-MITX_FEATURES['ENABLE_SHOPPING_CART'] = True
-MITX_FEATURES['AUTOMATIC_VERIFY_STUDENT_IDENTITY_FOR_TESTING'] = True
-MITX_FEATURES['ENABLE_S3_GRADE_DOWNLOADS'] = True
+FEATURES['DISABLE_START_DATES'] = False
+FEATURES['ENABLE_SQL_TRACKING_LOGS'] = True
+FEATURES['SUBDOMAIN_COURSE_LISTINGS'] = False  # Enable to test subdomains--otherwise, want all courses to show up
+FEATURES['SUBDOMAIN_BRANDING'] = True
+FEATURES['FORCE_UNIVERSITY_DOMAIN'] = None		# show all university courses if in dev (ie don't use HTTP_HOST)
+FEATURES['ENABLE_MANUAL_GIT_RELOAD'] = True
+FEATURES['ENABLE_PSYCHOMETRICS'] = False    # real-time psychometrics (eg item response theory analysis in instructor dashboard)
+FEATURES['ENABLE_INSTRUCTOR_ANALYTICS'] = True
+FEATURES['ENABLE_SERVICE_STATUS'] = True
+FEATURES['ENABLE_INSTRUCTOR_EMAIL'] = True     # Enable email for all Studio courses
+FEATURES['REQUIRE_COURSE_EMAIL_AUTH'] = False  # Give all courses email (don't require django-admin perms)
+FEATURES['ENABLE_HINTER_INSTRUCTOR_VIEW'] = True
+FEATURES['ENABLE_INSTRUCTOR_BETA_DASHBOARD'] = True
+FEATURES['MULTIPLE_ENROLLMENT_ROLES'] = True
+FEATURES['ENABLE_SHOPPING_CART'] = True
+FEATURES['AUTOMATIC_VERIFY_STUDENT_IDENTITY_FOR_TESTING'] = True
+FEATURES['ENABLE_S3_GRADE_DOWNLOADS'] = True
 
 FEEDBACK_SUBMISSION_EMAIL = "dummy@example.com"
 
@@ -174,9 +174,9 @@ OPEN_ENDED_GRADING_INTERFACE = {
 }
 
 ############################## LMS Migration ##################################
-MITX_FEATURES['ENABLE_LMS_MIGRATION'] = True
-MITX_FEATURES['ACCESS_REQUIRE_STAFF_FOR_COURSE'] = False   # require that user be in the staff_* group to be able to enroll
-MITX_FEATURES['USE_XQA_SERVER'] = 'http://xqa:server@content-qa.mitx.mit.edu/xqa'
+FEATURES['ENABLE_LMS_MIGRATION'] = True
+FEATURES['ACCESS_REQUIRE_STAFF_FOR_COURSE'] = False   # require that user be in the staff_* group to be able to enroll
+FEATURES['USE_XQA_SERVER'] = 'http://xqa:server@content-qa.edX.mit.edu/xqa'
 
 INSTALLED_APPS += ('lms_migration',)
 
@@ -184,9 +184,9 @@ LMS_MIGRATION_ALLOWED_IPS = ['127.0.0.1']
 
 ################################ OpenID Auth #################################
 
-MITX_FEATURES['AUTH_USE_OPENID'] = True
-MITX_FEATURES['AUTH_USE_OPENID_PROVIDER'] = True
-MITX_FEATURES['BYPASS_ACTIVATION_EMAIL_FOR_EXTAUTH'] = True
+FEATURES['AUTH_USE_OPENID'] = True
+FEATURES['AUTH_USE_OPENID_PROVIDER'] = True
+FEATURES['BYPASS_ACTIVATION_EMAIL_FOR_EXTAUTH'] = True
 
 INSTALLED_APPS += ('external_auth',)
 INSTALLED_APPS += ('django_openid_auth',)
@@ -200,7 +200,7 @@ OPENID_PROVIDER_TRUSTED_ROOTS = ['*']
 
 ######################## MIT Certificates SSL Auth ############################
 
-MITX_FEATURES['AUTH_USE_MIT_CERTIFICATES'] = True
+FEATURES['AUTH_USE_MIT_CERTIFICATES'] = True
 
 ################################# CELERY ######################################
 
@@ -247,8 +247,8 @@ FILE_UPLOAD_HANDLERS = (
     'django.core.files.uploadhandler.TemporaryFileUploadHandler',
 )
 
-MITX_FEATURES['AUTH_USE_SHIB'] = True
-MITX_FEATURES['RESTRICT_ENROLL_BY_REG_METHOD'] = True
+FEATURES['AUTH_USE_SHIB'] = True
+FEATURES['RESTRICT_ENROLL_BY_REG_METHOD'] = True
 
 ########################### PIPELINE #################################
 
@@ -264,7 +264,7 @@ ANALYTICS_API_KEY = ""
 # If there's an environment variable set, grab it and turn on Segment.io
 SEGMENT_IO_LMS_KEY = os.environ.get('SEGMENT_IO_LMS_KEY')
 if SEGMENT_IO_LMS_KEY:
-    MITX_FEATURES['SEGMENT_IO_LMS'] = True
+    FEATURES['SEGMENT_IO_LMS'] = True
 
 ###################### Payment ##############################3
 
@@ -279,7 +279,7 @@ EDX_API_KEY = None
 
 
 ####################### Shoppingcart ###########################
-MITX_FEATURES['ENABLE_SHOPPING_CART'] = True
+FEATURES['ENABLE_SHOPPING_CART'] = True
 
 #####################################################################
 # Lastly, see if the developer has any local overrides.

lms/envs/dev_ike.py

@@ -17,28 +17,28 @@ from .dev import *
 import socket
 
 WIKI_ENABLED = False
-MITX_FEATURES['ENABLE_TEXTBOOK'] = False
-MITX_FEATURES['ACCESS_REQUIRE_STAFF_FOR_COURSE'] = True	  # require that user be in the staff_* group to be able to enroll
-MITX_FEATURES['SUBDOMAIN_COURSE_LISTINGS'] = False
-MITX_FEATURES['SUBDOMAIN_BRANDING'] = False
-MITX_FEATURES['FORCE_UNIVERSITY_DOMAIN'] = None		# show all university courses if in dev (ie don't use HTTP_HOST)
+FEATURES['ENABLE_TEXTBOOK'] = False
+FEATURES['ACCESS_REQUIRE_STAFF_FOR_COURSE'] = True	  # require that user be in the staff_* group to be able to enroll
+FEATURES['SUBDOMAIN_COURSE_LISTINGS'] = False
+FEATURES['SUBDOMAIN_BRANDING'] = False
+FEATURES['FORCE_UNIVERSITY_DOMAIN'] = None		# show all university courses if in dev (ie don't use HTTP_HOST)
 
-MITX_FEATURES['DISABLE_START_DATES'] = True
-# MITX_FEATURES['USE_DJANGO_PIPELINE']=False      # don't recompile scss
+FEATURES['DISABLE_START_DATES'] = True
+# FEATURES['USE_DJANGO_PIPELINE']=False      # don't recompile scss
 
 myhost = socket.gethostname()
 if ('edxvm' in myhost) or ('ocw' in myhost):
-    MITX_FEATURES['DISABLE_LOGIN_BUTTON'] = True  	# auto-login with MIT certificate
-    MITX_FEATURES['USE_XQA_SERVER'] = 'https://qisx.mit.edu/xqa'  	# needs to be ssl or browser blocks it
-    MITX_FEATURES['USE_DJANGO_PIPELINE'] = False      # don't recompile scss
+    FEATURES['DISABLE_LOGIN_BUTTON'] = True  	# auto-login with MIT certificate
+    FEATURES['USE_XQA_SERVER'] = 'https://qisx.mit.edu/xqa'  	# needs to be ssl or browser blocks it
+    FEATURES['USE_DJANGO_PIPELINE'] = False      # don't recompile scss
 
 if ('ocw' in myhost):
-    MITX_FEATURES['ACCESS_REQUIRE_STAFF_FOR_COURSE'] = False
+    FEATURES['ACCESS_REQUIRE_STAFF_FOR_COURSE'] = False
 
 if ('domU' in myhost):
     EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
-    MITX_FEATURES['REROUTE_ACTIVATION_EMAIL'] = 'ichuang@mitx.mit.edu'  	# nonempty string = address for all activation emails
-    MITX_FEATURES['USE_DJANGO_PIPELINE'] = False      # don't recompile scss
+    FEATURES['REROUTE_ACTIVATION_EMAIL'] = 'ichuang@edX.mit.edu'  	# nonempty string = address for all activation emails
+    FEATURES['USE_DJANGO_PIPELINE'] = False      # don't recompile scss
 
 SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTOCOL', 'https')  	# django 1.4 for nginx ssl proxy
 

lms/envs/dev_int.py

@@ -16,7 +16,7 @@ use *.dev domains instead for local testing.
 
 from .dev import *
 
-MITX_FEATURES['SUBDOMAIN_COURSE_LISTINGS'] = True
+FEATURES['SUBDOMAIN_COURSE_LISTINGS'] = True
 
 COURSE_LISTINGS = {
     'default': ['BerkeleyX/CS169.1x/2012_Fall',

lms/envs/devstack.py

@@ -23,8 +23,8 @@ for pkg_name in ['track.contexts', 'track.middleware', 'dd.dogapi']:
 ################################ EMAIL ########################################
 
 EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
-MITX_FEATURES['ENABLE_INSTRUCTOR_EMAIL'] = True     # Enable email for all Studio courses
-MITX_FEATURES['REQUIRE_COURSE_EMAIL_AUTH'] = False  # Give all courses email (don't require django-admin perms)
+FEATURES['ENABLE_INSTRUCTOR_EMAIL'] = True     # Enable email for all Studio courses
+FEATURES['REQUIRE_COURSE_EMAIL_AUTH'] = False  # Give all courses email (don't require django-admin perms)
 
 
 ################################ DEBUG TOOLBAR ################################

lms/envs/test.py

@@ -21,20 +21,20 @@ os.environ['DJANGO_LIVE_TEST_SERVER_ADDRESS'] = 'localhost:8000-9000'
 
 # can't test start dates with this True, but on the other hand,
 # can test everything else :)
-MITX_FEATURES['DISABLE_START_DATES'] = True
+FEATURES['DISABLE_START_DATES'] = True
 
 # Most tests don't use the discussion service, so we turn it off to speed them up.
 # Tests that do can enable this flag, but must use the UrlResetMixin class to force urls.py
 # to reload
-MITX_FEATURES['ENABLE_DISCUSSION_SERVICE'] = False
+FEATURES['ENABLE_DISCUSSION_SERVICE'] = False
 
-MITX_FEATURES['ENABLE_SERVICE_STATUS'] = True
+FEATURES['ENABLE_SERVICE_STATUS'] = True
 
-MITX_FEATURES['ENABLE_HINTER_INSTRUCTOR_VIEW'] = True
+FEATURES['ENABLE_HINTER_INSTRUCTOR_VIEW'] = True
 
-MITX_FEATURES['ENABLE_INSTRUCTOR_BETA_DASHBOARD'] = True
+FEATURES['ENABLE_INSTRUCTOR_BETA_DASHBOARD'] = True
 
-MITX_FEATURES['ENABLE_SHOPPING_CART'] = True
+FEATURES['ENABLE_SHOPPING_CART'] = True
 
 # Need wiki for courseware views to work. TODO (vshnayder): shouldn't need it.
 WIKI_ENABLED = True
@@ -171,13 +171,13 @@ SECRET_KEY = '85920908f28904ed733fe576320db18cabd7b6cd'
 filterwarnings('ignore', message='No request passed to the backend, unable to rate-limit')
 
 ################################## OPENID #####################################
-MITX_FEATURES['AUTH_USE_OPENID'] = True
-MITX_FEATURES['AUTH_USE_OPENID_PROVIDER'] = True
+FEATURES['AUTH_USE_OPENID'] = True
+FEATURES['AUTH_USE_OPENID_PROVIDER'] = True
 
 ################################## SHIB #######################################
-MITX_FEATURES['AUTH_USE_SHIB'] = True
-MITX_FEATURES['SHIB_DISABLE_TOS'] = True
-MITX_FEATURES['RESTRICT_ENROLL_BY_REG_METHOD'] = True
+FEATURES['AUTH_USE_SHIB'] = True
+FEATURES['SHIB_DISABLE_TOS'] = True
+FEATURES['RESTRICT_ENROLL_BY_REG_METHOD'] = True
 
 OPENID_CREATE_USERS = False
 OPENID_UPDATE_DETAILS_FROM_SREG = True
@@ -186,7 +186,7 @@ OPENID_PROVIDER_TRUSTED_ROOTS = ['*']
 
 ###################### Payment ##############################3
 # Enable fake payment processing page
-MITX_FEATURES['ENABLE_PAYMENT_FAKE'] = True
+FEATURES['ENABLE_PAYMENT_FAKE'] = True
 # Configure the payment processor to use the fake processing page
 # Since both the fake payment page and the shoppingcart app are using
 # the same settings, we can generate this randomly and guarantee

lms/templates/courseware/course_about.html

@@ -5,7 +5,7 @@
   from courseware.access import has_access
   from django.conf import settings
 
-  if settings.MITX_FEATURES.get('ENABLE_SHOPPING_CART'):
+  if settings.FEATURES.get('ENABLE_SHOPPING_CART'):
       cart_link = reverse('shoppingcart.views.show_cart')
   else:
       cart_link = ""
@@ -31,7 +31,7 @@
       event.preventDefault();
     });
 
-    % if settings.MITX_FEATURES.get('ENABLE_SHOPPING_CART') and settings.MITX_FEATURES.get('ENABLE_PAID_COURSE_REGISTRATION'):
+    % if settings.FEATURES.get('ENABLE_SHOPPING_CART') and settings.FEATURES.get('ENABLE_PAID_COURSE_REGISTRATION'):
       add_course_complete_handler = function(jqXHR, textStatus) {
         if (jqXHR.status == 200) {
           location.href = "${cart_link}";
@@ -57,7 +57,7 @@
     % endif
 
     ## making the conditional around this entire JS block for sanity
-    %if settings.MITX_FEATURES.get('RESTRICT_ENROLL_BY_REG_METHOD') and course.enrollment_domain:
+    %if settings.FEATURES.get('RESTRICT_ENROLL_BY_REG_METHOD') and course.enrollment_domain:
     $('#class_enroll_form').on('ajax:complete', function(event, xhr) {
       if(xhr.status == 200) {
         location.href = "${reverse('dashboard')}";
@@ -135,7 +135,7 @@
           <span class="add-to-cart">
             ${_('This course is in your <a href="{cart_link}">cart</a>.').format(cart_link=cart_link)}
           </span>
-        %elif settings.MITX_FEATURES.get('ENABLE_PAID_COURSE_REGISTRATION') and registration_price:
+        %elif settings.FEATURES.get('ENABLE_PAID_COURSE_REGISTRATION') and registration_price:
           <%
           if user.is_authenticated():
             reg_href = "#"

lms/templates/courseware/instructor_dashboard.html

@@ -113,7 +113,7 @@ function goto( mode)
 <section class="container">
 <div class="instructor-dashboard-wrapper">
 
-  %if settings.MITX_FEATURES.get('ENABLE_INSTRUCTOR_BETA_DASHBOARD'):
+  %if settings.FEATURES.get('ENABLE_INSTRUCTOR_BETA_DASHBOARD'):
     <div class="beta-button-wrapper"><a href="${ beta_dashboard_url }">${_("Try New Beta Dashboard")}</a></div>
   %endif
   %if studio_url:
@@ -126,7 +126,7 @@ function goto( mode)
     <h1>${_("Instructor Dashboard")}</h1>
 
     <h2 class="navbar">[ <a href="#" onclick="goto('Grades');" class="${modeflag.get('Grades')}">Grades</a> |
-          %if settings.MITX_FEATURES.get('ENABLE_PSYCHOMETRICS'):
+          %if settings.FEATURES.get('ENABLE_PSYCHOMETRICS'):
             <a href="#" onclick="goto('Psychometrics');" class="${modeflag.get('Psychometrics')}">${_("Psychometrics")}</a> |
           %endif
           <a href="#" onclick="goto('Admin');" class="${modeflag.get('Admin')}">${_("Admin")}</a> |
@@ -137,7 +137,7 @@ function goto( mode)
           %if show_email_tab:
              | <a href="#" onclick="goto('Email')" class="${modeflag.get('Email')}">${_("Email")}</a>
           %endif
-          %if settings.MITX_FEATURES.get('ENABLE_INSTRUCTOR_ANALYTICS'):
+          %if settings.FEATURES.get('ENABLE_INSTRUCTOR_ANALYTICS'):
              | <a href="#" onclick="goto('Analytics');" class="${modeflag.get('Analytics')}">${_("Analytics")}</a>
           %endif
 	  ]
@@ -172,7 +172,7 @@ function goto( mode)
               "with more than {max_enrollment} students. We are urgently working on "
               "fixing this issue. Thank you for your patience as we continue "
               "working to improve the platform!").format(
-              max_enrollment=settings.MITX_FEATURES['MAX_ENROLLMENT_INSTR_BUTTONS']
+              max_enrollment=settings.FEATURES['MAX_ENROLLMENT_INSTR_BUTTONS']
             )}
         </p>
       </div>
@@ -207,7 +207,7 @@ function goto( mode)
     </p>
     <hr width="40%" style="align:left">
 
-  %if settings.MITX_FEATURES.get('REMOTE_GRADEBOOK_URL','') and instructor_access:
+  %if settings.FEATURES.get('REMOTE_GRADEBOOK_URL','') and instructor_access:
 
     <%
         rg = course.remote_gradebook
@@ -240,7 +240,7 @@ function goto( mode)
     <hr width="40%" style="align:left">
 
   %endif
-  %if settings.MITX_FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
+  %if settings.FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
     <H2>${_("Course-specific grade adjustment")}</h2>
 
     <p>
@@ -292,7 +292,7 @@ function goto( mode)
     <p>
       ${_("Then select an action:")}
       <input type="submit" name="action" value="Reset student's attempts">
-      %if settings.MITX_FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
+      %if settings.FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
       <input type="submit" name="action" value="Rescore student's problem submission">
       %endif
     </p>
@@ -303,7 +303,7 @@ function goto( mode)
       <input type="submit" name="action" value="Delete student state for module">
     </p>
     %endif
-    %if settings.MITX_FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
+    %if settings.FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
     <p>${_("Rescoring runs in the background, and status for active tasks will appear in a table below. "
            "To see status for all tasks submitted for this problem and student, click on this button:")}
     </p>
@@ -359,7 +359,7 @@ function goto( mode)
     <hr width="40%" style="align:left">
   %endif
 
-  %if settings.MITX_FEATURES['ENABLE_MANUAL_GIT_RELOAD'] and admin_access:
+  %if settings.FEATURES['ENABLE_MANUAL_GIT_RELOAD'] and admin_access:
     <p>
     <input type="submit" name="action" value="Reload course from XML files">
     <input type="submit" name="action" value="GIT pull and Reload course">
@@ -409,7 +409,7 @@ function goto( mode)
               "with more than {max_enrollment} students. We are urgently working on "
               "fixing this issue. Thank you for your patience as we continue "
               "working to improve the platform!").format(
-              max_enrollment=settings.MITX_FEATURES['MAX_ENROLLMENT_INSTR_BUTTONS']
+              max_enrollment=settings.FEATURES['MAX_ENROLLMENT_INSTR_BUTTONS']
             )}
         </p>
       </div>
@@ -420,7 +420,7 @@ function goto( mode)
     <input type="submit" name="action" value="List students who may enroll but may not have yet signed up" class="${'is-disabled' if disable_buttons else ''}">
     <hr width="40%" style="align:left">
 
-  %if settings.MITX_FEATURES.get('REMOTE_GRADEBOOK_URL','') and instructor_access:
+  %if settings.FEATURES.get('REMOTE_GRADEBOOK_URL','') and instructor_access:
 
     <%
         rg = course.remote_gradebook

lms/templates/dashboard.html

@@ -197,7 +197,7 @@
       </ul>
     % else:
       <section class="empty-dashboard-message">
-        % if settings.MITX_FEATURES.get('COURSES_ARE_BROWSABLE'):
+        % if settings.FEATURES.get('COURSES_ARE_BROWSABLE'):
           <p>${_("Looks like you haven't registered for any courses yet.")}</p>
           <a href="${marketing_link('COURSES')}">
             ${_("Find courses now!")}

lms/templates/discussion/_underscore_templates.html

@@ -185,7 +185,7 @@
   <h1 class="home-title">${course.display_name_with_default}</h1>
   </section>
 
-  % if settings.MITX_FEATURES.get('ENABLE_DISCUSSION_HOME_PANEL'):
+  % if settings.FEATURES.get('ENABLE_DISCUSSION_HOME_PANEL'):
   <span class="label label-settings">HOW TO USE EDX DISCUSSIONS</span>
   <table class="home-helpgrid">
   <tr class="helpgrid-row helpgrid-row-navigation">

lms/templates/help_modal.html

@@ -6,7 +6,7 @@
 <%! from django.conf import settings %>
 <%! from courseware.tabs import get_discussion_link %>
 
-% if settings.MITX_FEATURES.get('ENABLE_FEEDBACK_SUBMISSION', False):
+% if settings.FEATURES.get('ENABLE_FEEDBACK_SUBMISSION', False):
 
 <div class="help-tab">
   <a href="#help-modal" rel="leanModal" role="button">${_("Help")}</a>

lms/templates/index.html

@@ -165,7 +165,7 @@
         </section>
       % endif
 
-      % if settings.MITX_FEATURES.get('COURSES_ARE_BROWSABLE'):
+      % if settings.FEATURES.get('COURSES_ARE_BROWSABLE'):
         <section class="courses">
             <ul class="courses-listing">
             %for course in courses:

lms/templates/instructor/instructor_dashboard_2/course_info.html

@@ -58,7 +58,7 @@
 </div>
 
 
-%if settings.MITX_FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
+%if settings.FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
   <div class="running-tasks-container action-type-container">
     <hr>
     <h2> ${_("Pending Instructor Tasks")} </h2>

lms/templates/instructor/instructor_dashboard_2/data_download.html

@@ -23,12 +23,12 @@
   <p><input type="button" name="list-anon-ids" value="${_("Get Student Anonymized IDs CSV")}" data-csv="true" class="csv" data-endpoint="${ section_data['get_anon_ids_url'] }" class="${'is-disabled' if disable_buttons else ''}"></p>
 </div>
 
-%if settings.MITX_FEATURES.get('ENABLE_S3_GRADE_DOWNLOADS'):
+%if settings.FEATURES.get('ENABLE_S3_GRADE_DOWNLOADS'):
   <div class="grades-download-container action-type-container">
     <hr>
     <h2> ${_("Grade Reports")}</h2>
 
-  %if settings.MITX_FEATURES.get('ALLOW_COURSE_STAFF_GRADE_DOWNLOADS') or section_data['access']['admin']:
+  %if settings.FEATURES.get('ALLOW_COURSE_STAFF_GRADE_DOWNLOADS') or section_data['access']['admin']:
     <p>${_("The following button will generate a CSV grade report for all currently enrolled students. For large courses, generating this report may take a few hours.")}</p>
 
     <p>${_("The report is generated in the background, meaning it is OK to navigate away from this page while your report is generating. Generated reports appear in a table below and can be downloaded.")}</p>
@@ -46,7 +46,7 @@
   </div>
 %endif
 
-%if settings.MITX_FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
+%if settings.FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
   <div class="running-tasks-container action-type-container">
     <hr>
     <h2> ${_("Pending Instructor Tasks")} </h2>

lms/templates/instructor/instructor_dashboard_2/send_email.html

@@ -55,7 +55,7 @@
   <input type="button" name="send" value="${_("Send Email")}" data-endpoint="${ section_data['send_email'] }" >
   <div class="request-response-error"></div>
 
-%if settings.MITX_FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
+%if settings.FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
   <div class="running-tasks-container action-type-container">
     <hr>
     <h2> ${_("Pending Instructor Tasks")} </h2>

lms/templates/instructor/instructor_dashboard_2/student_admin.html

@@ -50,7 +50,7 @@
   <p>
   <input type="button" name="reset-attempts-single" value="${_("Reset Student Attempts")}" data-endpoint="${ section_data['reset_student_attempts_url'] }">
 
-  %if settings.MITX_FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS') and section_data['access']['instructor']:
+  %if settings.FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS') and section_data['access']['instructor']:
     <input type="button" name="rescore-problem-single" value="${_("Rescore Student Submission")}" data-endpoint="${ section_data['rescore_problem_url'] }">
   %endif
   </p>
@@ -63,7 +63,7 @@
   </p>
 
 
-  %if settings.MITX_FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS') and section_data['access']['instructor']:
+  %if settings.FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS') and section_data['access']['instructor']:
     <p>
       ${_("Rescoring runs in the background, and status for active tasks will appear in the 'Pending Instructor Tasks' table. "
       "To see status for all tasks submitted for this problem and student, click on this button:")}
@@ -75,7 +75,7 @@
   <hr>
 </div>
 
-%if settings.MITX_FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS') and section_data['access']['instructor']:
+%if settings.FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS') and section_data['access']['instructor']:
   <div class="course-specific-container action-type-container">
     <h2>${_('Course-specific grade adjustment')}</h2>
     <div class="request-response-error"></div>
@@ -108,7 +108,7 @@
   </div>
 %endif
 
-%if settings.MITX_FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
+%if settings.FEATURES.get('ENABLE_INSTRUCTOR_BACKGROUND_TASKS'):
   <div class="running-tasks-container action-type-container">
     <hr>
     <h2> ${_("Pending Instructor Tasks")} </h2>

lms/templates/login.html

@@ -170,7 +170,7 @@
       <h2 class="sr">${_("Helpful Information")}</h2>
     </header>
 
-    % if settings.MITX_FEATURES.get('AUTH_USE_OPENID'):
+    % if settings.FEATURES.get('AUTH_USE_OPENID'):
     <!-- <div class="cta cta-login-options-openid">
       <h3>${_("Login via OpenID")}</h3>
       <p>${_('You can now start learning with {platform_name} by logging in with your <a rel="external" href="http://openid.net/">OpenID account</a>.').format(platform_name=settings.PLATFORM_NAME)}</p>

lms/templates/login_modal.html

@@ -34,7 +34,7 @@
         <span>${_('Not enrolled?')} <a href="#signup-modal" class="close-login" rel="leanModal">${_('Sign up.')}</a></span>
         <a href="#forgot-password-modal" rel="leanModal" class="pwd-reset">${_('Forgot password?')}</a>
       </p>
-% if settings.MITX_FEATURES.get('AUTH_USE_OPENID'):
+% if settings.FEATURES.get('AUTH_USE_OPENID'):
       <p>
       <a href="${MITX_ROOT_URL}/openid/login/">${_('login via openid')}</a>
       </p>