41e5403f4e
* pyupgrade on contentstore/views * Apply suggestions from code review Co-authored-by: Usama Sadiq <usama.sadiq@arbisoft.com> Co-authored-by: Usama Sadiq <usama.sadiq@arbisoft.com>
1580 lines
70 KiB
Python
1580 lines
70 KiB
Python
"""Views for items (modules)."""
|
|
|
|
|
|
import logging
|
|
from collections import OrderedDict
|
|
from datetime import datetime
|
|
from functools import partial
|
|
from uuid import uuid4
|
|
|
|
from django.conf import settings
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.contrib.auth.models import User # lint-amnesty, pylint: disable=imported-auth-user
|
|
from django.core.exceptions import PermissionDenied
|
|
from django.http import Http404, HttpResponse, HttpResponseBadRequest
|
|
from django.utils.translation import ugettext as _
|
|
from django.views.decorators.http import require_http_methods
|
|
from edx_proctoring.api import (
|
|
does_backend_support_onboarding,
|
|
get_exam_by_content_id,
|
|
get_exam_configuration_dashboard_url
|
|
)
|
|
from edx_proctoring.exceptions import ProctoredExamNotFoundException
|
|
from help_tokens.core import HelpUrlExpert
|
|
from opaque_keys.edx.keys import CourseKey
|
|
from opaque_keys.edx.locator import LibraryUsageLocator
|
|
from pytz import UTC
|
|
from web_fragments.fragment import Fragment
|
|
from xblock.core import XBlock
|
|
from xblock.fields import Scope
|
|
|
|
from cms.djangoapps.contentstore.config.waffle import SHOW_REVIEW_RULES_FLAG
|
|
from cms.djangoapps.models.settings.course_grading import CourseGradingModel
|
|
from cms.djangoapps.xblock_config.models import CourseEditLTIFieldsEnabledFlag
|
|
from cms.lib.xblock.authoring_mixin import VISIBILITY_VIEW
|
|
from common.djangoapps.edxmako.shortcuts import render_to_string
|
|
from common.djangoapps.static_replace import replace_static_urls
|
|
from common.djangoapps.student.auth import has_studio_read_access, has_studio_write_access
|
|
from common.djangoapps.util.date_utils import get_default_time_display
|
|
from common.djangoapps.util.json_request import JsonResponse, expect_json
|
|
from common.djangoapps.xblock_django.user_service import DjangoXBlockUserService
|
|
from openedx.core.djangoapps.bookmarks import api as bookmarks_api
|
|
from openedx.core.lib.gating import api as gating_api
|
|
from openedx.core.lib.xblock_utils import hash_resource, request_token, wrap_xblock, wrap_xblock_aside
|
|
from openedx.core.toggles import ENTRANCE_EXAMS
|
|
from xmodule.course_module import DEFAULT_START_DATE
|
|
from xmodule.library_tools import LibraryToolsService
|
|
from xmodule.modulestore import EdxJSONEncoder, ModuleStoreEnum
|
|
from xmodule.modulestore.django import modulestore
|
|
from xmodule.modulestore.draft_and_published import DIRECT_ONLY_CATEGORIES
|
|
from xmodule.modulestore.exceptions import InvalidLocationError, ItemNotFoundError
|
|
from xmodule.modulestore.inheritance import own_metadata
|
|
from xmodule.services import ConfigurationService, SettingsService, TeamsConfigurationService
|
|
from xmodule.tabs import CourseTabList
|
|
from xmodule.x_module import AUTHOR_VIEW, PREVIEW_VIEWS, STUDENT_VIEW, STUDIO_VIEW
|
|
|
|
from ..utils import (
|
|
ancestor_has_staff_lock,
|
|
find_release_date_source,
|
|
find_staff_lock_source,
|
|
get_split_group_display_name,
|
|
get_user_partition_info,
|
|
get_visibility_partition_info,
|
|
has_children_visible_to_specific_partition_groups,
|
|
is_currently_visible_to_students,
|
|
is_self_paced
|
|
)
|
|
from .helpers import (
|
|
create_xblock,
|
|
get_parent_xblock,
|
|
is_unit,
|
|
usage_key_with_run,
|
|
xblock_primary_child_category,
|
|
xblock_studio_url,
|
|
xblock_type_display_name
|
|
)
|
|
from .preview import get_preview_fragment
|
|
|
|
__all__ = [
|
|
'orphan_handler', 'xblock_handler', 'xblock_view_handler', 'xblock_outline_handler', 'xblock_container_handler'
|
|
]
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
CREATE_IF_NOT_FOUND = ['course_info']
|
|
|
|
# Useful constants for defining predicates
|
|
NEVER = lambda x: False
|
|
ALWAYS = lambda x: True
|
|
|
|
|
|
def _filter_entrance_exam_grader(graders):
|
|
"""
|
|
If the entrance exams feature is enabled we need to hide away the grader from
|
|
views/controls like the 'Grade as' dropdown that allows a course author to select
|
|
the grader type for a given section of a course
|
|
"""
|
|
if ENTRANCE_EXAMS.is_enabled():
|
|
graders = [grader for grader in graders if grader.get('type') != 'Entrance Exam']
|
|
return graders
|
|
|
|
|
|
def _is_library_component_limit_reached(usage_key):
|
|
"""
|
|
Verify if the library has reached the maximum number of components allowed in it
|
|
"""
|
|
store = modulestore()
|
|
parent = store.get_item(usage_key)
|
|
if not parent.has_children:
|
|
# Limit cannot be applied on such items
|
|
return False
|
|
total_children = len(parent.children)
|
|
return total_children + 1 > settings.MAX_BLOCKS_PER_CONTENT_LIBRARY
|
|
|
|
|
|
@require_http_methods(("DELETE", "GET", "PUT", "POST", "PATCH"))
|
|
@login_required
|
|
@expect_json
|
|
def xblock_handler(request, usage_key_string):
|
|
"""
|
|
The restful handler for xblock requests.
|
|
|
|
DELETE
|
|
json: delete this xblock instance from the course.
|
|
GET
|
|
json: returns representation of the xblock (locator id, data, and metadata).
|
|
if ?fields=graderType, it returns the graderType for the unit instead of the above.
|
|
if ?fields=ancestorInfo, it returns ancestor info of the xblock.
|
|
html: returns HTML for rendering the xblock (which includes both the "preview" view and the "editor" view)
|
|
PUT or POST or PATCH
|
|
json: if xblock locator is specified, update the xblock instance. The json payload can contain
|
|
these fields, all optional:
|
|
:data: the new value for the data.
|
|
:children: the unicode representation of the UsageKeys of children for this xblock.
|
|
:metadata: new values for the metadata fields. Any whose values are None will be deleted not set
|
|
to None! Absent ones will be left alone.
|
|
:fields: any other xblock fields to be set. Only supported by update.
|
|
This is represented as a dictionary:
|
|
{'field_name': 'field_value'}
|
|
:nullout: which metadata fields to set to None
|
|
:graderType: change how this unit is graded
|
|
:isPrereq: Set this xblock as a prerequisite which can be used to limit access to other xblocks
|
|
:prereqUsageKey: Use the xblock identified by this usage key to limit access to this xblock
|
|
:prereqMinScore: The minimum score that needs to be achieved on the prerequisite xblock
|
|
identifed by prereqUsageKey. Ranging from 0 to 100.
|
|
:prereqMinCompletion: The minimum completion percentage that needs to be achieved on the
|
|
prerequisite xblock identifed by prereqUsageKey. Ranging from 0 to 100.
|
|
:publish: can be:
|
|
'make_public': publish the content
|
|
'republish': publish this item *only* if it was previously published
|
|
'discard_changes' - reverts to the last published version
|
|
Note: If 'discard_changes', the other fields will not be used; that is, it is not possible
|
|
to update and discard changes in a single operation.
|
|
The JSON representation on the updated xblock (minus children) is returned.
|
|
|
|
if usage_key_string is not specified, create a new xblock instance, either by duplicating
|
|
an existing xblock, or creating an entirely new one. The json playload can contain
|
|
these fields:
|
|
:parent_locator: parent for new xblock, required for duplicate, move and create new instance
|
|
:duplicate_source_locator: if present, use this as the source for creating a duplicate copy
|
|
:move_source_locator: if present, use this as the source item for moving
|
|
:target_index: if present, use this as the target index for moving an item to a particular index
|
|
otherwise target_index is calculated. It is sent back in the response.
|
|
:category: type of xblock, required if duplicate_source_locator is not present.
|
|
:display_name: name for new xblock, optional
|
|
:boilerplate: template name for populating fields, optional and only used
|
|
if duplicate_source_locator is not present
|
|
The locator (unicode representation of a UsageKey) for the created xblock (minus children) is returned.
|
|
"""
|
|
if usage_key_string:
|
|
usage_key = usage_key_with_run(usage_key_string)
|
|
|
|
access_check = has_studio_read_access if request.method == 'GET' else has_studio_write_access
|
|
if not access_check(request.user, usage_key.course_key):
|
|
raise PermissionDenied()
|
|
|
|
if request.method == 'GET':
|
|
accept_header = request.META.get('HTTP_ACCEPT', 'application/json')
|
|
|
|
if 'application/json' in accept_header:
|
|
fields = request.GET.get('fields', '').split(',')
|
|
if 'graderType' in fields:
|
|
# right now can't combine output of this w/ output of _get_module_info, but worthy goal
|
|
return JsonResponse(CourseGradingModel.get_section_grader_type(usage_key))
|
|
elif 'ancestorInfo' in fields:
|
|
xblock = _get_xblock(usage_key, request.user)
|
|
ancestor_info = _create_xblock_ancestor_info(xblock, is_concise=True)
|
|
return JsonResponse(ancestor_info)
|
|
# TODO: pass fields to _get_module_info and only return those
|
|
with modulestore().bulk_operations(usage_key.course_key):
|
|
response = _get_module_info(_get_xblock(usage_key, request.user))
|
|
return JsonResponse(response)
|
|
else:
|
|
return HttpResponse(status=406)
|
|
|
|
elif request.method == 'DELETE':
|
|
_delete_item(usage_key, request.user)
|
|
return JsonResponse()
|
|
else: # Since we have a usage_key, we are updating an existing xblock.
|
|
return _save_xblock(
|
|
request.user,
|
|
_get_xblock(usage_key, request.user),
|
|
data=request.json.get('data'),
|
|
children_strings=request.json.get('children'),
|
|
metadata=request.json.get('metadata'),
|
|
nullout=request.json.get('nullout'),
|
|
grader_type=request.json.get('graderType'),
|
|
is_prereq=request.json.get('isPrereq'),
|
|
prereq_usage_key=request.json.get('prereqUsageKey'),
|
|
prereq_min_score=request.json.get('prereqMinScore'),
|
|
prereq_min_completion=request.json.get('prereqMinCompletion'),
|
|
publish=request.json.get('publish'),
|
|
fields=request.json.get('fields'),
|
|
)
|
|
elif request.method in ('PUT', 'POST'):
|
|
if 'duplicate_source_locator' in request.json:
|
|
parent_usage_key = usage_key_with_run(request.json['parent_locator'])
|
|
duplicate_source_usage_key = usage_key_with_run(request.json['duplicate_source_locator'])
|
|
|
|
source_course = duplicate_source_usage_key.course_key
|
|
dest_course = parent_usage_key.course_key
|
|
if (
|
|
not has_studio_write_access(request.user, dest_course) or
|
|
not has_studio_read_access(request.user, source_course)
|
|
):
|
|
raise PermissionDenied()
|
|
|
|
# Libraries have a maximum component limit enforced on them
|
|
if (isinstance(parent_usage_key, LibraryUsageLocator) and
|
|
_is_library_component_limit_reached(parent_usage_key)):
|
|
return JsonResponse(
|
|
{
|
|
'error': _('Libraries cannot have more than {limit} components').format(
|
|
limit=settings.MAX_BLOCKS_PER_CONTENT_LIBRARY
|
|
)
|
|
},
|
|
status=400
|
|
)
|
|
|
|
dest_usage_key = _duplicate_item(
|
|
parent_usage_key,
|
|
duplicate_source_usage_key,
|
|
request.user,
|
|
request.json.get('display_name'),
|
|
)
|
|
return JsonResponse({
|
|
'locator': str(dest_usage_key),
|
|
'courseKey': str(dest_usage_key.course_key)
|
|
})
|
|
else:
|
|
return _create_item(request)
|
|
elif request.method == 'PATCH':
|
|
if 'move_source_locator' in request.json:
|
|
move_source_usage_key = usage_key_with_run(request.json.get('move_source_locator'))
|
|
target_parent_usage_key = usage_key_with_run(request.json.get('parent_locator'))
|
|
target_index = request.json.get('target_index')
|
|
if (
|
|
not has_studio_write_access(request.user, target_parent_usage_key.course_key) or
|
|
not has_studio_read_access(request.user, target_parent_usage_key.course_key)
|
|
):
|
|
raise PermissionDenied()
|
|
return _move_item(move_source_usage_key, target_parent_usage_key, request.user, target_index)
|
|
|
|
return JsonResponse({'error': 'Patch request did not recognise any parameters to handle.'}, status=400)
|
|
else:
|
|
return HttpResponseBadRequest(
|
|
'Only instance creation is supported without a usage key.',
|
|
content_type='text/plain'
|
|
)
|
|
|
|
|
|
class StudioPermissionsService:
|
|
"""
|
|
Service that can provide information about a user's permissions.
|
|
|
|
Deprecated. To be replaced by a more general authorization service.
|
|
|
|
Only used by LibraryContentBlock (and library_tools.py).
|
|
"""
|
|
def __init__(self, user):
|
|
self._user = user
|
|
|
|
def can_read(self, course_key):
|
|
""" Does the user have read access to the given course/library? """
|
|
return has_studio_read_access(self._user, course_key)
|
|
|
|
def can_write(self, course_key):
|
|
""" Does the user have read access to the given course/library? """
|
|
return has_studio_write_access(self._user, course_key)
|
|
|
|
|
|
class StudioEditModuleRuntime:
|
|
"""
|
|
An extremely minimal ModuleSystem shim used for XBlock edits and studio_view.
|
|
(i.e. whenever we're not using PreviewModuleSystem.) This is required to make information
|
|
about the current user (especially permissions) available via services as needed.
|
|
"""
|
|
|
|
def __init__(self, user):
|
|
self._user = user
|
|
|
|
def service(self, block, service_name):
|
|
"""
|
|
This block is not bound to a user but some blocks (LibraryContentBlock) may need
|
|
user-specific services to check for permissions, etc.
|
|
If we return None here, CombinedSystem will load services from the descriptor runtime.
|
|
"""
|
|
if block.service_declaration(service_name) is not None:
|
|
if service_name == "user":
|
|
return DjangoXBlockUserService(self._user)
|
|
if service_name == "studio_user_permissions":
|
|
return StudioPermissionsService(self._user)
|
|
if service_name == "settings":
|
|
return SettingsService()
|
|
if service_name == "lti-configuration":
|
|
return ConfigurationService(CourseEditLTIFieldsEnabledFlag)
|
|
if service_name == "teams_configuration":
|
|
return TeamsConfigurationService()
|
|
if service_name == "library_tools":
|
|
return LibraryToolsService(modulestore(), self._user.id)
|
|
return None
|
|
|
|
|
|
@require_http_methods("GET")
|
|
@login_required
|
|
@expect_json
|
|
def xblock_view_handler(request, usage_key_string, view_name):
|
|
"""
|
|
The restful handler for requests for rendered xblock views.
|
|
|
|
Returns a json object containing two keys:
|
|
html: The rendered html of the view
|
|
resources: A list of tuples where the first element is the resource hash, and
|
|
the second is the resource description
|
|
"""
|
|
usage_key = usage_key_with_run(usage_key_string)
|
|
if not has_studio_read_access(request.user, usage_key.course_key):
|
|
raise PermissionDenied()
|
|
|
|
accept_header = request.META.get('HTTP_ACCEPT', 'application/json')
|
|
|
|
if 'application/json' in accept_header:
|
|
store = modulestore()
|
|
xblock = store.get_item(usage_key)
|
|
container_views = ['container_preview', 'reorderable_container_child_preview', 'container_child_preview']
|
|
|
|
# wrap the generated fragment in the xmodule_editor div so that the javascript
|
|
# can bind to it correctly
|
|
xblock.runtime.wrappers.append(partial(
|
|
wrap_xblock,
|
|
'StudioRuntime',
|
|
usage_id_serializer=str,
|
|
request_token=request_token(request),
|
|
))
|
|
|
|
xblock.runtime.wrappers_asides.append(partial(
|
|
wrap_xblock_aside,
|
|
'StudioRuntime',
|
|
usage_id_serializer=str,
|
|
request_token=request_token(request),
|
|
extra_classes=['wrapper-comp-plugins']
|
|
))
|
|
|
|
if view_name in (STUDIO_VIEW, VISIBILITY_VIEW):
|
|
if view_name == STUDIO_VIEW and xblock.xmodule_runtime is None:
|
|
xblock.xmodule_runtime = StudioEditModuleRuntime(request.user)
|
|
|
|
try:
|
|
fragment = xblock.render(view_name)
|
|
# catch exceptions indiscriminately, since after this point they escape the
|
|
# dungeon and surface as uneditable, unsaveable, and undeletable
|
|
# component-goblins.
|
|
except Exception as exc: # pylint: disable=broad-except
|
|
log.debug("Unable to render %s for %r", view_name, xblock, exc_info=True)
|
|
fragment = Fragment(render_to_string('html_error.html', {'message': str(exc)}))
|
|
|
|
elif view_name in PREVIEW_VIEWS + container_views:
|
|
is_pages_view = view_name == STUDENT_VIEW # Only the "Pages" view uses student view in Studio
|
|
can_edit = has_studio_write_access(request.user, usage_key.course_key)
|
|
|
|
# Determine the items to be shown as reorderable. Note that the view
|
|
# 'reorderable_container_child_preview' is only rendered for xblocks that
|
|
# are being shown in a reorderable container, so the xblock is automatically
|
|
# added to the list.
|
|
reorderable_items = set()
|
|
if view_name == 'reorderable_container_child_preview':
|
|
reorderable_items.add(xblock.location)
|
|
|
|
paging = None
|
|
try:
|
|
if request.GET.get('enable_paging', 'false') == 'true':
|
|
paging = {
|
|
'page_number': int(request.GET.get('page_number', 0)),
|
|
'page_size': int(request.GET.get('page_size', 0)),
|
|
}
|
|
except ValueError:
|
|
return HttpResponse(
|
|
content="Couldn't parse paging parameters: enable_paging: "
|
|
"{}, page_number: {}, page_size: {}".format(
|
|
request.GET.get('enable_paging', 'false'),
|
|
request.GET.get('page_number', 0),
|
|
request.GET.get('page_size', 0)
|
|
),
|
|
status=400,
|
|
content_type="text/plain",
|
|
)
|
|
|
|
force_render = request.GET.get('force_render', None)
|
|
|
|
# Set up the context to be passed to each XBlock's render method.
|
|
context = request.GET.dict()
|
|
context.update({
|
|
# This setting disables the recursive wrapping of xblocks
|
|
'is_pages_view': is_pages_view or view_name == AUTHOR_VIEW,
|
|
'is_unit_page': is_unit(xblock),
|
|
'can_edit': can_edit,
|
|
'root_xblock': xblock if (view_name == 'container_preview') else None,
|
|
'reorderable_items': reorderable_items,
|
|
'paging': paging,
|
|
'force_render': force_render,
|
|
'item_url': '/container/{usage_key}',
|
|
})
|
|
fragment = get_preview_fragment(request, xblock, context)
|
|
|
|
# Note that the container view recursively adds headers into the preview fragment,
|
|
# so only the "Pages" view requires that this extra wrapper be included.
|
|
if is_pages_view:
|
|
fragment.content = render_to_string('component.html', {
|
|
'xblock_context': context,
|
|
'xblock': xblock,
|
|
'locator': usage_key,
|
|
'preview': fragment.content,
|
|
'label': xblock.display_name or xblock.scope_ids.block_type,
|
|
})
|
|
else:
|
|
raise Http404
|
|
|
|
hashed_resources = OrderedDict()
|
|
for resource in fragment.resources:
|
|
hashed_resources[hash_resource(resource)] = resource._asdict()
|
|
|
|
fragment_content = fragment.content
|
|
if isinstance(fragment_content, bytes):
|
|
fragment_content = fragment.content.decode('utf-8')
|
|
|
|
return JsonResponse({
|
|
'html': fragment_content,
|
|
'resources': list(hashed_resources.items())
|
|
})
|
|
|
|
else:
|
|
return HttpResponse(status=406)
|
|
|
|
|
|
@require_http_methods("GET")
|
|
@login_required
|
|
@expect_json
|
|
def xblock_outline_handler(request, usage_key_string):
|
|
"""
|
|
The restful handler for requests for XBlock information about the block and its children.
|
|
This is used by the course outline in particular to construct the tree representation of
|
|
a course.
|
|
"""
|
|
usage_key = usage_key_with_run(usage_key_string)
|
|
if not has_studio_read_access(request.user, usage_key.course_key):
|
|
raise PermissionDenied()
|
|
|
|
response_format = request.GET.get('format', 'html')
|
|
if response_format == 'json' or 'application/json' in request.META.get('HTTP_ACCEPT', 'application/json'):
|
|
store = modulestore()
|
|
with store.bulk_operations(usage_key.course_key):
|
|
root_xblock = store.get_item(usage_key, depth=None)
|
|
return JsonResponse(create_xblock_info(
|
|
root_xblock,
|
|
include_child_info=True,
|
|
course_outline=True,
|
|
include_children_predicate=lambda xblock: not xblock.category == 'vertical'
|
|
))
|
|
else:
|
|
return Http404
|
|
|
|
|
|
@require_http_methods("GET")
|
|
@login_required
|
|
@expect_json
|
|
def xblock_container_handler(request, usage_key_string):
|
|
"""
|
|
The restful handler for requests for XBlock information about the block and its children.
|
|
This is used by the container page in particular to get additional information about publish state
|
|
and ancestor state.
|
|
"""
|
|
usage_key = usage_key_with_run(usage_key_string)
|
|
|
|
if not has_studio_read_access(request.user, usage_key.course_key):
|
|
raise PermissionDenied()
|
|
|
|
response_format = request.GET.get('format', 'html')
|
|
if response_format == 'json' or 'application/json' in request.META.get('HTTP_ACCEPT', 'application/json'):
|
|
with modulestore().bulk_operations(usage_key.course_key):
|
|
response = _get_module_info(
|
|
_get_xblock(usage_key, request.user), include_ancestor_info=True, include_publishing_info=True
|
|
)
|
|
return JsonResponse(response)
|
|
else:
|
|
return Http404
|
|
|
|
|
|
def _update_with_callback(xblock, user, old_metadata=None, old_content=None):
|
|
"""
|
|
Updates the xblock in the modulestore.
|
|
But before doing so, it calls the xblock's editor_saved callback function.
|
|
"""
|
|
if callable(getattr(xblock, "editor_saved", None)):
|
|
if old_metadata is None:
|
|
old_metadata = own_metadata(xblock)
|
|
if old_content is None:
|
|
old_content = xblock.get_explicitly_set_fields_by_scope(Scope.content)
|
|
xblock.xmodule_runtime = StudioEditModuleRuntime(user)
|
|
xblock.editor_saved(user, old_metadata, old_content)
|
|
|
|
# Update after the callback so any changes made in the callback will get persisted.
|
|
return modulestore().update_item(xblock, user.id)
|
|
|
|
|
|
def _save_xblock(user, xblock, data=None, children_strings=None, metadata=None, nullout=None, # lint-amnesty, pylint: disable=too-many-statements
|
|
grader_type=None, is_prereq=None, prereq_usage_key=None, prereq_min_score=None,
|
|
prereq_min_completion=None, publish=None, fields=None):
|
|
"""
|
|
Saves xblock w/ its fields. Has special processing for grader_type, publish, and nullout and Nones in metadata.
|
|
nullout means to truly set the field to None whereas nones in metadata mean to unset them (so they revert
|
|
to default).
|
|
|
|
"""
|
|
store = modulestore()
|
|
# Perform all xblock changes within a (single-versioned) transaction
|
|
with store.bulk_operations(xblock.location.course_key):
|
|
|
|
# Don't allow updating an xblock and discarding changes in a single operation (unsupported by UI).
|
|
if publish == "discard_changes":
|
|
store.revert_to_published(xblock.location, user.id)
|
|
# Returning the same sort of result that we do for other save operations. In the future,
|
|
# we may want to return the full XBlockInfo.
|
|
return JsonResponse({'id': str(xblock.location)})
|
|
|
|
old_metadata = own_metadata(xblock)
|
|
old_content = xblock.get_explicitly_set_fields_by_scope(Scope.content)
|
|
|
|
if data:
|
|
# TODO Allow any scope.content fields not just "data" (exactly like the get below this)
|
|
xblock.data = data
|
|
else:
|
|
data = old_content['data'] if 'data' in old_content else None
|
|
|
|
if fields:
|
|
for field_name in fields:
|
|
setattr(xblock, field_name, fields[field_name])
|
|
|
|
if children_strings is not None:
|
|
children = []
|
|
for child_string in children_strings:
|
|
children.append(usage_key_with_run(child_string))
|
|
|
|
# if new children have been added, remove them from their old parents
|
|
new_children = set(children) - set(xblock.children)
|
|
for new_child in new_children:
|
|
old_parent_location = store.get_parent_location(new_child)
|
|
if old_parent_location:
|
|
old_parent = store.get_item(old_parent_location)
|
|
old_parent.children.remove(new_child)
|
|
old_parent = _update_with_callback(old_parent, user)
|
|
else:
|
|
# the Studio UI currently doesn't present orphaned children, so assume this is an error
|
|
return JsonResponse({"error": "Invalid data, possibly caused by concurrent authors."}, 400)
|
|
|
|
# make sure there are no old children that became orphans
|
|
# In a single-author (no-conflict) scenario, all children in the persisted list on the server should be
|
|
# present in the updated list. If there are any children that have been dropped as part of this update,
|
|
# then that would be an error.
|
|
#
|
|
# We can be even more restrictive in a multi-author (conflict), by returning an error whenever
|
|
# len(old_children) > 0. However, that conflict can still be "merged" if the dropped child had been
|
|
# re-parented. Hence, the check for the parent in the any statement below.
|
|
#
|
|
# Note that this multi-author conflict error should not occur in modulestores (such as Split) that support
|
|
# atomic write transactions. In Split, if there was another author who moved one of the "old_children"
|
|
# into another parent, then that child would have been deleted from this parent on the server. However,
|
|
# this is error could occur in modulestores (such as Draft) that do not support atomic write-transactions
|
|
old_children = set(xblock.children) - set(children)
|
|
if any(
|
|
store.get_parent_location(old_child) == xblock.location
|
|
for old_child in old_children
|
|
):
|
|
# since children are moved as part of a single transaction, orphans should not be created
|
|
return JsonResponse({"error": "Invalid data, possibly caused by concurrent authors."}, 400)
|
|
|
|
# set the children on the xblock
|
|
xblock.children = children
|
|
|
|
# also commit any metadata which might have been passed along
|
|
if nullout is not None or metadata is not None:
|
|
# the postback is not the complete metadata, as there's system metadata which is
|
|
# not presented to the end-user for editing. So let's use the original (existing_item) and
|
|
# 'apply' the submitted metadata, so we don't end up deleting system metadata.
|
|
if nullout is not None:
|
|
for metadata_key in nullout:
|
|
setattr(xblock, metadata_key, None)
|
|
|
|
# update existing metadata with submitted metadata (which can be partial)
|
|
# IMPORTANT NOTE: if the client passed 'null' (None) for a piece of metadata that means 'remove it'. If
|
|
# the intent is to make it None, use the nullout field
|
|
if metadata is not None:
|
|
for metadata_key, value in metadata.items():
|
|
field = xblock.fields[metadata_key]
|
|
|
|
if value is None:
|
|
field.delete_from(xblock)
|
|
else:
|
|
try:
|
|
value = field.from_json(value)
|
|
except ValueError as verr:
|
|
reason = _("Invalid data")
|
|
if str(verr):
|
|
reason = _("Invalid data ({details})").format(details=str(verr))
|
|
return JsonResponse({"error": reason}, 400)
|
|
|
|
field.write_to(xblock, value)
|
|
|
|
validate_and_update_xblock_due_date(xblock)
|
|
# update the xblock and call any xblock callbacks
|
|
xblock = _update_with_callback(xblock, user, old_metadata, old_content)
|
|
|
|
# for static tabs, their containing course also records their display name
|
|
course = store.get_course(xblock.location.course_key)
|
|
if xblock.location.block_type == 'static_tab':
|
|
# find the course's reference to this tab and update the name.
|
|
static_tab = CourseTabList.get_tab_by_slug(course.tabs, xblock.location.name)
|
|
# only update if changed
|
|
if static_tab:
|
|
update_tab = False
|
|
if static_tab['name'] != xblock.display_name:
|
|
static_tab['name'] = xblock.display_name
|
|
update_tab = True
|
|
if static_tab['course_staff_only'] != xblock.course_staff_only:
|
|
static_tab['course_staff_only'] = xblock.course_staff_only
|
|
update_tab = True
|
|
if update_tab:
|
|
store.update_item(course, user.id)
|
|
|
|
result = {
|
|
'id': str(xblock.location),
|
|
'data': data,
|
|
'metadata': own_metadata(xblock)
|
|
}
|
|
|
|
if grader_type is not None:
|
|
result.update(CourseGradingModel.update_section_grader_type(xblock, grader_type, user))
|
|
|
|
# Save gating info
|
|
if xblock.category == 'sequential' and course.enable_subsection_gating:
|
|
if is_prereq is not None:
|
|
if is_prereq:
|
|
gating_api.add_prerequisite(xblock.location.course_key, xblock.location)
|
|
else:
|
|
gating_api.remove_prerequisite(xblock.location)
|
|
result['is_prereq'] = is_prereq
|
|
|
|
if prereq_usage_key is not None:
|
|
gating_api.set_required_content(
|
|
xblock.location.course_key,
|
|
xblock.location,
|
|
prereq_usage_key,
|
|
prereq_min_score,
|
|
prereq_min_completion
|
|
)
|
|
|
|
# If publish is set to 'republish' and this item is not in direct only categories and has previously been
|
|
# published, then this item should be republished. This is used by staff locking to ensure that changing the
|
|
# draft value of the staff lock will also update the published version, but only at the unit level.
|
|
if publish == 'republish' and xblock.category not in DIRECT_ONLY_CATEGORIES:
|
|
if modulestore().has_published_version(xblock):
|
|
publish = 'make_public'
|
|
|
|
# Make public after updating the xblock, in case the caller asked for both an update and a publish.
|
|
# Used by Bok Choy tests and by republishing of staff locks.
|
|
if publish == 'make_public':
|
|
modulestore().publish(xblock.location, user.id)
|
|
|
|
# Note that children aren't being returned until we have a use case.
|
|
return JsonResponse(result, encoder=EdxJSONEncoder)
|
|
|
|
|
|
@login_required
|
|
@expect_json
|
|
def create_item(request):
|
|
"""
|
|
Exposes internal helper method without breaking existing bindings/dependencies
|
|
"""
|
|
return _create_item(request)
|
|
|
|
|
|
@login_required
|
|
@expect_json
|
|
def _create_item(request):
|
|
"""View for create items."""
|
|
parent_locator = request.json['parent_locator']
|
|
usage_key = usage_key_with_run(parent_locator)
|
|
if not has_studio_write_access(request.user, usage_key.course_key):
|
|
raise PermissionDenied()
|
|
|
|
category = request.json['category']
|
|
if isinstance(usage_key, LibraryUsageLocator):
|
|
# Only these categories are supported at this time.
|
|
if category not in ['html', 'problem', 'video']:
|
|
return HttpResponseBadRequest(
|
|
"Category '%s' not supported for Libraries" % category, content_type='text/plain'
|
|
)
|
|
|
|
if _is_library_component_limit_reached(usage_key):
|
|
return JsonResponse(
|
|
{
|
|
'error': _('Libraries cannot have more than {limit} components').format(
|
|
limit=settings.MAX_BLOCKS_PER_CONTENT_LIBRARY
|
|
)
|
|
},
|
|
status=400
|
|
)
|
|
|
|
created_block = create_xblock(
|
|
parent_locator=parent_locator,
|
|
user=request.user,
|
|
category=category,
|
|
display_name=request.json.get('display_name'),
|
|
boilerplate=request.json.get('boilerplate'),
|
|
)
|
|
|
|
return JsonResponse(
|
|
{'locator': str(created_block.location), 'courseKey': str(created_block.location.course_key)}
|
|
)
|
|
|
|
|
|
def _get_source_index(source_usage_key, source_parent):
|
|
"""
|
|
Get source index position of the XBlock.
|
|
|
|
Arguments:
|
|
source_usage_key (BlockUsageLocator): Locator of source item.
|
|
source_parent (XBlock): A parent of the source XBlock.
|
|
|
|
Returns:
|
|
source_index (int): Index position of the xblock in a parent.
|
|
"""
|
|
try:
|
|
source_index = source_parent.children.index(source_usage_key)
|
|
return source_index
|
|
except ValueError:
|
|
return None
|
|
|
|
|
|
def is_source_item_in_target_parents(source_item, target_parent):
|
|
"""
|
|
Returns True if source item is found in target parents otherwise False.
|
|
|
|
Arguments:
|
|
source_item (XBlock): Source Xblock.
|
|
target_parent (XBlock): Target XBlock.
|
|
"""
|
|
target_ancestors = _create_xblock_ancestor_info(target_parent, is_concise=True)['ancestors']
|
|
for target_ancestor in target_ancestors:
|
|
if str(source_item.location) == target_ancestor['id']:
|
|
return True
|
|
return False
|
|
|
|
|
|
def _move_item(source_usage_key, target_parent_usage_key, user, target_index=None):
|
|
"""
|
|
Move an existing xblock as a child of the supplied target_parent_usage_key.
|
|
|
|
Arguments:
|
|
source_usage_key (BlockUsageLocator): Locator of source item.
|
|
target_parent_usage_key (BlockUsageLocator): Locator of target parent.
|
|
target_index (int): If provided, insert source item at provided index location in target_parent_usage_key item.
|
|
|
|
Returns:
|
|
JsonResponse: Information regarding move operation. It may contains error info if an invalid move operation
|
|
is performed.
|
|
"""
|
|
# Get the list of all parentable component type XBlocks.
|
|
parent_component_types = list(
|
|
{name for name, class_ in XBlock.load_classes() if getattr(class_, 'has_children', False)} -
|
|
set(DIRECT_ONLY_CATEGORIES)
|
|
)
|
|
|
|
store = modulestore()
|
|
with store.bulk_operations(source_usage_key.course_key):
|
|
source_item = store.get_item(source_usage_key)
|
|
source_parent = source_item.get_parent()
|
|
target_parent = store.get_item(target_parent_usage_key)
|
|
source_type = source_item.category
|
|
target_parent_type = target_parent.category
|
|
error = None
|
|
|
|
# Store actual/initial index of the source item. This would be sent back with response,
|
|
# so that with Undo operation, it would easier to move back item to it's original/old index.
|
|
source_index = _get_source_index(source_usage_key, source_parent)
|
|
|
|
valid_move_type = {
|
|
'sequential': 'vertical',
|
|
'chapter': 'sequential',
|
|
}
|
|
|
|
if (valid_move_type.get(target_parent_type, '') != source_type and
|
|
target_parent_type not in parent_component_types):
|
|
error = _('You can not move {source_type} into {target_parent_type}.').format(
|
|
source_type=source_type,
|
|
target_parent_type=target_parent_type,
|
|
)
|
|
elif source_parent.location == target_parent.location or source_item.location in target_parent.children:
|
|
error = _('Item is already present in target location.')
|
|
elif source_item.location == target_parent.location:
|
|
error = _('You can not move an item into itself.')
|
|
elif is_source_item_in_target_parents(source_item, target_parent):
|
|
error = _('You can not move an item into it\'s child.')
|
|
elif target_parent_type == 'split_test':
|
|
error = _('You can not move an item directly into content experiment.')
|
|
elif source_index is None:
|
|
error = _('{source_usage_key} not found in {parent_usage_key}.').format(
|
|
source_usage_key=str(source_usage_key),
|
|
parent_usage_key=str(source_parent.location)
|
|
)
|
|
else:
|
|
try:
|
|
target_index = int(target_index) if target_index is not None else None
|
|
if target_index is not None and len(target_parent.children) < target_index:
|
|
error = _('You can not move {source_usage_key} at an invalid index ({target_index}).').format(
|
|
source_usage_key=str(source_usage_key),
|
|
target_index=target_index
|
|
)
|
|
except ValueError:
|
|
error = _('You must provide target_index ({target_index}) as an integer.').format(
|
|
target_index=target_index
|
|
)
|
|
if error:
|
|
return JsonResponse({'error': error}, status=400)
|
|
|
|
# When target_index is provided, insert xblock at target_index position, otherwise insert at the end.
|
|
insert_at = target_index if target_index is not None else len(target_parent.children)
|
|
|
|
store.update_item_parent(
|
|
item_location=source_item.location,
|
|
new_parent_location=target_parent.location,
|
|
old_parent_location=source_parent.location,
|
|
insert_at=insert_at,
|
|
user_id=user.id
|
|
)
|
|
|
|
log.info(
|
|
'MOVE: %s moved from %s to %s at %d index',
|
|
str(source_usage_key),
|
|
str(source_parent.location),
|
|
str(target_parent_usage_key),
|
|
insert_at
|
|
)
|
|
|
|
context = {
|
|
'move_source_locator': str(source_usage_key),
|
|
'parent_locator': str(target_parent_usage_key),
|
|
'source_index': target_index if target_index is not None else source_index
|
|
}
|
|
return JsonResponse(context)
|
|
|
|
|
|
def _duplicate_item(parent_usage_key, duplicate_source_usage_key, user, display_name=None, is_child=False):
|
|
"""
|
|
Duplicate an existing xblock as a child of the supplied parent_usage_key.
|
|
"""
|
|
store = modulestore()
|
|
with store.bulk_operations(duplicate_source_usage_key.course_key):
|
|
source_item = store.get_item(duplicate_source_usage_key)
|
|
# Change the blockID to be unique.
|
|
dest_usage_key = source_item.location.replace(name=uuid4().hex)
|
|
category = dest_usage_key.block_type
|
|
|
|
# Update the display name to indicate this is a duplicate (unless display name provided).
|
|
# Can't use own_metadata(), b/c it converts data for JSON serialization -
|
|
# not suitable for setting metadata of the new block
|
|
duplicate_metadata = {}
|
|
for field in source_item.fields.values():
|
|
if field.scope == Scope.settings and field.is_set_on(source_item):
|
|
duplicate_metadata[field.name] = field.read_from(source_item)
|
|
|
|
if is_child:
|
|
display_name = display_name or source_item.display_name or source_item.category
|
|
|
|
if display_name is not None:
|
|
duplicate_metadata['display_name'] = display_name
|
|
else:
|
|
if source_item.display_name is None:
|
|
duplicate_metadata['display_name'] = _("Duplicate of {0}").format(source_item.category)
|
|
else:
|
|
duplicate_metadata['display_name'] = _("Duplicate of '{0}'").format(source_item.display_name)
|
|
|
|
asides_to_create = []
|
|
for aside in source_item.runtime.get_asides(source_item):
|
|
for field in aside.fields.values():
|
|
if field.scope in (Scope.settings, Scope.content,) and field.is_set_on(aside):
|
|
asides_to_create.append(aside)
|
|
break
|
|
|
|
for aside in asides_to_create:
|
|
for field in aside.fields.values():
|
|
if field.scope not in (Scope.settings, Scope.content,):
|
|
field.delete_from(aside)
|
|
|
|
dest_module = store.create_item(
|
|
user.id,
|
|
dest_usage_key.course_key,
|
|
dest_usage_key.block_type,
|
|
block_id=dest_usage_key.block_id,
|
|
definition_data=source_item.get_explicitly_set_fields_by_scope(Scope.content),
|
|
metadata=duplicate_metadata,
|
|
runtime=source_item.runtime,
|
|
asides=asides_to_create
|
|
)
|
|
|
|
children_handled = False
|
|
|
|
if hasattr(dest_module, 'studio_post_duplicate'):
|
|
# Allow an XBlock to do anything fancy it may need to when duplicated from another block.
|
|
# These blocks may handle their own children or parenting if needed. Let them return booleans to
|
|
# let us know if we need to handle these or not.
|
|
dest_module.xmodule_runtime = StudioEditModuleRuntime(user)
|
|
children_handled = dest_module.studio_post_duplicate(store, source_item)
|
|
|
|
# Children are not automatically copied over (and not all xblocks have a 'children' attribute).
|
|
# Because DAGs are not fully supported, we need to actually duplicate each child as well.
|
|
if source_item.has_children and not children_handled:
|
|
dest_module.children = dest_module.children or []
|
|
for child in source_item.children:
|
|
dupe = _duplicate_item(dest_module.location, child, user=user, is_child=True)
|
|
if dupe not in dest_module.children: # _duplicate_item may add the child for us.
|
|
dest_module.children.append(dupe)
|
|
store.update_item(dest_module, user.id)
|
|
|
|
# pylint: disable=protected-access
|
|
if 'detached' not in source_item.runtime.load_block_type(category)._class_tags:
|
|
parent = store.get_item(parent_usage_key)
|
|
# If source was already a child of the parent, add duplicate immediately afterward.
|
|
# Otherwise, add child to end.
|
|
if source_item.location in parent.children:
|
|
source_index = parent.children.index(source_item.location)
|
|
parent.children.insert(source_index + 1, dest_module.location)
|
|
else:
|
|
parent.children.append(dest_module.location)
|
|
store.update_item(parent, user.id)
|
|
|
|
return dest_module.location
|
|
|
|
|
|
@login_required
|
|
@expect_json
|
|
def delete_item(request, usage_key):
|
|
"""
|
|
Exposes internal helper method without breaking existing bindings/dependencies
|
|
"""
|
|
_delete_item(usage_key, request.user)
|
|
|
|
|
|
def _delete_item(usage_key, user):
|
|
"""
|
|
Deletes an existing xblock with the given usage_key.
|
|
If the xblock is a Static Tab, removes it from course.tabs as well.
|
|
"""
|
|
store = modulestore()
|
|
|
|
with store.bulk_operations(usage_key.course_key):
|
|
# VS[compat] cdodge: This is a hack because static_tabs also have references from the course module, so
|
|
# if we add one then we need to also add it to the policy information (i.e. metadata)
|
|
# we should remove this once we can break this reference from the course to static tabs
|
|
if usage_key.block_type == 'static_tab':
|
|
course = store.get_course(usage_key.course_key)
|
|
existing_tabs = course.tabs or []
|
|
course.tabs = [tab for tab in existing_tabs if tab.get('url_slug') != usage_key.block_id]
|
|
store.update_item(course, user.id)
|
|
|
|
# Delete user bookmarks
|
|
bookmarks_api.delete_bookmarks(usage_key)
|
|
store.delete_item(usage_key, user.id)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(("GET", "DELETE"))
|
|
def orphan_handler(request, course_key_string):
|
|
"""
|
|
View for handling orphan related requests. GET gets all of the current orphans.
|
|
DELETE removes all orphans (requires is_staff access)
|
|
|
|
An orphan is a block whose category is not in the DETACHED_CATEGORY list, is not the root, and is not reachable
|
|
from the root via children
|
|
"""
|
|
course_usage_key = CourseKey.from_string(course_key_string)
|
|
if request.method == 'GET':
|
|
if has_studio_read_access(request.user, course_usage_key):
|
|
return JsonResponse([str(item) for item in modulestore().get_orphans(course_usage_key)])
|
|
else:
|
|
raise PermissionDenied()
|
|
if request.method == 'DELETE':
|
|
if request.user.is_staff:
|
|
deleted_items = _delete_orphans(course_usage_key, request.user.id, commit=True)
|
|
return JsonResponse({'deleted': deleted_items})
|
|
else:
|
|
raise PermissionDenied()
|
|
|
|
|
|
def _delete_orphans(course_usage_key, user_id, commit=False):
|
|
"""
|
|
Helper function to delete orphans for a given course.
|
|
If `commit` is False, this function does not actually remove
|
|
the orphans.
|
|
"""
|
|
store = modulestore()
|
|
items = store.get_orphans(course_usage_key)
|
|
branch = course_usage_key.branch
|
|
if commit:
|
|
with store.bulk_operations(course_usage_key):
|
|
for itemloc in items:
|
|
revision = ModuleStoreEnum.RevisionOption.all
|
|
# specify branches when deleting orphans
|
|
if branch == ModuleStoreEnum.BranchName.published:
|
|
revision = ModuleStoreEnum.RevisionOption.published_only
|
|
store.delete_item(itemloc, user_id, revision=revision)
|
|
return [str(item) for item in items]
|
|
|
|
|
|
def _get_xblock(usage_key, user):
|
|
"""
|
|
Returns the xblock for the specified usage key. Note: if failing to find a key with a category
|
|
in the CREATE_IF_NOT_FOUND list, an xblock will be created and saved automatically.
|
|
"""
|
|
store = modulestore()
|
|
with store.bulk_operations(usage_key.course_key):
|
|
try:
|
|
return store.get_item(usage_key, depth=None)
|
|
except ItemNotFoundError:
|
|
if usage_key.block_type in CREATE_IF_NOT_FOUND:
|
|
# Create a new one for certain categories only. Used for course info handouts.
|
|
return store.create_item(
|
|
user.id,
|
|
usage_key.course_key,
|
|
usage_key.block_type,
|
|
block_id=usage_key.block_id)
|
|
else:
|
|
raise
|
|
except InvalidLocationError:
|
|
log.error("Can't find item by location.")
|
|
return JsonResponse({"error": "Can't find item by location: " + str(usage_key)}, 404)
|
|
|
|
|
|
def _get_module_info(xblock, rewrite_static_links=True, include_ancestor_info=False, include_publishing_info=False):
|
|
"""
|
|
metadata, data, id representation of a leaf module fetcher.
|
|
:param usage_key: A UsageKey
|
|
"""
|
|
with modulestore().bulk_operations(xblock.location.course_key):
|
|
data = getattr(xblock, 'data', '')
|
|
if rewrite_static_links:
|
|
data = replace_static_urls(
|
|
data,
|
|
None,
|
|
course_id=xblock.location.course_key
|
|
)
|
|
|
|
# Pre-cache has changes for the entire course because we'll need it for the ancestor info
|
|
# Except library blocks which don't [yet] use draft/publish
|
|
if not isinstance(xblock.location, LibraryUsageLocator):
|
|
modulestore().has_changes(modulestore().get_course(xblock.location.course_key, depth=None))
|
|
|
|
# Note that children aren't being returned until we have a use case.
|
|
xblock_info = create_xblock_info(
|
|
xblock, data=data, metadata=own_metadata(xblock), include_ancestor_info=include_ancestor_info
|
|
)
|
|
if include_publishing_info:
|
|
add_container_page_publishing_info(xblock, xblock_info)
|
|
|
|
return xblock_info
|
|
|
|
|
|
def _get_gating_info(course, xblock):
|
|
"""
|
|
Returns a dict containing gating information for the given xblock which
|
|
can be added to xblock info responses.
|
|
|
|
Arguments:
|
|
course (CourseBlock): The course
|
|
xblock (XBlock): The xblock
|
|
|
|
Returns:
|
|
dict: Gating information
|
|
"""
|
|
info = {}
|
|
if xblock.category == 'sequential' and course.enable_subsection_gating:
|
|
if not hasattr(course, 'gating_prerequisites'):
|
|
# Cache gating prerequisites on course module so that we are not
|
|
# hitting the database for every xblock in the course
|
|
course.gating_prerequisites = gating_api.get_prerequisites(course.id)
|
|
info["is_prereq"] = gating_api.is_prerequisite(course.id, xblock.location)
|
|
info["prereqs"] = [
|
|
p for p in course.gating_prerequisites if str(xblock.location) not in p['namespace']
|
|
]
|
|
prereq, prereq_min_score, prereq_min_completion = gating_api.get_required_content(
|
|
course.id,
|
|
xblock.location
|
|
)
|
|
info["prereq"] = prereq
|
|
info["prereq_min_score"] = prereq_min_score
|
|
info["prereq_min_completion"] = prereq_min_completion
|
|
if prereq:
|
|
info["visibility_state"] = VisibilityState.gated
|
|
return info
|
|
|
|
|
|
def create_xblock_info(xblock, data=None, metadata=None, include_ancestor_info=False, include_child_info=False, # lint-amnesty, pylint: disable=too-many-statements
|
|
course_outline=False, include_children_predicate=NEVER, parent_xblock=None, graders=None,
|
|
user=None, course=None, is_concise=False):
|
|
"""
|
|
Creates the information needed for client-side XBlockInfo.
|
|
|
|
If data or metadata are not specified, their information will not be added
|
|
(regardless of whether or not the xblock actually has data or metadata).
|
|
|
|
There are three optional boolean parameters:
|
|
include_ancestor_info - if true, ancestor info is added to the response
|
|
include_child_info - if true, direct child info is included in the response
|
|
is_concise - if true, returns the concise version of xblock info, default is false.
|
|
course_outline - if true, the xblock is being rendered on behalf of the course outline.
|
|
There are certain expensive computations that do not need to be included in this case.
|
|
|
|
In addition, an optional include_children_predicate argument can be provided to define whether or
|
|
not a particular xblock should have its children included.
|
|
"""
|
|
is_library_block = isinstance(xblock.location, LibraryUsageLocator)
|
|
is_xblock_unit = is_unit(xblock, parent_xblock)
|
|
# this should not be calculated for Sections and Subsections on Unit page or for library blocks
|
|
has_changes = None
|
|
if (is_xblock_unit or course_outline) and not is_library_block:
|
|
has_changes = modulestore().has_changes(xblock)
|
|
|
|
if graders is None:
|
|
if not is_library_block:
|
|
graders = CourseGradingModel.fetch(xblock.location.course_key).graders
|
|
else:
|
|
graders = []
|
|
|
|
# Filter the graders data as needed
|
|
graders = _filter_entrance_exam_grader(graders)
|
|
|
|
# We need to load the course in order to retrieve user partition information.
|
|
# For this reason, we load the course once and re-use it when recursively loading children.
|
|
if course is None:
|
|
course = modulestore().get_course(xblock.location.course_key)
|
|
|
|
# Compute the child info first so it can be included in aggregate information for the parent
|
|
should_visit_children = include_child_info and (course_outline and not is_xblock_unit or not course_outline)
|
|
if should_visit_children and xblock.has_children:
|
|
child_info = _create_xblock_child_info(
|
|
xblock,
|
|
course_outline,
|
|
graders,
|
|
include_children_predicate=include_children_predicate,
|
|
user=user,
|
|
course=course,
|
|
is_concise=is_concise
|
|
)
|
|
else:
|
|
child_info = None
|
|
|
|
release_date = _get_release_date(xblock, user)
|
|
|
|
if xblock.category != 'course' and not is_concise:
|
|
visibility_state = _compute_visibility_state(
|
|
xblock, child_info, is_xblock_unit and has_changes, is_self_paced(course)
|
|
)
|
|
else:
|
|
visibility_state = None
|
|
published = modulestore().has_published_version(xblock) if not is_library_block else None
|
|
published_on = get_default_time_display(xblock.published_on) if published and xblock.published_on else None
|
|
|
|
# defining the default value 'True' for delete, duplicate, drag and add new child actions
|
|
# in xblock_actions for each xblock.
|
|
xblock_actions = {'deletable': True, 'draggable': True, 'childAddable': True, 'duplicable': True}
|
|
explanatory_message = None
|
|
|
|
# is_entrance_exam is inherited metadata.
|
|
if xblock.category == 'chapter' and getattr(xblock, "is_entrance_exam", None):
|
|
# Entrance exam section should not be deletable, draggable and not have 'New Subsection' button.
|
|
xblock_actions['deletable'] = xblock_actions['childAddable'] = xblock_actions['draggable'] = False
|
|
if parent_xblock is None:
|
|
parent_xblock = get_parent_xblock(xblock)
|
|
|
|
# Translators: The {pct_sign} here represents the percent sign, i.e., '%'
|
|
# in many languages. This is used to avoid Transifex's misinterpreting of
|
|
# '% o'. The percent sign is also translatable as a standalone string.
|
|
explanatory_message = _('Students must score {score}{pct_sign} or higher to access course materials.').format(
|
|
score=int(parent_xblock.entrance_exam_minimum_score_pct * 100),
|
|
# Translators: This is the percent sign. It will be used to represent
|
|
# a percent value out of 100, e.g. "58%" means "58/100".
|
|
pct_sign=_('%'))
|
|
|
|
xblock_info = {
|
|
'id': str(xblock.location),
|
|
'display_name': xblock.display_name_with_default,
|
|
'category': xblock.category,
|
|
'has_children': xblock.has_children
|
|
}
|
|
if is_concise:
|
|
if child_info and child_info.get('children', []):
|
|
xblock_info['child_info'] = child_info
|
|
# Groups are labelled with their internal ids, rather than with the group name. Replace id with display name.
|
|
group_display_name = get_split_group_display_name(xblock, course)
|
|
xblock_info['display_name'] = group_display_name if group_display_name else xblock_info['display_name']
|
|
else:
|
|
user_partitions = get_user_partition_info(xblock, course=course)
|
|
xblock_info.update({
|
|
'edited_on': get_default_time_display(xblock.subtree_edited_on) if xblock.subtree_edited_on else None,
|
|
'published': published,
|
|
'published_on': published_on,
|
|
'studio_url': xblock_studio_url(xblock, parent_xblock),
|
|
'released_to_students': datetime.now(UTC) > xblock.start,
|
|
'release_date': release_date,
|
|
'visibility_state': visibility_state,
|
|
'has_explicit_staff_lock': xblock.fields['visible_to_staff_only'].is_set_on(xblock),
|
|
'start': xblock.fields['start'].to_json(xblock.start),
|
|
'graded': xblock.graded,
|
|
'due_date': get_default_time_display(xblock.due),
|
|
'due': xblock.fields['due'].to_json(xblock.due),
|
|
'format': xblock.format,
|
|
'course_graders': [grader.get('type') for grader in graders],
|
|
'has_changes': has_changes,
|
|
'actions': xblock_actions,
|
|
'explanatory_message': explanatory_message,
|
|
'group_access': xblock.group_access,
|
|
'user_partitions': user_partitions,
|
|
'show_correctness': xblock.show_correctness,
|
|
})
|
|
|
|
if xblock.category == 'sequential':
|
|
xblock_info.update({
|
|
'hide_after_due': xblock.hide_after_due,
|
|
})
|
|
elif xblock.category in ('chapter', 'course'):
|
|
if xblock.category == 'chapter':
|
|
xblock_info.update({
|
|
'highlights': xblock.highlights,
|
|
})
|
|
elif xblock.category == 'course':
|
|
xblock_info.update({
|
|
'highlights_enabled_for_messaging': course.highlights_enabled_for_messaging,
|
|
})
|
|
xblock_info.update({
|
|
'highlights_enabled': True, # used to be controlled by a waffle switch, now just always enabled
|
|
'highlights_preview_only': False, # used to be controlled by a waffle flag, now just always disabled
|
|
'highlights_doc_url': HelpUrlExpert.the_one().url_for_token('content_highlights'),
|
|
})
|
|
|
|
# update xblock_info with special exam information if the feature flag is enabled
|
|
if settings.FEATURES.get('ENABLE_SPECIAL_EXAMS'):
|
|
if xblock.category == 'course':
|
|
xblock_info.update({
|
|
'enable_proctored_exams': xblock.enable_proctored_exams,
|
|
'create_zendesk_tickets': xblock.create_zendesk_tickets,
|
|
'enable_timed_exams': xblock.enable_timed_exams,
|
|
})
|
|
elif xblock.category == 'sequential':
|
|
rules_url = settings.PROCTORING_SETTINGS.get('LINK_URLS', {}).get('online_proctoring_rules', "")
|
|
supports_onboarding = does_backend_support_onboarding(course.proctoring_provider)
|
|
|
|
proctoring_exam_configuration_link = None
|
|
if xblock.is_proctored_exam:
|
|
proctoring_exam_configuration_link = get_exam_configuration_dashboard_url(
|
|
course.id, xblock_info['id'])
|
|
|
|
if course.proctoring_provider == 'proctortrack':
|
|
show_review_rules = SHOW_REVIEW_RULES_FLAG.is_enabled(xblock.location.course_key)
|
|
else:
|
|
show_review_rules = True
|
|
|
|
xblock_info.update({
|
|
'is_proctored_exam': xblock.is_proctored_exam,
|
|
'was_ever_special_exam': _was_xblock_ever_special_exam(
|
|
course, xblock
|
|
),
|
|
'online_proctoring_rules': rules_url,
|
|
'is_practice_exam': xblock.is_practice_exam,
|
|
'is_onboarding_exam': xblock.is_onboarding_exam,
|
|
'is_time_limited': xblock.is_time_limited,
|
|
'exam_review_rules': xblock.exam_review_rules,
|
|
'default_time_limit_minutes': xblock.default_time_limit_minutes,
|
|
'proctoring_exam_configuration_link': proctoring_exam_configuration_link,
|
|
'supports_onboarding': supports_onboarding,
|
|
'show_review_rules': show_review_rules
|
|
})
|
|
|
|
# Update with gating info
|
|
xblock_info.update(_get_gating_info(course, xblock))
|
|
|
|
if xblock.category == 'sequential':
|
|
# Entrance exam subsection should be hidden. in_entrance_exam is
|
|
# inherited metadata, all children will have it.
|
|
if getattr(xblock, 'in_entrance_exam', False):
|
|
xblock_info['is_header_visible'] = False
|
|
|
|
if data is not None:
|
|
xblock_info['data'] = data
|
|
if metadata is not None:
|
|
xblock_info['metadata'] = metadata
|
|
if include_ancestor_info:
|
|
xblock_info['ancestor_info'] = _create_xblock_ancestor_info(xblock, course_outline, include_child_info=True)
|
|
if child_info:
|
|
xblock_info['child_info'] = child_info
|
|
if visibility_state == VisibilityState.staff_only:
|
|
xblock_info['ancestor_has_staff_lock'] = ancestor_has_staff_lock(xblock, parent_xblock)
|
|
else:
|
|
xblock_info['ancestor_has_staff_lock'] = False
|
|
|
|
if course_outline:
|
|
if xblock_info['has_explicit_staff_lock']:
|
|
xblock_info['staff_only_message'] = True
|
|
elif child_info and child_info['children']:
|
|
xblock_info['staff_only_message'] = all(
|
|
child['staff_only_message'] for child in child_info['children']
|
|
)
|
|
else:
|
|
xblock_info['staff_only_message'] = False
|
|
|
|
xblock_info['has_partition_group_components'] = has_children_visible_to_specific_partition_groups(
|
|
xblock
|
|
)
|
|
xblock_info['user_partition_info'] = get_visibility_partition_info(xblock, course=course)
|
|
|
|
return xblock_info
|
|
|
|
|
|
def _was_xblock_ever_special_exam(course, xblock):
|
|
"""
|
|
Determine whether this XBlock is or was ever configured as a special exam.
|
|
|
|
If this block is *not* currently a special exam, the best way for us to tell
|
|
whether it was was *ever* configured as a special exam is by checking whether
|
|
edx-proctoring has an exam record associated with the block's ID.
|
|
If an exception is not raised, then we know that such a record exists,
|
|
indicating that this *was* once a special exam.
|
|
|
|
Arguments:
|
|
course (CourseBlock)
|
|
xblock (XBlock)
|
|
|
|
Returns: bool
|
|
"""
|
|
if xblock.is_time_limited:
|
|
return True
|
|
try:
|
|
get_exam_by_content_id(course.id, xblock.location)
|
|
except ProctoredExamNotFoundException:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
|
|
def add_container_page_publishing_info(xblock, xblock_info):
|
|
"""
|
|
Adds information about the xblock's publish state to the supplied
|
|
xblock_info for the container page.
|
|
"""
|
|
def safe_get_username(user_id):
|
|
"""
|
|
Guard against bad user_ids, like the infamous "**replace_user**".
|
|
Note that this will ignore our special known IDs (ModuleStoreEnum.UserID).
|
|
We should consider adding special handling for those values.
|
|
|
|
:param user_id: the user id to get the username of
|
|
:return: username, or None if the user does not exist or user_id is None
|
|
"""
|
|
if user_id:
|
|
try:
|
|
return User.objects.get(id=user_id).username
|
|
except: # pylint: disable=bare-except
|
|
pass
|
|
|
|
return None
|
|
|
|
xblock_info["edited_by"] = safe_get_username(xblock.subtree_edited_by)
|
|
xblock_info["published_by"] = safe_get_username(xblock.published_by)
|
|
xblock_info["currently_visible_to_students"] = is_currently_visible_to_students(xblock)
|
|
xblock_info["has_partition_group_components"] = has_children_visible_to_specific_partition_groups(xblock)
|
|
if xblock_info["release_date"]:
|
|
xblock_info["release_date_from"] = _get_release_date_from(xblock)
|
|
if xblock_info["visibility_state"] == VisibilityState.staff_only:
|
|
xblock_info["staff_lock_from"] = _get_staff_lock_from(xblock)
|
|
else:
|
|
xblock_info["staff_lock_from"] = None
|
|
|
|
|
|
class VisibilityState:
|
|
"""
|
|
Represents the possible visibility states for an xblock:
|
|
|
|
live - the block and all of its descendants are live to students (excluding staff only items)
|
|
Note: Live means both published and released.
|
|
|
|
ready - the block is ready to go live and all of its descendants are live or ready (excluding staff only items)
|
|
Note: content is ready when it is published and scheduled with a release date in the future.
|
|
|
|
unscheduled - the block and all of its descendants have no release date (excluding staff only items)
|
|
Note: it is valid for items to be published with no release date in which case they are still unscheduled.
|
|
|
|
needs_attention - the block or its descendants are not fully live, ready or unscheduled
|
|
(excluding staff only items)
|
|
For example: one subsection has draft content, or there's both unreleased and released content in one section.
|
|
|
|
staff_only - all of the block's content is to be shown to staff only
|
|
Note: staff only items do not affect their parent's state.
|
|
|
|
gated - all of the block's content is to be shown to students only after the configured prerequisite is met
|
|
"""
|
|
live = 'live'
|
|
ready = 'ready'
|
|
unscheduled = 'unscheduled'
|
|
needs_attention = 'needs_attention'
|
|
staff_only = 'staff_only'
|
|
gated = 'gated'
|
|
|
|
|
|
def _compute_visibility_state(xblock, child_info, is_unit_with_changes, is_course_self_paced=False):
|
|
"""
|
|
Returns the current publish state for the specified xblock and its children
|
|
"""
|
|
if xblock.visible_to_staff_only:
|
|
return VisibilityState.staff_only
|
|
elif is_unit_with_changes:
|
|
# Note that a unit that has never been published will fall into this category,
|
|
# as well as previously published units with draft content.
|
|
return VisibilityState.needs_attention
|
|
|
|
is_unscheduled = xblock.start == DEFAULT_START_DATE
|
|
is_live = is_course_self_paced or datetime.now(UTC) > xblock.start
|
|
if child_info and child_info.get('children', []):
|
|
all_staff_only = True
|
|
all_unscheduled = True
|
|
all_live = True
|
|
for child in child_info['children']:
|
|
child_state = child['visibility_state']
|
|
if child_state == VisibilityState.needs_attention:
|
|
return child_state
|
|
elif not child_state == VisibilityState.staff_only:
|
|
all_staff_only = False
|
|
if not child_state == VisibilityState.unscheduled:
|
|
all_unscheduled = False
|
|
if not child_state == VisibilityState.live:
|
|
all_live = False
|
|
if all_staff_only:
|
|
return VisibilityState.staff_only
|
|
elif all_unscheduled:
|
|
return VisibilityState.unscheduled if is_unscheduled else VisibilityState.needs_attention
|
|
elif all_live:
|
|
return VisibilityState.live if is_live else VisibilityState.needs_attention
|
|
else:
|
|
return VisibilityState.ready if not is_unscheduled else VisibilityState.needs_attention
|
|
if is_live:
|
|
return VisibilityState.live
|
|
elif is_unscheduled:
|
|
return VisibilityState.unscheduled
|
|
else:
|
|
return VisibilityState.ready
|
|
|
|
|
|
def _create_xblock_ancestor_info(xblock, course_outline=False, include_child_info=False, is_concise=False):
|
|
"""
|
|
Returns information about the ancestors of an xblock. Note that the direct parent will also return
|
|
information about all of its children.
|
|
"""
|
|
ancestors = []
|
|
|
|
def collect_ancestor_info(ancestor, include_child_info=False, is_concise=False):
|
|
"""
|
|
Collect xblock info regarding the specified xblock and its ancestors.
|
|
"""
|
|
if ancestor:
|
|
direct_children_only = lambda parent: parent == ancestor
|
|
ancestors.append(create_xblock_info(
|
|
ancestor,
|
|
include_child_info=include_child_info,
|
|
course_outline=course_outline,
|
|
include_children_predicate=direct_children_only,
|
|
is_concise=is_concise
|
|
))
|
|
collect_ancestor_info(get_parent_xblock(ancestor), is_concise=is_concise)
|
|
collect_ancestor_info(get_parent_xblock(xblock), include_child_info=include_child_info, is_concise=is_concise)
|
|
return {
|
|
'ancestors': ancestors
|
|
}
|
|
|
|
|
|
def _create_xblock_child_info(xblock, course_outline, graders, include_children_predicate=NEVER, user=None,
|
|
course=None, is_concise=False):
|
|
"""
|
|
Returns information about the children of an xblock, as well as about the primary category
|
|
of xblock expected as children.
|
|
"""
|
|
child_info = {}
|
|
child_category = xblock_primary_child_category(xblock)
|
|
if child_category:
|
|
child_info = {
|
|
'category': child_category,
|
|
'display_name': xblock_type_display_name(child_category, default_display_name=child_category),
|
|
}
|
|
if xblock.has_children and include_children_predicate(xblock):
|
|
child_info['children'] = [
|
|
create_xblock_info(
|
|
child, include_child_info=True, course_outline=course_outline,
|
|
include_children_predicate=include_children_predicate,
|
|
parent_xblock=xblock,
|
|
graders=graders,
|
|
user=user,
|
|
course=course,
|
|
is_concise=is_concise
|
|
) for child in xblock.get_children()
|
|
]
|
|
return child_info
|
|
|
|
|
|
def _get_release_date(xblock, user=None):
|
|
"""
|
|
Returns the release date for the xblock, or None if the release date has never been set.
|
|
"""
|
|
# If year of start date is less than 1900 then reset the start date to DEFAULT_START_DATE
|
|
reset_to_default = False
|
|
try:
|
|
reset_to_default = xblock.start.year < 1900
|
|
except ValueError:
|
|
# For old mongo courses, accessing the start attribute calls `to_json()`,
|
|
# which raises a `ValueError` for years < 1900.
|
|
reset_to_default = True
|
|
|
|
if reset_to_default and user:
|
|
xblock.start = DEFAULT_START_DATE
|
|
xblock = _update_with_callback(xblock, user)
|
|
|
|
# Treat DEFAULT_START_DATE as a magic number that means the release date has not been set
|
|
return get_default_time_display(xblock.start) if xblock.start != DEFAULT_START_DATE else None
|
|
|
|
|
|
def validate_and_update_xblock_due_date(xblock):
|
|
"""
|
|
Validates the due date for the xblock, and set to None if pre-1900 due date provided
|
|
"""
|
|
if xblock.due and xblock.due.year < 1900:
|
|
xblock.due = None
|
|
|
|
|
|
def _get_release_date_from(xblock):
|
|
"""
|
|
Returns a string representation of the section or subsection that sets the xblock's release date
|
|
"""
|
|
return _xblock_type_and_display_name(find_release_date_source(xblock))
|
|
|
|
|
|
def _get_staff_lock_from(xblock):
|
|
"""
|
|
Returns a string representation of the section or subsection that sets the xblock's release date
|
|
"""
|
|
source = find_staff_lock_source(xblock)
|
|
return _xblock_type_and_display_name(source) if source else None
|
|
|
|
|
|
def _xblock_type_and_display_name(xblock):
|
|
"""
|
|
Returns a string representation of the xblock's type and display name
|
|
"""
|
|
return _('{section_or_subsection} "{display_name}"').format(
|
|
section_or_subsection=xblock_type_display_name(xblock),
|
|
display_name=xblock.display_name_with_default)
|