aa7370c773
This makes a couple of changes to the xblock handler in the CMS. These changes add a handful of utility functions and modify the existing ones to make reuse of existing blocks easier. With these changes, it is possible to copy an entire section from one course to another, and then later refresh that section, and all of its children, without destroying the blocks next to it. The existing _duplicate_block function was modified to have a shallow keyword to avoid copying children, and the update_from_source function was added to make it easy to copy attributes over from one block to another. These functions can be used alongside copy_from_template in the modulestore to copy over blocks and their children without requiring them to be within any particular container (other than a library or course root)-- thus allowing library-like inclusion without the library content block. This is especially useful for cases like copying sections rather than unit content.
137 lines
6.1 KiB
Python
137 lines
6.1 KiB
Python
# lint-amnesty, pylint: disable=missing-module-docstring
|
|
import hashlib
|
|
import logging
|
|
import re
|
|
import uuid
|
|
from collections import namedtuple
|
|
|
|
from xblock.core import XBlock
|
|
|
|
from xmodule.modulestore.split_mongo import BlockKey
|
|
|
|
DETACHED_XBLOCK_TYPES = {name for name, __ in XBlock.load_tagged_classes("detached")}
|
|
|
|
|
|
def _prefix_only_url_replace_regex(pattern):
|
|
"""
|
|
Match urls in quotes pulling out the fields from pattern
|
|
"""
|
|
return re.compile("""
|
|
(?x) # flags=re.VERBOSE
|
|
(?P<quote>\\\\?['"]) # the opening quotes
|
|
{}
|
|
(?P=quote) # the first matching closing quote
|
|
""".format(pattern))
|
|
|
|
|
|
def rewrite_nonportable_content_links(source_course_id, dest_course_id, text):
|
|
"""
|
|
rewrite any non-portable links to (->) relative links:
|
|
/c4x/<org>/<course>/asset/<name> -> /static/<name>
|
|
/jump_to/i4x://<org>/<course>/<category>/<name> -> /jump_to_id/<id>
|
|
"""
|
|
|
|
def portable_asset_link_subtitution(match):
|
|
quote = match.group('quote')
|
|
block_id = match.group('block_id')
|
|
return quote + '/static/' + block_id + quote
|
|
|
|
def portable_jump_to_link_substitution(match):
|
|
quote = match.group('quote')
|
|
rest = match.group('block_id')
|
|
return quote + '/jump_to_id/' + rest + quote
|
|
|
|
# if something blows up, log the error and continue
|
|
|
|
# create a serialized template for what the id will look like in the source_course but with
|
|
# the block_id as a regex pattern
|
|
placeholder_id = uuid.uuid4().hex
|
|
asset_block_pattern = str(source_course_id.make_asset_key('asset', placeholder_id))
|
|
asset_block_pattern = asset_block_pattern.replace(placeholder_id, r'(?P<block_id>.*?)')
|
|
try:
|
|
text = _prefix_only_url_replace_regex(asset_block_pattern).sub(portable_asset_link_subtitution, text)
|
|
except Exception as exc: # pylint: disable=broad-except
|
|
logging.warning("Error producing regex substitution %r for text = %r.\n\nError msg = %s", asset_block_pattern, text, str(exc)) # lint-amnesty, pylint: disable=line-too-long
|
|
|
|
placeholder_category = f'cat_{uuid.uuid4().hex}'
|
|
usage_block_pattern = str(source_course_id.make_usage_key(placeholder_category, placeholder_id))
|
|
usage_block_pattern = usage_block_pattern.replace(placeholder_category, r'(?P<category>[^/+@]+)')
|
|
usage_block_pattern = usage_block_pattern.replace(placeholder_id, r'(?P<block_id>.*?)')
|
|
jump_to_link_base = '/courses/{course_key_string}/jump_to/{usage_key_string}'.format(
|
|
course_key_string=str(source_course_id), usage_key_string=usage_block_pattern
|
|
)
|
|
try:
|
|
text = _prefix_only_url_replace_regex(jump_to_link_base).sub(portable_jump_to_link_substitution, text)
|
|
except Exception as exc: # pylint: disable=broad-except
|
|
logging.warning("Error producing regex substitution %r for text = %r.\n\nError msg = %s", jump_to_link_base, text, str(exc)) # lint-amnesty, pylint: disable=line-too-long
|
|
|
|
# Also, there commonly is a set of link URL's used in the format:
|
|
# /courses/<org>/<course>/<name> which will be broken if migrated to a different course_id
|
|
# so let's rewrite those, but the target will also be non-portable,
|
|
#
|
|
# Note: we only need to do this if we are changing course-id's
|
|
#
|
|
if source_course_id != dest_course_id:
|
|
try:
|
|
generic_courseware_link_base = f'/courses/{str(source_course_id)}/'
|
|
text = re.sub(_prefix_only_url_replace_regex(generic_courseware_link_base), portable_asset_link_subtitution, text) # lint-amnesty, pylint: disable=line-too-long
|
|
except Exception as exc: # pylint: disable=broad-except
|
|
logging.warning("Error producing regex substitution %r for text = %r.\n\nError msg = %s", source_course_id, text, str(exc)) # lint-amnesty, pylint: disable=line-too-long
|
|
|
|
return text
|
|
|
|
|
|
def draft_node_constructor(block, url, parent_url, location=None, parent_location=None, index=None):
|
|
"""
|
|
Contructs a draft_node namedtuple with defaults.
|
|
"""
|
|
draft_node = namedtuple('draft_node', ['module', 'location', 'url', 'parent_location', 'parent_url', 'index'])
|
|
return draft_node(block, location, url, parent_location, parent_url, index)
|
|
|
|
|
|
def get_draft_subtree_roots(draft_nodes):
|
|
"""
|
|
Takes a list of draft_nodes, which are namedtuples, each of which identify
|
|
itself and its parent.
|
|
|
|
If a draft_node is in `draft_nodes`, then we expect for all its children
|
|
should be in `draft_nodes` as well. Since `_import_draft` is recursive,
|
|
we only want to import the roots of any draft subtrees contained in
|
|
`draft_nodes`.
|
|
|
|
This generator yields those roots.
|
|
"""
|
|
urls = [draft_node.url for draft_node in draft_nodes]
|
|
|
|
for draft_node in draft_nodes:
|
|
if draft_node.parent_url not in urls:
|
|
yield draft_node
|
|
|
|
|
|
def derived_key(courselike_source_key, block_key, dest_parent: BlockKey):
|
|
"""
|
|
Return a new reproducible block ID for a given root, source block, and destination parent.
|
|
|
|
When recursively copying a block structure, we need to generate new block IDs for the
|
|
blocks. We don't want to use the exact same IDs as we might copy blocks multiple times.
|
|
However, we do want to be able to reproduce the same IDs when copying the same block
|
|
so that if we ever need to re-copy the block from its source (that is, to update it with
|
|
upstream changes) we don't affect any data tied to the ID, such as grades.
|
|
|
|
This is used by the copy_from_template function of the modulestore, and can be used by
|
|
pluggable django apps that need to copy blocks from one course to another in an
|
|
idempotent way. In the future, this should be created into a proper API function
|
|
in the spirit of OEP-49.
|
|
"""
|
|
hashable_source_id = courselike_source_key.for_version(None)
|
|
|
|
# Compute a new block ID. This new block ID must be consistent when this
|
|
# method is called with the same (source_key, dest_structure) pair
|
|
unique_data = "{}:{}:{}".format(
|
|
str(hashable_source_id).encode("utf-8"),
|
|
block_key.id,
|
|
dest_parent.id,
|
|
)
|
|
new_block_id = hashlib.sha1(unique_data.encode('utf-8')).hexdigest()[:20]
|
|
return BlockKey(block_key.type, new_block_id)
|