def assets(self): """ Returns every block assets from Blockstore """ if not hasattr(self, '_assets') or not self._assets: # pylint: disable=access-member-before-definition self._assets = library_api.get_library_block_static_asset_files( # pylint: disable=attribute-defined-outside-init, # noqa: E501 self.location, # pylint: disable=no-member ) return self._assets
def get(self, request, usage_key_str): """ List the static asset files belonging to this block. """ key = LibraryUsageLocatorV2.from_string(usage_key_str) api.require_permission_for_library_key(key.lib_key, request.user, permissions.CAN_VIEW_THIS_CONTENT_LIBRARY) files = api.get_library_block_static_asset_files(key) return Response(LibraryXBlockStaticFilesSerializer({"files": files}).data)
def get(self, request, usage_key_str, file_path): """ Get a static asset file belonging to this block. """ key = LibraryUsageLocatorV2.from_string(usage_key_str) api.require_permission_for_library_key(key.lib_key, request.user, permissions.CAN_VIEW_THIS_CONTENT_LIBRARY) files = api.get_library_block_static_asset_files(key) for f in files: if f.path == file_path: return Response(LibraryXBlockStaticFileSerializer(f).data) raise NotFound
def test_import_from_blockstore(self): # Create a blockstore content library library = self._create_library(slug="testlib1_import", title="A Test Library", description="Testing XBlocks") # Create a unit block with an HTML block in it. unit_block_id = self._add_block_to_library(library["id"], "unit", "unit1")["id"] html_block_id = self._add_block_to_library(library["id"], "html", "html1", parent_block=unit_block_id)["id"] html_block = load_block(UsageKey.from_string(html_block_id), self.user) # Add assets and content to the HTML block self._set_library_block_asset(html_block_id, "test.txt", b"data", expect_response=200) self._set_library_block_olx(html_block_id, '<html><a href="/static/test.txt">Hello world</a></html>') # Create a modulestore course course = CourseFactory.create(modulestore=self.store, user_id=self.user.id) CourseInstructorRole(course.id).add_users(self.user) # Add Source from library block to the course sourced_block = self.make_block("library_sourced", course, user_id=self.user.id) # Import the unit block from the library to the course self.tools.import_from_blockstore(sourced_block, unit_block_id) # Verify imported block with its children self.assertEqual(len(sourced_block.children), 1) self.assertEqual(sourced_block.children[0].category, 'unit') imported_unit_block = self.store.get_item(sourced_block.children[0]) self.assertEqual(len(imported_unit_block.children), 1) self.assertEqual(imported_unit_block.children[0].category, 'html') imported_html_block = self.store.get_item(imported_unit_block.children[0]) self.assertIn('Hello world', imported_html_block.data) # Check that assets were imported and static paths were modified after importing assets = library_api.get_library_block_static_asset_files(html_block.scope_ids.usage_id) self.assertEqual(len(assets), 1) self.assertIn(assets[0].url, imported_html_block.data) # Check that reimporting updates the target block self._set_library_block_olx(html_block_id, '<html><a href="/static/test.txt">Foo bar</a></html>') self.tools.import_from_blockstore(sourced_block, unit_block_id) self.assertEqual(len(sourced_block.children), 1) imported_unit_block = self.store.get_item(sourced_block.children[0]) self.assertEqual(len(imported_unit_block.children), 1) imported_html_block = self.store.get_item(imported_unit_block.children[0]) self.assertNotIn('Hello world', imported_html_block.data) self.assertIn('Foo bar', imported_html_block.data)
def _import_block(self, source_block, dest_parent_key): """ Recursively import a blockstore block and its children. See import_from_blockstore above. """ def generate_block_key(source_key, dest_parent_key): """ Deterministically generate an ID for the new block and return the key """ block_id = ( dest_parent_key.block_id[:10] + '-' + hashlib.sha1(str(source_key).encode('utf-8')).hexdigest()[:10]) return dest_parent_key.context_key.make_usage_key( source_key.block_type, block_id) source_key = source_block.scope_ids.usage_id new_block_key = generate_block_key(source_key, dest_parent_key) try: new_block = self.store.get_item(new_block_key) if new_block.parent != dest_parent_key: raise ValueError( "Expected existing block {} to be a child of {} but instead it's a child of {}" .format( new_block_key, dest_parent_key, new_block.parent, )) except ItemNotFoundError: new_block = self.store.create_child( user_id=self.user_id, parent_usage_key=dest_parent_key, block_type=source_key.block_type, block_id=new_block_key.block_id, ) # Prepare a list of this block's static assets; any assets that are referenced as /static/{path} (the # recommended way for referencing them) will stop working, and so we rewrite the url when importing. # Copying assets not advised because modulestore doesn't namespace assets to each block like blockstore, which # might cause conflicts when the same filename is used across imported blocks. if isinstance(source_key, LibraryUsageLocatorV2): all_assets = library_api.get_library_block_static_asset_files( source_key) else: all_assets = [] for field_name, field in source_block.fields.items(): if field.scope not in (Scope.settings, Scope.content): continue # Only copy authored field data if field.is_set_on(source_block) or field.is_set_on(new_block): field_value = getattr(source_block, field_name) if isinstance(field_value, str): # If string field (which may also be JSON/XML data), rewrite /static/... URLs to point to blockstore for asset in all_assets: field_value = field_value.replace( '/static/{}'.format(asset.path), asset.url) setattr(new_block, field_name, field_value) new_block.save() self.store.update_item(new_block, self.user_id) if new_block.has_children: # Delete existing children in the new block, which can be reimported again if they still exist in the # source library for existing_child_key in new_block.children: self.store.delete_item(existing_child_key, self.user_id) # Now import the children for child in source_block.get_children(): self._import_block(child, new_block_key) return new_block_key