fix: add ResourceTemplates

Author: irtazaakram

xblocks_contrib/html/html.py

@@ -3,8 +3,12 @@
 This XBlock allows users to embed HTML content inside courses.
 """
 
+import logging
+import os
 import re
+from importlib import resources
 
+import yaml
 from django.conf import settings
 from django.utils.translation import gettext_noop as _
 from web_fragments.fragment import Fragment
@@ -14,15 +18,148 @@
 
 from xblocks_contrib.html.utils import escape_html_characters
 
+log = logging.getLogger(__name__)
+
 resource_loader = ResourceLoader(__name__)
 
 # The global (course-agnostic) anonymous user ID for the user.
 ATTR_KEY_DEPRECATED_ANONYMOUS_USER_ID = "edx-platform.deprecated_anonymous_user_id"
 
 
+class ResourceTemplates:
+    """
+    Gets the yaml templates associated with a containing cls for display in the Studio.
+
+    The cls must have a 'template_dir_name' attribute. It finds the templates as directly
+    in this directory under 'templates'.
+
+    Additional templates can be loaded by setting the
+    CUSTOM_RESOURCE_TEMPLATES_DIRECTORY configuration setting.
+
+    Note that a template must end with ".yaml" extension otherwise it will not be
+    loaded.
+    """
+
+    template_packages = [__name__]
+
+    @classmethod
+    def _load_template(cls, template_path, template_id):
+        """
+        Reads an loads the yaml content provided in the template_path and
+        return the content as a dictionary.
+        """
+        if not os.path.exists(template_path):
+            return None
+
+        with open(template_path) as file_object:
+            template = yaml.safe_load(file_object)
+            template["template_id"] = template_id
+            return template
+
+    @classmethod
+    def _load_templates_in_dir(cls, dirpath):
+        """
+        Lists every resource template found in the provided dirpath.
+        """
+        templates = []
+        for template_file in os.listdir(dirpath):
+            if not template_file.endswith(".yaml"):
+                log.warning("Skipping unknown template file %s", template_file)
+                continue
+
+            template = cls._load_template(os.path.join(dirpath, template_file), template_file)
+            templates.append(template)
+        return templates
+
+    @classmethod
+    def templates(cls):
+        """
+        Returns a list of dictionary field: value objects that describe possible templates that can be used
+        to seed a module of this type.
+
+        Expects a class attribute template_dir_name that defines the directory
+        inside the 'templates' resource directory to pull templates from.
+        """
+        templates = {}
+
+        for dirpath in cls.get_template_dirpaths():
+            for template in cls._load_templates_in_dir(dirpath):
+                templates[template["template_id"]] = template
+
+        return list(templates.values())
+
+    @classmethod
+    def get_template_dir(cls):  # lint-amnesty, pylint: disable=missing-function-docstring
+        if getattr(cls, "template_dir_name", None):
+            dirname = os.path.join("templates", cls.template_dir_name)  # lint-amnesty, pylint: disable=no-member
+            template_path = resources.files(__name__.rsplit(".", 1)[0]) / dirname
+
+            if not template_path.is_dir():
+                log.warning(
+                    "No resource directory {dir} found when loading {cls_name} templates".format(
+                        dir=dirname,
+                        cls_name=cls.__name__,
+                    )
+                )
+                return
+            return dirname
+        return
+
+    @classmethod
+    def get_template_dirpaths(cls):
+        """
+        Returns of list of directories containing resource templates.
+        """
+        template_dirpaths = []
+        template_dirname = cls.get_template_dir()
+        if template_dirname:
+            template_path = resources.files(__name__.rsplit(".", 1)[0]) / template_dirname
+            if template_path.is_dir():
+                with resources.as_file(template_path) as template_real_path:
+                    template_dirpaths.append(str(template_real_path))
+
+        custom_template_dir = cls.get_custom_template_dir()
+        if custom_template_dir:
+            template_dirpaths.append(custom_template_dir)
+        return template_dirpaths
+
+    @classmethod
+    def get_custom_template_dir(cls):
+        """
+        If settings.CUSTOM_RESOURCE_TEMPLATES_DIRECTORY is defined, check if it has a
+        subdirectory named as the class's template_dir_name and return the full path.
+        """
+        template_dir_name = getattr(cls, "template_dir_name", None)
+
+        if template_dir_name is None:
+            return
+
+        resource_dir = settings.CUSTOM_RESOURCE_TEMPLATES_DIRECTORY
+
+        if not resource_dir:
+            return None
+
+        template_dir_path = os.path.join(resource_dir, template_dir_name)
+
+        if os.path.exists(template_dir_path):
+            return template_dir_path
+        return None
+
+    @classmethod
+    def get_template(cls, template_id):
+        """
+        Get a single template by the given id (which is the file name identifying it w/in the class's
+        template_dir_name)
+        """
+        for directory in sorted(cls.get_template_dirpaths(), reverse=True):
+            abs_path = os.path.join(directory, template_id)
+            if os.path.exists(abs_path):
+                return cls._load_template(abs_path, template_id)
+
+
 @XBlock.needs("i18n")
 @XBlock.needs("user")
-class HtmlBlock(XBlock):
+class HtmlBlock(ResourceTemplates, XBlock):
     """
     The HTML XBlock
     This provides the base class for all Html-ish blocks (including the HTML XBlock).
@@ -117,39 +254,11 @@ def public_view(self, context):
         """
         return self.student_view(context)
 
-    # def studio_view(self, context):  # pylint: disable=unused-argument
-    #     """
-    #     Generates a fragment that redirects to the new Studio editor URL.
-    #     """
-    #     course_key = self.runtime.course_id
-    #     block_id = str(self.scope_ids.usage_id)
-
-    #     new_url = f"http://apps.local.openedx.io:2001/authoring/course/{course_key}/editor/html/{block_id}"
-
-    #     fragment = Fragment()
-    #     fragment.add_content(
-    #         f"""
-    #         <script>
-    #             window.location.href = "{new_url}";
-    #         </script>
-    #     """
-    #     )
-    #     return fragment
-
     def studio_view(self, context=None):  # pylint: disable=unused-argument
         """
         Return the studio view, which redirects to the frontend-app-authoring editor.
         """
-        fragment = Fragment()
-        fragment.add_content(f"""
-            <div class="xblock-editor-redirect">
-                <a href="/authoring/course/{self.location.course_key}/editor/html/{self.location}" class="btn btn-primary">
-                    {_("Edit Content")}
-                </a>
-            </div>
-        """)
-        fragment.add_css(resource_loader.load_unicode("static/css/html_editor.css"))
-        return fragment
+        raise NotImplementedError("The studio view is not implemented. Please use the new Studio editor URL.")
 
     @staticmethod
     def workbench_scenarios():