django-spire 0.17.11__py3-none-any.whl → 0.18.0__py3-none-any.whl

django_spire/knowledge/entry/version/block/services/service.py

@@ -1,16 +1,10 @@
 from __future__ import annotations
 
-from django_spire.contrib.ordering.services.service import OrderingService
-from django_spire.contrib.service import BaseDjangoModelService
-
 from typing import TYPE_CHECKING
 
+from django_spire.contrib.service import BaseDjangoModelService
 from django_spire.knowledge.entry.version.block.services.factory_service import \
     EntryVersionBlockFactoryService
-from django_spire.knowledge.entry.version.block.services.processor_service import \
-    EntryVersionBlockProcessorService
-from django_spire.knowledge.entry.version.block.services.transformation_service import \
-    EntryVersionBlockTransformationService
 
 if TYPE_CHECKING:
     from django_spire.knowledge.entry.version.block.models import EntryVersionBlock
@@ -18,8 +12,4 @@ if TYPE_CHECKING:
 
 class EntryVersionBlockService(BaseDjangoModelService['EntryVersionBlock']):
     obj: EntryVersionBlock
-
-    factory = EntryVersionBlockFactoryService()
-    ordering = OrderingService()
-    processor = EntryVersionBlockProcessorService()
-    transformation = EntryVersionBlockTransformationService()
+    factory = EntryVersionBlockFactoryService()

django_spire/knowledge/entry/version/block/tests/factories.py

@@ -2,13 +2,26 @@ from __future__ import annotations
 
 import json
 
-from django_spire.knowledge.entry.version.block.blocks.text_block import TextBlock
 from django_spire.knowledge.entry.version.block.choices import BlockTypeChoices
+from django_spire.knowledge.entry.version.block.data.text_data import \
+    TextEditorBlockData
 from django_spire.knowledge.entry.version.block.models import EntryVersionBlock
 from django_spire.knowledge.entry.version.tests.factories import \
     create_test_entry_version
 
 
+def create_test_block_form_data(**kwargs) -> dict:
+    data = {
+        'block_order': 0,
+        'block_type': BlockTypeChoices.TEXT,
+        'block_data': {'text': 'test text'},
+        'block_tunes': {}
+    }
+
+    data.update(kwargs)
+    return data
+
+
 def create_test_version_block(**kwargs) -> EntryVersionBlock:
     data = {
         'version': create_test_entry_version(),
@@ -17,9 +30,12 @@ def create_test_version_block(**kwargs) -> EntryVersionBlock:
         '_block_data': json.dumps({}),
         '_text_data': ''
     }
+
     data.update(kwargs)
     version_block = EntryVersionBlock.objects.create(**data)
-    version_block.block = TextBlock(value='', type=BlockTypeChoices.TEXT)
+    version_block.editor_block_data = TextEditorBlockData(
+        text='',
+    )
     version_block.save()
 
     return version_block

django_spire/knowledge/entry/version/converters/markdown_converter.py

@@ -1,19 +1,23 @@
 from __future__ import annotations
 
-import html
+import logging
 import re
-
-import marko
-
+from collections import defaultdict
 from typing import TYPE_CHECKING
 
+import marko
+from bs4 import BeautifulSoup
 from django.core.files.storage import default_storage
+from markitdown.converters import HtmlConverter
+from marko.block import Heading, List, ListItem, Paragraph, BlankLine
 from marko.element import Element
-from marko.block import Heading, List, ListItem
 
+from django_spire.knowledge.entry.version.block import models
+from django_spire.knowledge.entry.version.block.choices import BlockTypeChoices
+from django_spire.knowledge.entry.version.block.data.list.choices import \
+    ListEditorBlockDataStyle
 from django_spire.knowledge.entry.version.converters.converter import \
     BaseConverter
-from django_spire.knowledge.entry.version.block import models
 
 if TYPE_CHECKING:
     from django_spire.knowledge.entry.version.models import EntryVersion
@@ -21,12 +25,26 @@ if TYPE_CHECKING:
     from marko.block import BlockElement
 
 
+MARKO_BLOCK_TYPE_TO_BLOCK_CHOICES = defaultdict(
+    lambda:BlockTypeChoices.TEXT,
+    {
+        Paragraph: models.BlockTypeChoices.TEXT,
+        BlankLine: models.BlockTypeChoices.TEXT,
+        Heading: models.BlockTypeChoices.HEADING,
+        List: models.BlockTypeChoices.LIST,
+    }
+)
+
+
 class MarkdownConverter(BaseConverter):
     """Converts Markdown content to a list of EntryVersionBlocks using Marko.
 
     For more info on Marko:
     https://marko-py.readthedocs.io/en/latest/api.html#marko.block.BlockElement
     """
+
+    html_converter = HtmlConverter()
+
     def __init__(self, entry_version: EntryVersion):
         super().__init__(entry_version)
         self._order = 0
@@ -35,112 +53,169 @@ class MarkdownConverter(BaseConverter):
         with default_storage.open(file.file.name, 'r') as f:
             return self.convert_markdown_to_blocks(f.read())
 
-    def _convert_heading_block(
-            self,
-            marko_block: Heading,
-            order: int
-    ) -> models.EntryVersionBlock:
-        heading_type = (
-            models.BlockTypeChoices.HEADING
-            if marko_block.level == 1
-            else models.BlockTypeChoices.SUB_HEADING
-        )
-
-        return models.EntryVersionBlock.services.factory.create_null_block(
-            entry_version=self.entry_version,
-            block_type=heading_type,
-            order=order,
-            value=self._get_marko_text_content(marko_block),
-        )
-
-    def _convert_list_block(
+    def convert_markdown_to_blocks(
             self,
-            marko_block: List | ListItem | Element,
-            bullet: str,
-            indent_level: int,
-            ordered: bool,
+            markdown_content: str
     ) -> list[models.EntryVersionBlock]:
-        if isinstance(marko_block.children, str):
-            list_item_block = models.EntryVersionBlock.services.factory.create_null_block(
+        marko_blocks = marko.parse(markdown_content).children
+
+        return [
+            models.EntryVersionBlock.services.factory.create_validated_block(
                 entry_version=self.entry_version,
-                block_type=models.BlockTypeChoices.LIST_ITEM,
-                order=self._order,
-                value=self._get_marko_text_content(marko_block),
-                bullet=bullet,
-                indent_level=indent_level,
-                ordered=ordered,
-            )
-            self._order += 1
-            return [list_item_block]
-
-        if isinstance(marko_block, ListItem):
-            indent_level += 1
-
-        blocks = []
-        for child in marko_block.children:
-            blocks.extend(
-                self._convert_list_block(
-                    marko_block=child,
-                    bullet=bullet,
-                    indent_level=indent_level,
-                    ordered=ordered,
-                )
+                block_type=MARKO_BLOCK_TYPE_TO_BLOCK_CHOICES[marko_block.__class__],
+                block_data=self._marko_block_to_editor_block_data_dict(marko_block),
+                block_order=order,
+                block_tunes={}
             )
+            for order, marko_block in enumerate(marko_blocks)
+        ]
 
-            if isinstance(child, ListItem) and bullet.endswith('.'):
-                bullet = bullet.rstrip('.')
-                bullet = str(int(bullet) + 1) + '.'
+    @classmethod
+    def html_to_markdown(cls, html_content: str) -> str:
+        return cls.html_converter.convert_string(html_content).markdown
 
-        return blocks
+    @classmethod
+    def _remove_outer_html_tags(
+            cls,
+            html_content: str,
+            tag_name: str | None = None,
+    ) -> str:
+        bs = BeautifulSoup(html_content, 'html.parser')
 
-    def convert_markdown_to_blocks(
-            self,
-            markdown_content: str
-    ) -> list[models.EntryVersionBlock]:
-        syntax_tree = marko.parse(markdown_content)
-
-        blocks = []
-        for marko_block in syntax_tree.children:
-            if isinstance(marko_block, List):
-                blocks.extend(
-                    self._convert_list_block(
-                        marko_block=marko_block,
-                        bullet=marko_block.bullet,
-                        indent_level=-1,
-                        ordered=marko_block.ordered,
-                    )
-                )
-            else:
-                blocks.append(
-                    self._marko_block_to_version_block(
-                        marko_block=marko_block,
-                        order=self._order,
-                    )
-                )
-                self._order += 1
-
-        return blocks
+        if tag_name:
+            # Only target specific tag given for removal
+            html_element = bs.find(tag_name)
+
+            if html_element:
+                html_content = html_element.decode_contents()
+        else:
+            # Remove any outer tag found
+            html_element = bs.find()
+
+            if html_element:
+                html_content = html_element.decode_contents()
+
+        return html_content
 
     @staticmethod
-    def _get_marko_text_content(marko_block: BlockElement) -> str:
-        html_text = marko.render(marko_block)
-        bolded_text = re.sub(r'<strong>(.*?)</strong>', r'**\1**', html_text)
-        italicized_text = re.sub(r'<em>(.*?)</em>', r'*\1*', bolded_text)
-        strikethrough_text = re.sub(r'<del>(.*?)</del>', r'~~*\1*~~', italicized_text)
-        text = re.sub(r'<[^>]+>', '', strikethrough_text)
-        return html.unescape(text)
-
-    def _marko_block_to_version_block(
-            self,
-            marko_block: BlockElement | Element,
-            order: int
-    ) -> models.EntryVersionBlock:
-        if isinstance(marko_block, Heading):
-            return self._convert_heading_block(marko_block=marko_block, order=order)
-
-        return models.EntryVersionBlock.services.factory.create_null_block(
-            entry_version=self.entry_version,
-            block_type=models.BlockTypeChoices.TEXT,
-            order=order,
-            value=self._get_marko_text_content(marko_block)
+    def _try_parse_content_as_checklist_item(content: str) -> tuple[bool, bool | None, str]:
+        empty_checkbox_pattern = re.compile(r'\[ ?\]\s*')
+        checked_checkbox_pattern = re.compile(r'\[[xX]\]\s*')
+
+        is_checked = None
+        has_empty_checkbox = re.match(empty_checkbox_pattern, content)
+
+        if has_empty_checkbox:
+            content = re.sub(empty_checkbox_pattern, '', content)
+            is_checked = False
+
+        has_checked_checkbox = re.match(checked_checkbox_pattern, content)
+        if has_checked_checkbox:
+            content = re.sub(checked_checkbox_pattern, '', content)
+            is_checked = True
+
+        is_checklist_item = is_checked is not None
+
+        return (
+            is_checklist_item,
+            is_checked,
+            content
+        )
+
+    @classmethod
+    def _marko_list_item_block_to_editor_block_data_dict(
+            cls,
+            marko_list_item_block: ListItem,
+            parent_marko_list_block: List | None = None,
+    ):
+        list_item_editor_block_data_kwargs = {
+            'items': [],
+            'content': '',
+            'meta': {},
+        }
+
+        # First determine if this item contains a nested list.
+        # If it does, remove the list from the item's children (so the item content can be
+        # properly rendered) and process it into editor_block_data if it does
+        for i, child in enumerate(marko_list_item_block.children):
+            if isinstance(child, List):
+                nested_marko_list_block = marko_list_item_block.children.pop(i)
+                for nested_child in nested_marko_list_block.children:
+                    nested_list_item_editor_block_data_kwargs, _ = \
+                        cls._marko_list_item_block_to_editor_block_data_dict(nested_child)
+                    list_item_editor_block_data_kwargs['items'].append(nested_list_item_editor_block_data_kwargs)
+
+                break
+
+        # Marko wraps the text content in li when it renders a ListItem into html,
+        # so we need to remove that, plus remove any leftover tags (e.g. if the content
+        # in the li was a header)
+        content = cls._remove_outer_html_tags(
+            cls._remove_outer_html_tags(marko.render(marko_list_item_block), 'li')
         )
+
+        is_checklist_item, is_checked, content = \
+            cls._try_parse_content_as_checklist_item(content)
+
+        if is_checklist_item:
+            # Each editor list item block data tracks its checked state through an
+            # item level meta
+            list_item_editor_block_data_kwargs['meta']['checked'] = is_checked
+
+        list_item_editor_block_data_kwargs['content'] = content
+
+        list_editor_block_data_style = None
+        if parent_marko_list_block:
+            # We determine the entire list style from the top level list items for simplicity.
+            # If parent_marko_list_block is present, it means we are processing the top level list.
+            list_editor_block_data_style = ListEditorBlockDataStyle.UNORDERED
+            if is_checklist_item:
+                # The presence of checklist items takes priority over an ordered list style
+                list_editor_block_data_style = ListEditorBlockDataStyle.CHECKLIST
+            elif parent_marko_list_block.ordered:
+                list_editor_block_data_style = ListEditorBlockDataStyle.ORDERED
+
+        return list_item_editor_block_data_kwargs, list_editor_block_data_style
+
+    @classmethod
+    def _marko_block_to_editor_block_data_dict(cls, marko_block: BlockElement | Element):
+        if isinstance(marko_block, BlankLine):
+            return { 'text': '' }
+
+        elif isinstance(marko_block, Paragraph):
+            editor_block_text_string = cls._remove_outer_html_tags(marko.render(marko_block))
+            return { 'text': editor_block_text_string }
+
+        elif isinstance(marko_block, Heading):
+            return {
+                'text': cls._remove_outer_html_tags(marko.render(marko_block)),
+                'level': marko_block.level,
+            }
+
+        elif isinstance(marko_block, List):
+            list_editor_block_data_dict = {
+                'items': [],
+                'style': ListEditorBlockDataStyle.UNORDERED,
+                'meta': {},
+            }
+
+            for child in marko_block.children:
+                list_item_editor_block_data_dict, list_editor_block_data_style = \
+                    cls._marko_list_item_block_to_editor_block_data_dict(child, marko_block)
+
+                list_editor_block_data_dict['items'].append(list_item_editor_block_data_dict)
+                list_editor_block_data_dict['style'] = list_editor_block_data_style
+
+            return list_editor_block_data_dict
+
+        else:
+            logging.warning(
+                f'Unsupported marko block type: {marko_block.__class__.__name__!r}. '
+                f'Rendering content to html and adding to markdown as a basic paragraph block.'
+            )
+            return { 'text': marko.render(marko_block) }
+
+
+    @classmethod
+    def marko_block_to_markdown_string(cls, marko_block: BlockElement) -> str:
+        return cls.html_to_markdown(marko.render(marko_block))

django_spire/knowledge/entry/version/maps.py

@@ -8,4 +8,4 @@ from django_spire.knowledge.entry.version.converters.markdown_converter import \
 FILE_TYPE_CONVERTER_MAP = {
     'md': MarkdownConverter,
     'docx': DocxConverter
-}
+}

django_spire/knowledge/entry/version/models.py

@@ -42,3 +42,4 @@ class EntryVersion(HistoryModelMixin):
         verbose_name = 'Entry Version'
         verbose_name_plural = 'Entry Versions'
         db_table = 'django_spire_knowledge_entry_version'
+

django_spire/knowledge/entry/version/querysets.py

@@ -1,7 +1,17 @@
 from __future__ import annotations
 
+from django.db.models import Prefetch
+
 from django_spire.history.querysets import HistoryQuerySet
 
 
 class EntryVersionQuerySet(HistoryQuerySet):
-    pass
+    def prefetch_blocks(self):
+        from django_spire.knowledge.entry.version.block.models import EntryVersionBlock
+
+        return self.prefetch_related(
+            Prefetch(
+                'blocks',
+                queryset=EntryVersionBlock.objects.order_by('order')
+            )
+        )

django_spire/knowledge/entry/version/seeding/seeder.py

@@ -11,6 +11,8 @@ from django_spire.knowledge.entry.models import Entry
 from django_spire.knowledge.entry.version import models
 
 from django_spire.contrib.seeding import DjangoModelSeeder
+from django_spire.knowledge.entry.version.block.data.maps import \
+    EDITOR_BLOCK_DATA_REVERSE_MAP
 from django_spire.knowledge.entry.version.block.models import EntryVersionBlock
 from django_spire.knowledge.entry.version.block.seeding.constants import SAFETY_BLOCKS
 from django_spire.knowledge.entry.version.choices import EntryVersionStatusChoices
@@ -61,10 +63,10 @@ class EntryVersionSeeder(DjangoModelSeeder):
             for idx, safety_block in enumerate(safety_blocks):
                 version_block = EntryVersionBlock(
                     version=entry_version,
-                    type=safety_block.type,
+                    type=EDITOR_BLOCK_DATA_REVERSE_MAP[type(safety_block)],
                     order=idx,
                 )
-                version_block.block = safety_block
+                version_block.editor_block_data = safety_block
                 version_blocks.append(version_block)
 
             EntryVersionBlock.objects.bulk_create(version_blocks)

django_spire/knowledge/entry/version/services/processor_service.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from django.db import transaction
 from django.utils.timezone import localtime
 
 from django_spire.contrib.service import BaseDjangoModelService
@@ -18,3 +19,20 @@ class EntryVersionProcessorService(BaseDjangoModelService['EntryVersion']):
         self.obj.status = EntryVersionStatusChoices.PUBLISHED
         self.obj.published_datetime = localtime()
         self.obj.save()
+
+    def update_blocks(self, raw_block_data: list[dict]):
+        from django_spire.knowledge.entry.version.block.models import EntryVersionBlock
+
+        old_entry_blocks = self.obj.blocks.active()
+
+        incoming_entry_blocks = [
+            EntryVersionBlock.services.factory.create_validated_block(
+                entry_version=self.obj,
+                **block_data,
+            )
+            for block_data in raw_block_data
+        ]
+
+        with transaction.atomic():
+            old_entry_blocks.delete()
+            EntryVersionBlock.objects.bulk_create(incoming_entry_blocks)

django_spire/knowledge/entry/version/tests/test_urls/test_json_urls.py

@@ -1,9 +1,13 @@
 from __future__ import annotations
 
+import json
+
 from django.urls import reverse
 
 from django_spire.core.tests.test_cases import BaseTestCase
 from django_spire.knowledge.entry.tests.factories import create_test_entry
+from django_spire.knowledge.entry.version.block.tests.factories import \
+    create_test_block_form_data
 from django_spire.knowledge.entry.version.tests.factories import \
     create_test_entry_version
 
@@ -17,34 +21,13 @@ class EntryVersionJsonUrlsTests(BaseTestCase):
         self.test_entry.current_version = self.test_entry_version
         self.test_entry.save()
 
-    def test_create_blank_block_view_url_path(self):
-        response = self.client.post(
-            reverse(
-                'django_spire:knowledge:entry:version:json:create_blank_block',
-                kwargs={'pk': self.test_entry_version.pk}
-            ),
-            content_type='application/json'
-        )
-
-        self.assertEqual(response.status_code, 200)
-
-    def test_delete_block_view_url_path(self):
-        response = self.client.post(
-            reverse(
-                'django_spire:knowledge:entry:version:json:delete_block',
-                kwargs={'pk': self.test_entry_version.pk}
-            ),
-            content_type='application/json'
-        )
-
-        self.assertEqual(response.status_code, 200)
-
-    def test_reorder_view_url_path(self):
+    def test_save_version_blocks_view(self):
         response = self.client.post(
             reverse(
-                'django_spire:knowledge:entry:version:json:reorder',
+                'django_spire:knowledge:entry:version:json:update_blocks',
                 kwargs={'pk': self.test_entry_version.pk}
             ),
+            data=json.dumps([create_test_block_form_data()]),
             content_type='application/json'
         )
 

django_spire/knowledge/entry/version/urls/__init__.py

@@ -3,9 +3,6 @@ from django.urls import include, path
 app_name = 'version'
 
 urlpatterns = [
-    path('block/', include('django_spire.knowledge.entry.version.block.urls', namespace='block')),
-
-    path('form/', include('django_spire.knowledge.entry.version.urls.form_urls', namespace='form')),
     path('json/', include('django_spire.knowledge.entry.version.urls.json_urls', namespace='json')),
     path('page/', include('django_spire.knowledge.entry.version.urls.page_urls', namespace='page')),
     path('redirect/', include('django_spire.knowledge.entry.version.urls.redirect_urls', namespace='redirect')),

django_spire/knowledge/entry/version/urls/json_urls.py

@@ -5,20 +5,12 @@ from django_spire.knowledge.entry.version.views import json_views
 
 app_name = 'json'
 
+
 urlpatterns = [
     path(
-        '<int:pk>/create_blank_block/',
-        json_views.create_blank_block_view,
-        name='create_blank_block',
-    ),
-    path(
-        '<int:pk>/delete_block/',
-        json_views.delete_block_view,
-        name='delete_block',
-    ),
-    path(
-        '<int:pk>/reorder/',
-        json_views.reorder_view,
-        name='reorder',
+        '<int:pk>/update_blocks/',
+
+        json_views.update_blocks_view,
+        name='update_blocks',
     ),
 ]

django_spire/knowledge/entry/version/views/json_views.py

@@ -4,86 +4,18 @@ import json
 
 from django.core.handlers.wsgi import WSGIRequest
 from django.http import JsonResponse
+from django.shortcuts import get_object_or_404
 
+from django_spire.auth.controller.controller import AppAuthController
 from django_spire.core.decorators import valid_ajax_request_required
-from django_spire.core.shortcuts import get_object_or_null_obj
-from django_spire.knowledge.entry.version.block.models import EntryVersionBlock
 from django_spire.knowledge.entry.version.models import EntryVersion
 
 
 @valid_ajax_request_required
-def create_blank_block_view(request: WSGIRequest, pk: int) -> JsonResponse:
-    entry_version = EntryVersion.objects.get(pk=pk)
+@AppAuthController('knowledge').permission_required('can_change')
+def update_blocks_view(request: WSGIRequest, pk: int) -> JsonResponse:
+    entry_version = get_object_or_404(EntryVersion.objects.prefetch_blocks(), pk=pk)
+    new_block_data = json.loads(request.body.decode('utf-8'))
+    entry_version.services.processor.update_blocks(new_block_data)
 
-    body_data = json.loads(request.body.decode('utf-8'))
-
-    if 'order' not in body_data or 'block_type' not in body_data:
-        return JsonResponse({'type': 'error', 'message': 'Missing Required Data.'})
-
-    block_type = body_data.pop('block_type')
-    order = body_data.pop('order')
-
-    version_block = EntryVersionBlock.services.factory.create_blank_block(
-        entry_version=entry_version,
-        block_type=block_type,
-        order=order,
-        **body_data,
-    )
-
-    return JsonResponse(
-        {
-            'type': 'success',
-            'entry_version_block_json': version_block.services.transformation.to_json()
-        }
-    )
-
-
-@valid_ajax_request_required
-def delete_block_view(request: WSGIRequest, pk: int) -> JsonResponse:
-    entry_version = EntryVersion.objects.get(pk=pk)
-
-    body_data = json.loads(request.body.decode('utf-8'))
-    version_block_pk = body_data.get('version_block_pk')
-
-    try:
-        version_block = EntryVersionBlock.objects.get(pk=version_block_pk)
-    except EntryVersionBlock.DoesNotExist:
-        return JsonResponse({'type': 'error', 'message': 'Block Not Found.'})
-
-    version_block.services.processor.set_deleted()
-
-    return JsonResponse({'type': 'success'})
-
-
-@valid_ajax_request_required
-def reorder_view(request: WSGIRequest, pk: int) -> JsonResponse:
-    entry_version = get_object_or_null_obj(EntryVersion, pk=pk)
-
-    if entry_version.id is None:
-        return JsonResponse({'type': 'error', 'message': 'EntryVersion not found.'})
-
-    body_data = json.loads(request.body.decode('utf-8'))
-
-    order = body_data.get('order', None)
-
-    if order is None:
-        return JsonResponse({'type': 'error', 'message': 'Order Not Found.'})
-
-    block_id = body_data.get('block_id')
-
-    if not body_data.get('block_id'):
-        return JsonResponse({'type': 'error', 'message': 'Missing Required Data.'})
-
-    block = get_object_or_null_obj(EntryVersionBlock, pk=block_id)
-
-    if block.id is None:
-        return JsonResponse({'type': 'error', 'message': 'Block not found.'})
-
-    block.ordering_services.processor.move_to_position(
-        destination_objects=entry_version.blocks.active(),
-        position=order,
-    )
-
-    return JsonResponse({
-        'type': 'success', 'message': 'Order reordered successfully',
-    })
+    return JsonResponse({'type': 'success'})