_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q256800 | HandleConsentEnrollment.get | validation | def get(self, request, enterprise_uuid, course_id):
"""
Handle the enrollment of enterprise learner in the provided course.
Based on `enterprise_uuid` in URL, the view will decide which
enterprise customer's course enrollment record should be created.
Depending on the value of ... | python | {
"resource": ""
} |
q256801 | CourseEnrollmentView.set_final_prices | validation | def set_final_prices(self, modes, request):
"""
Set the final discounted price on each premium mode.
"""
result = []
for mode in modes:
if mode['premium']:
mode['final_price'] = EcommerceApiClient(request.user).get_course_final_price(
... | python | {
"resource": ""
} |
q256802 | CourseEnrollmentView.get_available_course_modes | validation | def get_available_course_modes(self, request, course_run_id, enterprise_catalog):
"""
Return the available course modes for the course run.
The provided EnterpriseCustomerCatalog is used to filter and order the
course modes returned using the EnterpriseCustomerCatalog's
field "e... | python | {
"resource": ""
} |
q256803 | CourseEnrollmentView.get | validation | def get(self, request, enterprise_uuid, course_id):
"""
Show course track selection page for the enterprise.
Based on `enterprise_uuid` in URL, the view will decide which
enterprise customer's course enrollment page is to use.
Unauthenticated learners will be redirected to ente... | python | {
"resource": ""
} |
q256804 | ProgramEnrollmentView.extend_course | validation | def extend_course(course, enterprise_customer, request):
"""
Extend a course with more details needed for the program landing page.
In particular, we add the following:
* `course_image_uri`
* `course_title`
* `course_level_type`
* `course_short_description`
... | python | {
"resource": ""
} |
q256805 | ProgramEnrollmentView.get | validation | def get(self, request, enterprise_uuid, program_uuid):
"""
Show Program Landing page for the Enterprise's Program.
Render the Enterprise's Program Enrollment page for a specific program.
The Enterprise and Program are both selected by their respective UUIDs.
Unauthenticated lea... | python | {
"resource": ""
} |
q256806 | RouterView.get_path_variables | validation | def get_path_variables(**kwargs):
"""
Get the base variables for any view to route to.
Currently gets:
- `enterprise_uuid` - the UUID of the enterprise customer.
- `course_run_id` - the ID of the course, if applicable.
- `program_uuid` - the UUID of the program, if appli... | python | {
"resource": ""
} |
q256807 | RouterView.get_course_run_id | validation | def get_course_run_id(user, enterprise_customer, course_key):
"""
User is requesting a course, we need to translate that into the current course run.
:param user:
:param enterprise_customer:
:param course_key:
:return: course_run_id
"""
try:
c... | python | {
"resource": ""
} |
q256808 | RouterView.eligible_for_direct_audit_enrollment | validation | def eligible_for_direct_audit_enrollment(self, request, enterprise_customer, resource_id, course_key=None):
"""
Return whether a request is eligible for direct audit enrollment for a particular enterprise customer.
'resource_id' can be either course_run_id or program_uuid.
We check for ... | python | {
"resource": ""
} |
q256809 | RouterView.redirect | validation | def redirect(self, request, *args, **kwargs):
"""
Redirects to the appropriate view depending on where the user came from.
"""
enterprise_customer_uuid, course_run_id, course_key, program_uuid = RouterView.get_path_variables(**kwargs)
resource_id = course_key or course_run_id or ... | python | {
"resource": ""
} |
q256810 | RouterView.get | validation | def get(self, request, *args, **kwargs):
"""
Run some custom GET logic for Enterprise workflows before routing the user through existing views.
In particular, before routing to existing views:
- If the requested resource is a course, find the current course run for that course,
... | python | {
"resource": ""
} |
q256811 | RouterView.post | validation | def post(self, request, *args, **kwargs):
"""
Run some custom POST logic for Enterprise workflows before routing the user through existing views.
"""
# pylint: disable=unused-variable
enterprise_customer_uuid, course_run_id, course_key, program_uuid = RouterView.get_path_variable... | python | {
"resource": ""
} |
q256812 | transmit_content_metadata | validation | def transmit_content_metadata(username, channel_code, channel_pk):
"""
Task to send content metadata to each linked integrated channel.
Arguments:
username (str): The username of the User to be used for making API requests to retrieve content metadata.
channel_code (str): Capitalized identi... | python | {
"resource": ""
} |
q256813 | transmit_learner_data | validation | def transmit_learner_data(username, channel_code, channel_pk):
"""
Task to send learner data to each linked integrated channel.
Arguments:
username (str): The username of the User to be used for making API requests for learner data.
channel_code (str): Capitalized identifier for the integra... | python | {
"resource": ""
} |
q256814 | unlink_inactive_learners | validation | def unlink_inactive_learners(channel_code, channel_pk):
"""
Task to unlink inactive learners of provided integrated channel.
Arguments:
channel_code (str): Capitalized identifier for the integrated channel
channel_pk (str): Primary key for identifying integrated channel
"""
start =... | python | {
"resource": ""
} |
q256815 | handle_user_post_save | validation | def handle_user_post_save(sender, **kwargs): # pylint: disable=unused-argument
"""
Handle User model changes - checks if pending enterprise customer user record exists and upgrades it to actual link.
If there are pending enrollments attached to the PendingEnterpriseCustomerUser, then this signal also take... | python | {
"resource": ""
} |
q256816 | default_content_filter | validation | def default_content_filter(sender, instance, **kwargs): # pylint: disable=unused-argument
"""
Set default value for `EnterpriseCustomerCatalog.content_filter` if not already set.
"""
if kwargs['created'] and not instance.content_filter:
instance.content_filter = get_default_catalog_content_f... | python | {
"resource": ""
} |
q256817 | assign_enterprise_learner_role | validation | def assign_enterprise_learner_role(sender, instance, **kwargs): # pylint: disable=unused-argument
"""
Assign an enterprise learner role to EnterpriseCustomerUser whenever a new record is created.
"""
if kwargs['created'] and instance.user:
enterprise_learner_role, __ = SystemWideEnterpriseRo... | python | {
"resource": ""
} |
q256818 | delete_enterprise_learner_role_assignment | validation | def delete_enterprise_learner_role_assignment(sender, instance, **kwargs): # pylint: disable=unused-argument
"""
Delete the associated enterprise learner role assignment record when deleting an EnterpriseCustomerUser record.
"""
if instance.user:
enterprise_learner_role, __ = SystemWideEnter... | python | {
"resource": ""
} |
q256819 | enterprise_customer_required | validation | def enterprise_customer_required(view):
"""
Ensure the user making the API request is associated with an EnterpriseCustomer.
This decorator attempts to find an EnterpriseCustomer associated with the requesting
user and passes that EnterpriseCustomer to the view as a parameter. It will return a
Perm... | python | {
"resource": ""
} |
q256820 | require_at_least_one_query_parameter | validation | def require_at_least_one_query_parameter(*query_parameter_names):
"""
Ensure at least one of the specified query parameters are included in the request.
This decorator checks for the existence of at least one of the specified query
parameters and passes the values as function parameters to the decorate... | python | {
"resource": ""
} |
q256821 | Command._get_enterprise_customer_users_batch | validation | def _get_enterprise_customer_users_batch(self, start, end):
"""
Returns a batched queryset of EnterpriseCustomerUser objects.
"""
LOGGER.info('Fetching new batch of enterprise customer users from indexes: %s to %s', start, end)
return User.objects.filter(pk__in=self._get_enterpri... | python | {
"resource": ""
} |
q256822 | Command._assign_enterprise_role_to_users | validation | def _assign_enterprise_role_to_users(self, _get_batch_method, options, is_feature_role=False):
"""
Assigns enterprise role to users.
"""
role_name = options['role']
batch_limit = options['batch_limit']
batch_sleep = options['batch_sleep']
batch_offset = options['b... | python | {
"resource": ""
} |
q256823 | Command.handle | validation | def handle(self, *args, **options):
"""
Entry point for managment command execution.
"""
LOGGER.info('Starting assigning enterprise roles to users!')
role = options['role']
if role == ENTERPRISE_ADMIN_ROLE:
# Assign admin role to non-staff users with enterpri... | python | {
"resource": ""
} |
q256824 | DegreedLearnerTransmitter.transmit | validation | def transmit(self, payload, **kwargs):
"""
Send a completion status call to Degreed using the client.
Args:
payload: The learner completion data payload to send to Degreed
"""
kwargs['app_label'] = 'degreed'
kwargs['model_name'] = 'DegreedLearnerDataTransmiss... | python | {
"resource": ""
} |
q256825 | get_enterprise_customer_for_running_pipeline | validation | def get_enterprise_customer_for_running_pipeline(request, pipeline): # pylint: disable=invalid-name
"""
Get the EnterpriseCustomer associated with a running pipeline.
"""
sso_provider_id = request.GET.get('tpa_hint')
if pipeline:
sso_provider_id = Registry.get_from_pipeline(pipeline).provid... | python | {
"resource": ""
} |
q256826 | handle_enterprise_logistration | validation | def handle_enterprise_logistration(backend, user, **kwargs):
"""
Perform the linking of user in the process of logging to the Enterprise Customer.
Args:
backend: The class handling the SSO interaction (SAML, OAuth, etc)
user: The user object in the process of being logged in with
**... | python | {
"resource": ""
} |
q256827 | get_user_from_social_auth | validation | def get_user_from_social_auth(tpa_provider, tpa_username):
"""
Find the LMS user from the LMS model `UserSocialAuth`.
Arguments:
tpa_provider (third_party_auth.provider): third party auth provider object
tpa_username (str): Username returned by the third party auth
"""
user_social_... | python | {
"resource": ""
} |
q256828 | SAPSuccessFactorsAPIClient._create_session | validation | def _create_session(self):
"""
Instantiate a new session object for use in connecting with SAP SuccessFactors
"""
session = requests.Session()
session.timeout = self.SESSION_TIMEOUT
oauth_access_token, expires_at = SAPSuccessFactorsAPIClient.get_oauth_access_token(
... | python | {
"resource": ""
} |
q256829 | SAPSuccessFactorsAPIClient.create_course_completion | validation | def create_course_completion(self, user_id, payload):
"""
Send a completion status payload to the SuccessFactors OCN Completion Status endpoint
Args:
user_id (str): The sap user id that the completion status is being sent for.
payload (str): JSON encoded object (serializ... | python | {
"resource": ""
} |
q256830 | SAPSuccessFactorsAPIClient._call_post_with_user_override | validation | def _call_post_with_user_override(self, sap_user_id, url, payload):
"""
Make a post request with an auth token acquired for a specific user to a SuccessFactors endpoint.
Args:
sap_user_id (str): The user to use to retrieve an auth token.
url (str): The url to post to.
... | python | {
"resource": ""
} |
q256831 | SAPSuccessFactorsAPIClient._call_post_with_session | validation | def _call_post_with_session(self, url, payload):
"""
Make a post request using the session object to a SuccessFactors endpoint.
Args:
url (str): The url to post to.
payload (str): The json encoded payload to post.
"""
now = datetime.datetime.utcnow()
... | python | {
"resource": ""
} |
q256832 | SAPSuccessFactorsAPIClient.get_inactive_sap_learners | validation | def get_inactive_sap_learners(self):
"""
Make a GET request using the session object to a SuccessFactors endpoint for inactive learners.
Example:
sap_search_student_url: "/learning/odatav4/searchStudent/v1/Students?
$filter=criteria/isActive eq False&$select=studentI... | python | {
"resource": ""
} |
q256833 | SAPSuccessFactorsAPIClient._call_search_students_recursively | validation | def _call_search_students_recursively(self, sap_search_student_url, all_inactive_learners, page_size, start_at):
"""
Make recursive GET calls to traverse the paginated API response for search students.
"""
search_student_paginated_url = '{sap_search_student_url}&{pagination_criterion}'.f... | python | {
"resource": ""
} |
q256834 | UserFilterBackend.filter_queryset | validation | def filter_queryset(self, request, queryset, view):
"""
Filter only for the user's ID if non-staff.
"""
if not request.user.is_staff:
filter_kwargs = {view.USER_ID_FILTER: request.user.id}
queryset = queryset.filter(**filter_kwargs)
return queryset | python | {
"resource": ""
} |
q256835 | EnterpriseCustomerUserFilterBackend.filter_queryset | validation | def filter_queryset(self, request, queryset, view):
"""
Apply incoming filters only if user is staff. If not, only filter by user's ID.
"""
if request.user.is_staff:
email = request.query_params.get('email', None)
username = request.query_params.get('username', No... | python | {
"resource": ""
} |
q256836 | LearnerTransmitter.transmit | validation | def transmit(self, payload, **kwargs):
"""
Send a completion status call to the integrated channel using the client.
Args:
payload: The learner completion data payload to send to the integrated channel.
kwargs: Contains integrated channel-specific information for customi... | python | {
"resource": ""
} |
q256837 | LearnerTransmitter.handle_transmission_error | validation | def handle_transmission_error(self, learner_data, request_exception):
"""Handle the case where the transmission fails."""
try:
sys_msg = request_exception.response.content
except AttributeError:
sys_msg = 'Not available'
LOGGER.error(
(
... | python | {
"resource": ""
} |
q256838 | add_missing_price_information_message | validation | def add_missing_price_information_message(request, item):
"""
Add a message to the Django messages store indicating that we failed to retrieve price information about an item.
:param request: The current request.
:param item: The item for which price information is missing. Example: a program title, or... | python | {
"resource": ""
} |
q256839 | validate_image_extension | validation | def validate_image_extension(value):
"""
Validate that a particular image extension.
"""
config = get_app_config()
ext = os.path.splitext(value.name)[1]
if config and not ext.lower() in config.valid_image_extensions:
raise ValidationError(_("Unsupported file extension.")) | python | {
"resource": ""
} |
q256840 | validate_image_size | validation | def validate_image_size(image):
"""
Validate that a particular image size.
"""
config = get_app_config()
valid_max_image_size_in_bytes = config.valid_max_image_size * 1024
if config and not image.size <= valid_max_image_size_in_bytes:
raise ValidationError(
_("The logo image ... | python | {
"resource": ""
} |
q256841 | get_enterprise_customer_from_catalog_id | validation | def get_enterprise_customer_from_catalog_id(catalog_id):
"""
Get the enterprise customer id given an enterprise customer catalog id.
"""
try:
return str(EnterpriseCustomerCatalog.objects.get(pk=catalog_id).enterprise_customer.uuid)
except EnterpriseCustomerCatalog.DoesNotExist:
retur... | python | {
"resource": ""
} |
q256842 | on_init | validation | def on_init(app): # pylint: disable=unused-argument
"""
Run sphinx-apidoc after Sphinx initialization.
Read the Docs won't run tox or custom shell commands, so we need this to
avoid checking in the generated reStructuredText files.
"""
docs_path = os.path.abspath(os.path.dirname(__file__))
... | python | {
"resource": ""
} |
q256843 | IntegratedChannelCommandMixin.get_integrated_channels | validation | def get_integrated_channels(self, options):
"""
Generates a list of active integrated channels for active customers, filtered from the given options.
Raises errors when invalid options are encountered.
See ``add_arguments`` for the accepted options.
"""
channel_classes ... | python | {
"resource": ""
} |
q256844 | IntegratedChannelCommandMixin.get_enterprise_customer | validation | def get_enterprise_customer(uuid):
"""
Returns the enterprise customer requested for the given uuid, None if not.
Raises CommandError if uuid is invalid.
"""
if uuid is None:
return None
try:
return EnterpriseCustomer.active_customers.get(uuid=uui... | python | {
"resource": ""
} |
q256845 | IntegratedChannelCommandMixin.get_channel_classes | validation | def get_channel_classes(channel_code):
"""
Assemble a list of integrated channel classes to transmit to.
If a valid channel type was provided, use it.
Otherwise, use all the available channel types.
"""
if channel_code:
# Channel code is case-insensitive
... | python | {
"resource": ""
} |
q256846 | LearnerCourseCompletionStatement.get_result | validation | def get_result(self, course_grade):
"""
Get result for the statement.
Arguments:
course_grade (CourseGrade): Course grade.
"""
return Result(
score=Score(
scaled=course_grade.percent,
raw=course_grade.percent * 100,
... | python | {
"resource": ""
} |
q256847 | get_requirements | validation | def get_requirements(requirements_file):
"""
Get the contents of a file listing the requirements
"""
lines = open(requirements_file).readlines()
dependencies = []
dependency_links = []
for line in lines:
package = line.strip()
if package.startswith('#'):
# Skip p... | python | {
"resource": ""
} |
q256848 | EnterpriseCustomerPluginConfiguration.transmit_learner_data | validation | def transmit_learner_data(self, user):
"""
Iterate over each learner data record and transmit it to the integrated channel.
"""
exporter = self.get_learner_data_exporter(user)
transmitter = self.get_learner_data_transmitter()
transmitter.transmit(exporter) | python | {
"resource": ""
} |
q256849 | EnterpriseCustomerPluginConfiguration.transmit_content_metadata | validation | def transmit_content_metadata(self, user):
"""
Transmit content metadata to integrated channel.
"""
exporter = self.get_content_metadata_exporter(user)
transmitter = self.get_content_metadata_transmitter()
transmitter.transmit(exporter.export()) | python | {
"resource": ""
} |
q256850 | DegreedLearnerExporter.get_learner_data_records | validation | def get_learner_data_records(
self,
enterprise_enrollment,
completed_date=None,
is_passing=False,
**kwargs
): # pylint: disable=arguments-differ,unused-argument
"""
Return a DegreedLearnerDataTransmissionAudit with the given enrollment and... | python | {
"resource": ""
} |
q256851 | TemplatePreviewView.get | validation | def get(self, request, template_id, view_type):
"""
Render the given template with the stock data.
"""
template = get_object_or_404(EnrollmentNotificationEmailTemplate, pk=template_id)
if view_type not in self.view_type_contexts:
return HttpResponse(status=404)
... | python | {
"resource": ""
} |
q256852 | EnterpriseCustomerTransmitCoursesView._build_admin_context | validation | def _build_admin_context(request, customer):
"""
Build common admin context.
"""
opts = customer._meta
codename = get_permission_codename('change', opts)
has_change_permission = request.user.has_perm('%s.%s' % (opts.app_label, codename))
return {
'has_... | python | {
"resource": ""
} |
q256853 | EnterpriseCustomerTransmitCoursesView.get | validation | def get(self, request, enterprise_customer_uuid):
"""
Handle GET request - render "Transmit courses metadata" form.
Arguments:
request (django.http.request.HttpRequest): Request instance
enterprise_customer_uuid (str): Enterprise Customer UUID
Returns:
... | python | {
"resource": ""
} |
q256854 | EnterpriseCustomerManageLearnersView.get_enterprise_customer_user_queryset | validation | def get_enterprise_customer_user_queryset(self, request, search_keyword, customer_uuid, page_size=PAGE_SIZE):
"""
Get the list of EnterpriseCustomerUsers we want to render.
Arguments:
request (HttpRequest): HTTP Request instance.
search_keyword (str): The keyword to sear... | python | {
"resource": ""
} |
q256855 | EnterpriseCustomerManageLearnersView.get_pending_users_queryset | validation | def get_pending_users_queryset(self, search_keyword, customer_uuid):
"""
Get the list of PendingEnterpriseCustomerUsers we want to render.
Args:
search_keyword (str): The keyword to search for in pending users' email addresses.
customer_uuid (str): A unique identifier to... | python | {
"resource": ""
} |
q256856 | EnterpriseCustomerManageLearnersView._handle_singular | validation | def _handle_singular(cls, enterprise_customer, manage_learners_form):
"""
Link single user by email or username.
Arguments:
enterprise_customer (EnterpriseCustomer): learners will be linked to this Enterprise Customer instance
manage_learners_form (ManageLearnersForm): b... | python | {
"resource": ""
} |
q256857 | EnterpriseCustomerManageLearnersView._handle_bulk_upload | validation | def _handle_bulk_upload(cls, enterprise_customer, manage_learners_form, request, email_list=None):
"""
Bulk link users by email.
Arguments:
enterprise_customer (EnterpriseCustomer): learners will be linked to this Enterprise Customer instance
manage_learners_form (Manage... | python | {
"resource": ""
} |
q256858 | EnterpriseCustomerManageLearnersView.enroll_user | validation | def enroll_user(cls, enterprise_customer, user, course_mode, *course_ids):
"""
Enroll a single user in any number of courses using a particular course mode.
Args:
enterprise_customer: The EnterpriseCustomer which is sponsoring the enrollment
user: The user who needs to b... | python | {
"resource": ""
} |
q256859 | EnterpriseCustomerManageLearnersView.is_user_enrolled | validation | def is_user_enrolled(cls, user, course_id, course_mode):
"""
Query the enrollment API and determine if a learner is enrolled in a given course run track.
Args:
user: The user whose enrollment needs to be checked
course_mode: The mode with which the enrollment should be c... | python | {
"resource": ""
} |
q256860 | EnterpriseCustomerManageLearnersView.get_users_by_email | validation | def get_users_by_email(cls, emails):
"""
Accept a list of emails, and separate them into users that exist on OpenEdX and users who don't.
Args:
emails: An iterable of email addresses to split between existing and nonexisting
Returns:
users: Queryset of users who... | python | {
"resource": ""
} |
q256861 | EnterpriseCustomerManageLearnersView.enroll_users_in_program | validation | def enroll_users_in_program(cls, enterprise_customer, program_details, course_mode, emails, cohort=None):
"""
Enroll existing users in all courses in a program, and create pending enrollments for nonexisting users.
Args:
enterprise_customer: The EnterpriseCustomer which is sponsorin... | python | {
"resource": ""
} |
q256862 | EnterpriseCustomerManageLearnersView.enroll_users_in_course | validation | def enroll_users_in_course(cls, enterprise_customer, course_id, course_mode, emails):
"""
Enroll existing users in a course, and create a pending enrollment for nonexisting users.
Args:
enterprise_customer: The EnterpriseCustomer which is sponsoring the enrollment
course... | python | {
"resource": ""
} |
q256863 | EnterpriseCustomerManageLearnersView.send_messages | validation | def send_messages(cls, http_request, message_requests):
"""
Deduplicate any outgoing message requests, and send the remainder.
Args:
http_request: The HTTP request in whose response we want to embed the messages
message_requests: A list of undeduplicated messages in the ... | python | {
"resource": ""
} |
q256864 | EnterpriseCustomerManageLearnersView.notify_program_learners | validation | def notify_program_learners(cls, enterprise_customer, program_details, users):
"""
Notify learners about a program in which they've been enrolled.
Args:
enterprise_customer: The EnterpriseCustomer being linked to
program_details: Details about the specific program the le... | python | {
"resource": ""
} |
q256865 | EnterpriseCustomerManageLearnersView.get_failed_enrollment_message | validation | def get_failed_enrollment_message(cls, users, enrolled_in):
"""
Create message for the users who were not able to be enrolled in a course or program.
Args:
users: An iterable of users who were not successfully enrolled
enrolled_in (str): A string identifier for the cours... | python | {
"resource": ""
} |
q256866 | EnterpriseCustomerManageLearnersView._enroll_users | validation | def _enroll_users(
cls,
request,
enterprise_customer,
emails,
mode,
course_id=None,
program_details=None,
notify=True
):
"""
Enroll the users with the given email addresses to the courses specified, eithe... | python | {
"resource": ""
} |
q256867 | EnterpriseCustomerManageLearnersView.get | validation | def get(self, request, customer_uuid):
"""
Handle GET request - render linked learners list and "Link learner" form.
Arguments:
request (django.http.request.HttpRequest): Request instance
customer_uuid (str): Enterprise Customer UUID
Returns:
django.... | python | {
"resource": ""
} |
q256868 | EnterpriseCustomerManageLearnersView.delete | validation | def delete(self, request, customer_uuid):
"""
Handle DELETE request - handle unlinking learner.
Arguments:
request (django.http.request.HttpRequest): Request instance
customer_uuid (str): Enterprise Customer UUID
Returns:
django.http.response.HttpRes... | python | {
"resource": ""
} |
q256869 | DataSharingConsentQuerySet.proxied_get | validation | def proxied_get(self, *args, **kwargs):
"""
Perform the query and returns a single object matching the given keyword arguments.
This customizes the queryset to return an instance of ``ProxyDataSharingConsent`` when
the searched-for ``DataSharingConsent`` instance does not exist.
... | python | {
"resource": ""
} |
q256870 | ProxyDataSharingConsent.from_children | validation | def from_children(cls, program_uuid, *children):
"""
Build a ProxyDataSharingConsent using the details of the received consent records.
"""
if not children or any(child is None for child in children):
return None
granted = all((child.granted for child in children))
... | python | {
"resource": ""
} |
q256871 | ProxyDataSharingConsent.commit | validation | def commit(self):
"""
Commit a real ``DataSharingConsent`` object to the database, mirroring current field settings.
:return: A ``DataSharingConsent`` object if validation is successful, otherwise ``None``.
"""
if self._child_consents:
consents = []
for ... | python | {
"resource": ""
} |
q256872 | Command.get_course_completions | validation | def get_course_completions(self, enterprise_customer, days):
"""
Get course completions via PersistentCourseGrade for all the learners of given enterprise customer.
Arguments:
enterprise_customer (EnterpriseCustomer): Include Course enrollments for learners
of this e... | python | {
"resource": ""
} |
q256873 | Command.prefetch_users | validation | def prefetch_users(persistent_course_grades):
"""
Prefetch Users from the list of user_ids present in the persistent_course_grades.
Arguments:
persistent_course_grades (list): A list of PersistentCourseGrade.
Returns:
(dict): A dictionary containing user_id to u... | python | {
"resource": ""
} |
q256874 | get_identity_provider | validation | def get_identity_provider(provider_id):
"""
Get Identity Provider with given id.
Return:
Instance of ProviderConfig or None.
"""
try:
from third_party_auth.provider import Registry # pylint: disable=redefined-outer-name
except ImportError as exception:
LOGGER.warning("... | python | {
"resource": ""
} |
q256875 | get_idp_choices | validation | def get_idp_choices():
"""
Get a list of identity providers choices for enterprise customer.
Return:
A list of choices of all identity providers, None if it can not get any available identity provider.
"""
try:
from third_party_auth.provider import Registry # pylint: disable=redef... | python | {
"resource": ""
} |
q256876 | get_catalog_admin_url_template | validation | def get_catalog_admin_url_template(mode='change'):
"""
Get template of catalog admin url.
URL template will contain a placeholder '{catalog_id}' for catalog id.
Arguments:
mode e.g. change/add.
Returns:
A string containing template for catalog url.
Example:
>>> get_cat... | python | {
"resource": ""
} |
q256877 | build_notification_message | validation | def build_notification_message(template_context, template_configuration=None):
"""
Create HTML and plaintext message bodies for a notification.
We receive a context with data we can use to render, as well as an optional site
template configration - if we don't get a template configuration, we'll use th... | python | {
"resource": ""
} |
q256878 | get_notification_subject_line | validation | def get_notification_subject_line(course_name, template_configuration=None):
"""
Get a subject line for a notification email.
The method is designed to fail in a "smart" way; if we can't render a
database-backed subject line template, then we'll fall back to a template
saved in the Django settings;... | python | {
"resource": ""
} |
q256879 | send_email_notification_message | validation | def send_email_notification_message(user, enrolled_in, enterprise_customer, email_connection=None):
"""
Send an email notifying a user about their enrollment in a course.
Arguments:
user: Either a User object or a PendingEnterpriseCustomerUser that we can use
to get details for the emai... | python | {
"resource": ""
} |
q256880 | get_enterprise_customer | validation | def get_enterprise_customer(uuid):
"""
Get the ``EnterpriseCustomer`` instance associated with ``uuid``.
:param uuid: The universally unique ID of the enterprise customer.
:return: The ``EnterpriseCustomer`` instance, or ``None`` if it doesn't exist.
"""
EnterpriseCustomer = apps.get_model('ent... | python | {
"resource": ""
} |
q256881 | get_enterprise_customer_for_user | validation | def get_enterprise_customer_for_user(auth_user):
"""
Return enterprise customer instance for given user.
Some users are associated with an enterprise customer via `EnterpriseCustomerUser` model,
1. if given user is associated with any enterprise customer, return enterprise customer.
2. othe... | python | {
"resource": ""
} |
q256882 | get_enterprise_customer_user | validation | def get_enterprise_customer_user(user_id, enterprise_uuid):
"""
Return the object for EnterpriseCustomerUser.
Arguments:
user_id (str): user identifier
enterprise_uuid (UUID): Universally unique identifier for the enterprise customer.
Returns:
(EnterpriseCustomerUser): enterpri... | python | {
"resource": ""
} |
q256883 | get_course_track_selection_url | validation | def get_course_track_selection_url(course_run, query_parameters):
"""
Return track selection url for the given course.
Arguments:
course_run (dict): A dictionary containing course run metadata.
query_parameters (dict): A dictionary containing query parameters to be added to course selection... | python | {
"resource": ""
} |
q256884 | update_query_parameters | validation | def update_query_parameters(url, query_parameters):
"""
Return url with updated query parameters.
Arguments:
url (str): Original url whose query parameters need to be updated.
query_parameters (dict): A dictionary containing query parameters to be added to course selection url.
Returns... | python | {
"resource": ""
} |
q256885 | filter_audit_course_modes | validation | def filter_audit_course_modes(enterprise_customer, course_modes):
"""
Filter audit course modes out if the enterprise customer has not enabled the 'Enable audit enrollment' flag.
Arguments:
enterprise_customer: The EnterpriseCustomer that the enrollment was created using.
course_modes: iter... | python | {
"resource": ""
} |
q256886 | get_enterprise_customer_or_404 | validation | def get_enterprise_customer_or_404(enterprise_uuid):
"""
Given an EnterpriseCustomer UUID, return the corresponding EnterpriseCustomer or raise a 404.
Arguments:
enterprise_uuid (str): The UUID (in string form) of the EnterpriseCustomer to fetch.
Returns:
(EnterpriseCustomer): The Ente... | python | {
"resource": ""
} |
q256887 | get_cache_key | validation | def get_cache_key(**kwargs):
"""
Get MD5 encoded cache key for given arguments.
Here is the format of key before MD5 encryption.
key1:value1__key2:value2 ...
Example:
>>> get_cache_key(site_domain="example.com", resource="enterprise")
# Here is key format for above call
... | python | {
"resource": ""
} |
q256888 | traverse_pagination | validation | def traverse_pagination(response, endpoint):
"""
Traverse a paginated API response.
Extracts and concatenates "results" (list of dict) returned by DRF-powered
APIs.
Arguments:
response (Dict): Current response dict from service API
endpoint (slumber Resource object): slumber Resour... | python | {
"resource": ""
} |
q256889 | ungettext_min_max | validation | def ungettext_min_max(singular, plural, range_text, min_val, max_val):
"""
Return grammatically correct, translated text based off of a minimum and maximum value.
Example:
min = 1, max = 1, singular = '{} hour required for this course', plural = '{} hours required for this course'
output = ... | python | {
"resource": ""
} |
q256890 | format_price | validation | def format_price(price, currency='$'):
"""
Format the price to have the appropriate currency and digits..
:param price: The price amount.
:param currency: The currency for the price.
:return: A formatted price string, i.e. '$10', '$10.52'.
"""
if int(price) == price:
return '{}{}'.f... | python | {
"resource": ""
} |
q256891 | get_configuration_value_for_site | validation | def get_configuration_value_for_site(site, key, default=None):
"""
Get the site configuration value for a key, unless a site configuration does not exist for that site.
Useful for testing when no Site Configuration exists in edx-enterprise or if a site in LMS doesn't have
a configuration tied to it.
... | python | {
"resource": ""
} |
q256892 | get_configuration_value | validation | def get_configuration_value(val_name, default=None, **kwargs):
"""
Get a configuration value, or fall back to ``default`` if it doesn't exist.
Also takes a `type` argument to guide which particular upstream method to use when trying to retrieve a value.
Current types include:
- `url` to specifi... | python | {
"resource": ""
} |
q256893 | get_request_value | validation | def get_request_value(request, key, default=None):
"""
Get the value in the request, either through query parameters or posted data, from a key.
:param request: The request from which the value should be gotten.
:param key: The key to use to get the desired value.
:param default: The backup value t... | python | {
"resource": ""
} |
q256894 | track_enrollment | validation | def track_enrollment(pathway, user_id, course_run_id, url_path=None):
"""
Emit a track event for enterprise course enrollment.
"""
track_event(user_id, 'edx.bi.user.enterprise.onboarding', {
'pathway': pathway,
'url_path': url_path,
'course_run_id': course_run_id,
}) | python | {
"resource": ""
} |
q256895 | is_course_run_enrollable | validation | def is_course_run_enrollable(course_run):
"""
Return true if the course run is enrollable, false otherwise.
We look for the following criteria:
- end is greater than now OR null
- enrollment_start is less than now OR null
- enrollment_end is greater than now OR null
"""
now = datetime.d... | python | {
"resource": ""
} |
q256896 | is_course_run_upgradeable | validation | def is_course_run_upgradeable(course_run):
"""
Return true if the course run has a verified seat with an unexpired upgrade deadline, false otherwise.
"""
now = datetime.datetime.now(pytz.UTC)
for seat in course_run.get('seats', []):
if seat.get('type') == 'verified':
upgrade_dead... | python | {
"resource": ""
} |
q256897 | get_closest_course_run | validation | def get_closest_course_run(course_runs):
"""
Return course run with start date closest to now.
"""
if len(course_runs) == 1:
return course_runs[0]
now = datetime.datetime.now(pytz.UTC)
# course runs with no start date should be considered last.
never = now - datetime.timedelta(days=... | python | {
"resource": ""
} |
q256898 | get_current_course_run | validation | def get_current_course_run(course, users_active_course_runs):
"""
Return the current course run on the following conditions.
- If user has active course runs (already enrolled) then return course run with closest start date
Otherwise it will check the following logic:
- Course run is enrollable (se... | python | {
"resource": ""
} |
q256899 | strip_html_tags | validation | def strip_html_tags(text, allowed_tags=None):
"""
Strip all tags from a string except those tags provided in `allowed_tags` parameter.
Args:
text (str): string to strip html tags from
allowed_tags (list): allowed list of html tags
Returns: a string without html tags
"""
if text... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.