79cd0b1ef8
* feat: Adds discussions settings for new discusions experience This commit adds new discussions settings for the new discussions experience. These are stored in the course so they can be a part of course import/export flow. These are also added to the discussions configuraiton API to allow MFEs to update the settings. The discussions API is currently available via LMS, however that means it cannot save changes to the modulestore. This also adds the API to the studio config so it can now also be accessed from studio and be used to save course settings. * fix: tests
513 lines
18 KiB
Python
513 lines
18 KiB
Python
"""
|
|
Provide django models to back the discussions app
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from collections import namedtuple
|
|
from typing import List, Type, TypeVar
|
|
|
|
from django.conf import settings
|
|
from django.core.exceptions import ValidationError
|
|
from django.db import models
|
|
from django.utils.translation import gettext_lazy as _
|
|
from django_mysql.models import ListCharField
|
|
from enum import Enum
|
|
from jsonfield import JSONField
|
|
from lti_consumer.models import LtiConfiguration
|
|
from model_utils.models import TimeStampedModel
|
|
from opaque_keys.edx.django.models import LearningContextKeyField
|
|
from opaque_keys.edx.keys import CourseKey
|
|
from simple_history.models import HistoricalRecords
|
|
|
|
from openedx.core.djangoapps.config_model_utils.models import StackedConfigurationModel
|
|
from openedx.core.djangoapps.content.course_overviews.models import CourseOverview
|
|
from openedx.core.djangoapps.site_configuration import helpers as configuration_helpers
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
DEFAULT_PROVIDER_TYPE = 'legacy'
|
|
DEFAULT_CONFIG_ENABLED = True
|
|
|
|
ProviderExternalLinks = namedtuple(
|
|
'ProviderExternalLinks',
|
|
['learn_more', 'configuration', 'general', 'accessibility', 'contact_email']
|
|
)
|
|
|
|
|
|
class Features(Enum):
|
|
"""
|
|
Features to be used/mapped in discussion providers
|
|
"""
|
|
|
|
# Basic Supported Features
|
|
PRIMARY_DISCUSSION_APP_EXPERIENCE = ('primary-discussion-app-experience', 'basic')
|
|
BASIC_CONFIGURATION = ('basic-configuration', 'basic')
|
|
# DISCUSSION_PAGE = ('discussion-page', 'basic')
|
|
|
|
# Partially Supported Features
|
|
QUESTION_DISCUSSION_SUPPORT = ('question-discussion-support', 'partial')
|
|
COMMUNITY_TA_SUPPORT = ('community-ta-support', 'partial')
|
|
REPORT_FLAG_CONTENT_TO_MODERATORS = ('report/flag-content-to-moderators', 'partial')
|
|
LTI_ADVANCED_SHARING_MODE = ('lti-advanced-sharing-mode', 'partial')
|
|
AUTOMATIC_LEARNER_ENROLLMENT = ('automatic-learner-enrollment', 'partial')
|
|
ANONYMOUS_POSTING = ('anonymous-posting', 'partial')
|
|
INTERNATIONALIZATION_SUPPORT = ('internationalization-support', 'partial')
|
|
EMAIL_NOTIFICATIONS = ('email-notifications', 'partial')
|
|
WCAG_2_0_SUPPORT = ('wcag-2.0-support', 'partial')
|
|
BLACKOUT_DISCUSSION_DATES = ('blackout-discussion-dates', 'partial')
|
|
# WCAG_2_1 = ('wcag-2.1', 'partial')
|
|
# EMBEDDED_COURSE_SECTIONS = ('embedded-course-sections', 'basic')
|
|
|
|
# Fully Supported Features
|
|
COURSE_COHORT_SUPPORT = ('course-cohort-support', 'full')
|
|
RESEARCH_DATA_EVENTS = ('research-data-events', 'full')
|
|
|
|
# Commonly Requested Features
|
|
IN_PLATFORM_NOTIFICATIONS = ('in-platform-notifications', 'common')
|
|
DISCUSSION_CONTENT_PROMPTS = ('discussion-content-prompts', 'common')
|
|
GRADED_DISCUSSIONS = ('graded-discussions', 'common')
|
|
DIRECT_MESSAGES_FROM_INSTRUCTORS = ('direct-messages-from-instructors', 'common')
|
|
USER_MENTIONS = ('user-mentions', 'common')
|
|
|
|
def __init__(self, feature_id, feature_support_type):
|
|
self.feature_id = feature_id
|
|
self.feature_support_type = feature_support_type
|
|
|
|
@property
|
|
def value(self): # pylint: disable=invalid-overridden-method
|
|
return self.feature_id
|
|
|
|
@property
|
|
def support(self):
|
|
return self.feature_support_type
|
|
|
|
|
|
def pii_sharing_required_message(provider_name):
|
|
"""
|
|
Build an i18n'ed message stating PII sharing is required for the provider.
|
|
"""
|
|
return _(
|
|
'{provider} requires that LTI advanced sharing be enabled for your course,'
|
|
' as this provider uses email address and username to personalize'
|
|
' the experience. Please contact {support_contact} to enable this feature.'
|
|
).format(
|
|
provider=provider_name,
|
|
support_contact=(
|
|
configuration_helpers.get_value(
|
|
'CONTACT_EMAIL',
|
|
getattr(settings, 'CONTACT_EMAIL', _('technical support'))
|
|
)
|
|
)
|
|
)
|
|
|
|
|
|
AVAILABLE_PROVIDER_MAP = {
|
|
'legacy': {
|
|
'features': [
|
|
Features.BASIC_CONFIGURATION.value,
|
|
Features.PRIMARY_DISCUSSION_APP_EXPERIENCE.value,
|
|
Features.QUESTION_DISCUSSION_SUPPORT.value,
|
|
Features.COMMUNITY_TA_SUPPORT.value,
|
|
Features.REPORT_FLAG_CONTENT_TO_MODERATORS.value,
|
|
Features.AUTOMATIC_LEARNER_ENROLLMENT.value,
|
|
Features.ANONYMOUS_POSTING.value,
|
|
Features.INTERNATIONALIZATION_SUPPORT.value,
|
|
Features.WCAG_2_0_SUPPORT.value,
|
|
Features.BLACKOUT_DISCUSSION_DATES.value,
|
|
Features.COURSE_COHORT_SUPPORT.value,
|
|
Features.RESEARCH_DATA_EVENTS.value,
|
|
],
|
|
'external_links': ProviderExternalLinks(
|
|
learn_more='',
|
|
configuration='',
|
|
general='',
|
|
accessibility='',
|
|
contact_email='',
|
|
)._asdict(),
|
|
'messages': [],
|
|
'has_full_support': True
|
|
},
|
|
'ed-discuss': {
|
|
'features': [
|
|
Features.PRIMARY_DISCUSSION_APP_EXPERIENCE.value,
|
|
Features.BASIC_CONFIGURATION.value,
|
|
Features.QUESTION_DISCUSSION_SUPPORT.value,
|
|
Features.REPORT_FLAG_CONTENT_TO_MODERATORS.value,
|
|
Features.LTI_ADVANCED_SHARING_MODE.value,
|
|
Features.AUTOMATIC_LEARNER_ENROLLMENT.value,
|
|
Features.ANONYMOUS_POSTING.value,
|
|
Features.INTERNATIONALIZATION_SUPPORT.value,
|
|
Features.EMAIL_NOTIFICATIONS.value,
|
|
Features.WCAG_2_0_SUPPORT.value,
|
|
Features.BLACKOUT_DISCUSSION_DATES.value,
|
|
Features.IN_PLATFORM_NOTIFICATIONS.value,
|
|
Features.USER_MENTIONS.value,
|
|
],
|
|
'external_links': ProviderExternalLinks(
|
|
learn_more='',
|
|
configuration='',
|
|
general='https://edstem.org/us/',
|
|
accessibility='',
|
|
contact_email='',
|
|
)._asdict(),
|
|
'messages': [],
|
|
'has_full_support': False
|
|
},
|
|
'inscribe': {
|
|
'features': [
|
|
Features.PRIMARY_DISCUSSION_APP_EXPERIENCE.value,
|
|
Features.BASIC_CONFIGURATION.value,
|
|
Features.QUESTION_DISCUSSION_SUPPORT.value,
|
|
Features.COMMUNITY_TA_SUPPORT.value,
|
|
Features.REPORT_FLAG_CONTENT_TO_MODERATORS.value,
|
|
Features.LTI_ADVANCED_SHARING_MODE.value,
|
|
Features.AUTOMATIC_LEARNER_ENROLLMENT.value,
|
|
Features.ANONYMOUS_POSTING.value,
|
|
Features.INTERNATIONALIZATION_SUPPORT.value,
|
|
Features.EMAIL_NOTIFICATIONS.value,
|
|
Features.WCAG_2_0_SUPPORT.value,
|
|
Features.RESEARCH_DATA_EVENTS.value,
|
|
Features.IN_PLATFORM_NOTIFICATIONS.value,
|
|
Features.DISCUSSION_CONTENT_PROMPTS.value,
|
|
],
|
|
'external_links': ProviderExternalLinks(
|
|
learn_more='',
|
|
configuration='',
|
|
general='https://www.inscribeapp.com/',
|
|
accessibility='',
|
|
contact_email='',
|
|
)._asdict(),
|
|
'messages': [pii_sharing_required_message('InScribe')],
|
|
'has_full_support': False
|
|
},
|
|
'piazza': {
|
|
'features': [
|
|
Features.PRIMARY_DISCUSSION_APP_EXPERIENCE.value,
|
|
Features.BASIC_CONFIGURATION.value,
|
|
Features.QUESTION_DISCUSSION_SUPPORT.value,
|
|
Features.COMMUNITY_TA_SUPPORT.value,
|
|
Features.REPORT_FLAG_CONTENT_TO_MODERATORS.value,
|
|
Features.LTI_ADVANCED_SHARING_MODE.value,
|
|
Features.ANONYMOUS_POSTING.value,
|
|
Features.EMAIL_NOTIFICATIONS.value,
|
|
Features.WCAG_2_0_SUPPORT.value,
|
|
Features.BLACKOUT_DISCUSSION_DATES.value,
|
|
],
|
|
'external_links': ProviderExternalLinks(
|
|
learn_more='https://piazza.com/product/overview',
|
|
configuration='https://support.piazza.com/support/solutions/articles/48001065447-configure-piazza-within-edx', # pylint: disable=line-too-long
|
|
general='https://support.piazza.com/',
|
|
accessibility='https://piazza.com/product/accessibility',
|
|
contact_email='team@piazza.com',
|
|
)._asdict(),
|
|
'messages': [],
|
|
'has_full_support': False
|
|
},
|
|
'yellowdig': {
|
|
'features': [
|
|
Features.PRIMARY_DISCUSSION_APP_EXPERIENCE.value,
|
|
Features.BASIC_CONFIGURATION.value,
|
|
Features.QUESTION_DISCUSSION_SUPPORT.value,
|
|
Features.COMMUNITY_TA_SUPPORT.value,
|
|
Features.REPORT_FLAG_CONTENT_TO_MODERATORS.value,
|
|
Features.EMAIL_NOTIFICATIONS.value,
|
|
Features.WCAG_2_0_SUPPORT.value,
|
|
Features.RESEARCH_DATA_EVENTS.value,
|
|
Features.IN_PLATFORM_NOTIFICATIONS.value,
|
|
Features.GRADED_DISCUSSIONS.value,
|
|
Features.DIRECT_MESSAGES_FROM_INSTRUCTORS.value,
|
|
Features.USER_MENTIONS.value,
|
|
],
|
|
'external_links': ProviderExternalLinks(
|
|
learn_more='https://www.youtube.com/watch?v=ZACief-qMwY',
|
|
configuration='',
|
|
general='https://hubs.ly/H0J5Bn70',
|
|
accessibility='',
|
|
contact_email='learnmore@yellowdig.com',
|
|
)._asdict(),
|
|
'messages': [pii_sharing_required_message('Yellowdig')],
|
|
'has_full_support': False,
|
|
'admin_only_config': True,
|
|
},
|
|
}
|
|
|
|
|
|
def get_supported_providers() -> List[str]:
|
|
"""
|
|
Return the list of supported discussion providers
|
|
|
|
TODO: Load this from entry points?
|
|
"""
|
|
|
|
return list(AVAILABLE_PROVIDER_MAP.keys())
|
|
|
|
|
|
class ProviderFilter(StackedConfigurationModel):
|
|
"""
|
|
Associate allow/deny-lists of discussions providers with courses/orgs
|
|
"""
|
|
|
|
allow = ListCharField(
|
|
base_field=models.CharField(
|
|
choices=[
|
|
(provider, provider)
|
|
for provider in get_supported_providers()
|
|
],
|
|
max_length=20,
|
|
),
|
|
blank=True,
|
|
help_text=_("Comma-separated list of providers to allow, eg: {choices}").format(
|
|
choices=','.join(get_supported_providers()),
|
|
),
|
|
# max_length = (size * (max_length + len(','))
|
|
# max_length = ( 3 * ( 20 + 1))
|
|
max_length=63,
|
|
# size = len(get_supported_providers())
|
|
size=3,
|
|
verbose_name=_('Allow List'),
|
|
)
|
|
deny = ListCharField(
|
|
base_field=models.CharField(
|
|
choices=[
|
|
(provider, provider)
|
|
for provider in get_supported_providers()
|
|
],
|
|
max_length=20,
|
|
),
|
|
blank=True,
|
|
help_text=_("Comma-separated list of providers to deny, eg: {choices}").format(
|
|
choices=','.join(get_supported_providers()),
|
|
),
|
|
# max_length = (size * (max_length + len(','))
|
|
# max_length = ( 3 * ( 20 + 1))
|
|
max_length=63,
|
|
# size = len(get_supported_providers())
|
|
size=3,
|
|
verbose_name=_('Deny List'),
|
|
)
|
|
|
|
STACKABLE_FIELDS = (
|
|
'enabled',
|
|
'allow',
|
|
'deny',
|
|
)
|
|
|
|
def __str__(self):
|
|
return 'ProviderFilter(org="{org}", course="{course}", allow={allow}, deny={deny})'.format(
|
|
allow=self.allow,
|
|
course=self.course or '',
|
|
deny=self.deny,
|
|
org=self.org or '',
|
|
)
|
|
|
|
@property
|
|
def available_providers(self) -> List[str]:
|
|
"""
|
|
Return a filtered list of available providers
|
|
"""
|
|
_providers = get_supported_providers()
|
|
if self.allow:
|
|
_providers = [
|
|
provider
|
|
for provider in _providers
|
|
if provider in self.allow
|
|
]
|
|
if self.deny:
|
|
_providers = [
|
|
provider
|
|
for provider in _providers
|
|
if provider not in self.deny
|
|
]
|
|
return _providers
|
|
|
|
@classmethod
|
|
def get_available_providers(cls, course_key: CourseKey) -> List[str]:
|
|
_filter = cls.current(course_key=course_key)
|
|
providers = _filter.available_providers
|
|
return providers
|
|
|
|
|
|
T = TypeVar('T', bound='DiscussionsConfiguration')
|
|
|
|
|
|
class DiscussionsConfiguration(TimeStampedModel):
|
|
"""
|
|
Associates a learning context with discussion provider and configuration
|
|
"""
|
|
|
|
context_key = LearningContextKeyField(
|
|
primary_key=True,
|
|
db_index=True,
|
|
unique=True,
|
|
max_length=255,
|
|
# Translators: A key specifying a course, library, program,
|
|
# website, or some other collection of content where learning
|
|
# happens.
|
|
verbose_name=_("Learning Context Key"),
|
|
)
|
|
enabled = models.BooleanField(
|
|
default=True,
|
|
help_text=_("If disabled, the discussions in the associated learning context/course will be disabled.")
|
|
)
|
|
lti_configuration = models.ForeignKey(
|
|
LtiConfiguration,
|
|
on_delete=models.SET_NULL,
|
|
blank=True,
|
|
null=True,
|
|
help_text=_("The LTI configuration data for this context/provider."),
|
|
)
|
|
enable_in_context = models.BooleanField(
|
|
default=True,
|
|
help_text=_(
|
|
"If enabled, discussion topics will be created for each non-graded unit in the course. "
|
|
"A UI for discussions will show up with each unit."
|
|
)
|
|
)
|
|
enable_graded_units = models.BooleanField(
|
|
default=False,
|
|
help_text=_("If enabled, discussion topics will be created for graded units as well.")
|
|
)
|
|
unit_level_visibility = models.BooleanField(
|
|
default=False,
|
|
help_text=_("If enabled, discussions will need to be manually enabled for each unit.")
|
|
)
|
|
plugin_configuration = JSONField(
|
|
blank=True,
|
|
default={},
|
|
help_text=_("The plugin configuration data for this context/provider."),
|
|
)
|
|
provider_type = models.CharField(
|
|
blank=False,
|
|
max_length=100,
|
|
verbose_name=_("Discussion provider"),
|
|
help_text=_("The discussion tool/provider's id"),
|
|
default=DEFAULT_PROVIDER_TYPE,
|
|
)
|
|
history = HistoricalRecords()
|
|
|
|
def clean(self):
|
|
"""
|
|
Validate the model.
|
|
Currently, this only support courses, this can be extended
|
|
whenever discussions are available in other contexts
|
|
"""
|
|
if not CourseOverview.course_exists(self.context_key):
|
|
raise ValidationError('Context Key should be an existing learning context.')
|
|
|
|
def __str__(self):
|
|
return "DiscussionsConfiguration(context_key='{context_key}', provider='{provider}', enabled={enabled})".format(
|
|
context_key=self.context_key,
|
|
provider=self.provider_type,
|
|
enabled=self.enabled,
|
|
)
|
|
|
|
def supports(self, feature: str) -> bool:
|
|
"""
|
|
Check if the provider supports some feature
|
|
"""
|
|
features = AVAILABLE_PROVIDER_MAP.get(self.provider_type)['features'] or []
|
|
has_support = bool(feature in features)
|
|
return has_support
|
|
|
|
def supports_lti(self) -> bool:
|
|
"""Returns a boolean indicating if the provider supports lti discussion view."""
|
|
return self.provider_type != DEFAULT_PROVIDER_TYPE
|
|
|
|
@classmethod
|
|
def is_enabled(cls, context_key: CourseKey) -> bool:
|
|
"""
|
|
Check if there is an active configuration for a given course key
|
|
|
|
Default to False, if no configuration exists
|
|
"""
|
|
configuration = cls.get(context_key)
|
|
return configuration.enabled
|
|
|
|
@classmethod
|
|
def get(cls: Type[T], context_key: CourseKey) -> T:
|
|
"""
|
|
Lookup a model by context_key
|
|
"""
|
|
try:
|
|
configuration = cls.objects.get(context_key=context_key)
|
|
except cls.DoesNotExist:
|
|
configuration = cls(
|
|
context_key=context_key,
|
|
enabled=DEFAULT_CONFIG_ENABLED,
|
|
provider_type=DEFAULT_PROVIDER_TYPE,
|
|
)
|
|
return configuration
|
|
|
|
@property
|
|
def available_providers(self) -> List[str]:
|
|
return ProviderFilter.current(course_key=self.context_key).available_providers
|
|
|
|
@classmethod
|
|
def get_available_providers(cls, context_key: CourseKey) -> List[str]:
|
|
return ProviderFilter.current(course_key=context_key).available_providers
|
|
|
|
@classmethod
|
|
def lti_discussion_enabled(cls, course_key: CourseKey) -> bool:
|
|
"""
|
|
Checks if LTI discussion is enabled for this course.
|
|
|
|
Arguments:
|
|
course_key: course locator.
|
|
Returns:
|
|
Boolean indicating weather or not this course has lti discussion enabled.
|
|
"""
|
|
discussion_provider = cls.get(course_key)
|
|
return (
|
|
discussion_provider.enabled
|
|
and discussion_provider.supports_lti()
|
|
and discussion_provider.lti_configuration is not None
|
|
)
|
|
|
|
|
|
class ProgramDiscussionsConfiguration(TimeStampedModel):
|
|
"""
|
|
Associates a program with a discussion provider and configuration
|
|
"""
|
|
|
|
program_uuid = models.CharField(
|
|
primary_key=True,
|
|
db_index=True,
|
|
max_length=50,
|
|
verbose_name=_("Program UUID"),
|
|
)
|
|
enabled = models.BooleanField(
|
|
default=True,
|
|
help_text=_("If disabled, the discussions in the associated program will be disabled.")
|
|
)
|
|
lti_configuration = models.ForeignKey(
|
|
LtiConfiguration,
|
|
on_delete=models.SET_NULL,
|
|
blank=True,
|
|
null=True,
|
|
help_text=_("The LTI configuration data for this program/provider."),
|
|
)
|
|
provider_type = models.CharField(
|
|
blank=False,
|
|
max_length=50,
|
|
verbose_name=_("Discussion provider"),
|
|
help_text=_("The discussion provider's id"),
|
|
)
|
|
history = HistoricalRecords()
|
|
|
|
def __str__(self):
|
|
return f"Configuration(uuid='{self.program_uuid}', provider='{self.provider_type}', enabled={self.enabled})"
|
|
|
|
@classmethod
|
|
def is_enabled(cls, program_uuid) -> bool:
|
|
"""
|
|
Check if there is an active configuration for a given program uuid
|
|
|
|
Default to False, if no configuration exists
|
|
"""
|
|
try:
|
|
configuration = cls.objects.get(program_uuid=program_uuid)
|
|
return configuration.enabled
|
|
except cls.DoesNotExist:
|
|
return False
|