django-spire 0.23.4__py3-none-any.whl

django_spire/knowledge/collection/tests/test_urls/test_form_urls.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from django.urls import reverse
+
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class CollectionFormUrlsTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+    def test_form_view_url_path(self):
+        response = self.client.get(
+            reverse(
+                'django_spire:knowledge:collection:form:create',
+            )
+        )
+
+        self.assertEqual(response.status_code, 200)

django_spire/knowledge/collection/tests/test_urls/test_json_urls.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from django.urls import reverse
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.collection.tests.factories import create_test_collection
+
+
+class CollectionJsonUrlsTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+
+        self.test_collection = create_test_collection()
+
+    def test_reorder_view_url_path(self):
+        response = self.client.post(
+            reverse('django_spire:knowledge:collection:json:reorder'),
+            data={
+                'collection_id': self.test_collection.pk,
+                'order': 0
+            },
+            content_type='application/json',
+        )
+
+        self.assertEqual(response.status_code, 200)

django_spire/knowledge/collection/tests/test_urls/test_page_urls.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from django.urls import reverse
+
+from django_spire.core.tests.test_cases import BaseTestCase
+from django_spire.knowledge.collection.tests.factories import create_test_collection
+
+
+class CollectionPageUrlsTests(BaseTestCase):
+    def setUp(self):
+        super().setUp()
+        self.test_collection = create_test_collection()
+
+    def test_delete_view_url_path(self):
+        response = self.client.get(
+            reverse(
+                'django_spire:knowledge:collection:page:delete',
+                kwargs={'pk': self.test_collection.pk}
+            )
+        )
+
+        self.assertEqual(response.status_code, 200)
+
+    def test_list_view_url_path(self):
+        response = self.client.get(
+            reverse('django_spire:knowledge:page:home')
+        )
+
+        self.assertEqual(response.status_code, 200)

django_spire/knowledge/collection/urls/__init__.py

@@ -0,0 +1,11 @@
+from django.urls import include, path
+
+from django_spire.knowledge.collection import views
+
+app_name = 'collection'
+
+urlpatterns = [
+    path('page/', include('django_spire.knowledge.collection.urls.page_urls', namespace='page')),
+    path('json/', include('django_spire.knowledge.collection.urls.json_urls', namespace='json')),
+    path('form/', include('django_spire.knowledge.collection.urls.form_urls', namespace='form')),
+]

django_spire/knowledge/collection/urls/form_urls.py

@@ -0,0 +1,12 @@
+from django.urls import path
+
+from django_spire.knowledge.collection.views import form_views
+
+
+app_name = 'form'
+
+urlpatterns = [
+    path('create/', form_views.form_view, name='create'),
+    path('<int:parent_pk>/create_with_parent/', form_views.form_view, name='create_with_parent'),
+    path('<int:pk>/update/', form_views.form_view, name='update'),
+]

django_spire/knowledge/collection/urls/json_urls.py

@@ -0,0 +1,10 @@
+from django.urls import path
+
+from django_spire.knowledge.collection.views import json_views
+
+
+app_name = 'json'
+
+urlpatterns = [
+    path('reorder/', json_views.reorder_view, name='reorder'),
+]

django_spire/knowledge/collection/urls/page_urls.py

@@ -0,0 +1,11 @@
+from django.urls import path
+
+from django_spire.knowledge.collection.views import page_views
+
+
+app_name = 'page'
+
+urlpatterns = [
+    path('<int:pk>/', page_views.top_level_collection_view, name='top_level'),
+    path('<int:pk>/delete/', page_views.delete_view, name='delete'),
+]

django_spire/knowledge/collection/views/form_views.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import django_glue as dg
+
+from typing import TYPE_CHECKING
+
+from django.http import HttpResponseRedirect
+from django.urls import reverse
+
+from django_spire.auth.controller.controller import AppAuthController
+from django_spire.auth.group.models import AuthGroup
+from django_spire.contrib.form.utils import show_form_errors
+from django_spire.contrib.generic_views import portal_views
+from django_spire.core.shortcuts import get_object_or_null_obj
+from django_spire.knowledge.collection.models import Collection, CollectionGroup
+from django_spire.knowledge.collection.forms import CollectionForm
+
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+    from django.template.response import TemplateResponse
+
+
+@AppAuthController('knowledge').permission_required('can_add')
+def form_view(
+        request: WSGIRequest,
+        pk: int = 0,
+        parent_pk: int = None,
+) -> TemplateResponse | HttpResponseRedirect:
+    collection = get_object_or_null_obj(Collection, pk=pk)
+
+    dg.glue_model_object(request, unique_name='collection', model_object=collection)
+
+    dg.glue_query_set(
+        request,
+        unique_name='collections',
+        target=(
+            Collection.objects
+            .active()
+            .request_user_has_access(request)
+            .exclude(pk=collection.pk)
+            .exclude_children(collection_id=pk)
+        ),
+        fields=['name']
+    )
+    dg.glue_query_set(
+        request,
+        unique_name='group_query_set',
+        target=AuthGroup.objects.all(),
+        fields=['name']
+    )
+
+    if request.method == 'POST':
+        form = CollectionForm(request.POST, instance=collection)
+
+        if form.is_valid():
+            collection, _ = collection.services.save_model_obj(**form.cleaned_data)
+
+            _ = CollectionGroup.services.factory.replace_groups(
+                request=request,
+                group_pks=dict(request.POST).get('groups'),
+                collection=collection,
+            )
+
+            collection.services.tag.process_and_set_tags()
+
+            if collection.parent_id:
+                return_url = reverse(
+                    'django_spire:knowledge:collection:page:top_level',
+                    kwargs={'pk': collection.services.tool.get_root_collection_pk()}
+                )
+            else:
+                return_url = reverse('django_spire:knowledge:page:home')
+
+            return HttpResponseRedirect(
+                return_url
+            )
+
+        show_form_errors(request, form)
+    else:
+        form = CollectionForm(instance=collection)
+
+    return portal_views.form_view(
+        request,
+        form=form,
+        obj=collection,
+        context_data={
+            'collection': collection,
+            'collection_parent_pk': parent_pk,
+            'group_ids': list(
+                collection.groups.all().values_list('auth_group_id', flat=True)
+            ) if collection.id else [],
+        },
+        template='django_spire/knowledge/collection/page/form_page.html'
+    )

django_spire/knowledge/collection/views/json_views.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import json
+
+from django.core.handlers.wsgi import WSGIRequest
+from django.http import JsonResponse
+
+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.collection.models import Collection
+
+
+@valid_ajax_request_required
+def reorder_view(request: WSGIRequest) -> JsonResponse:
+    body_data = json.loads(request.body.decode('utf-8'))
+
+    collection_id = body_data.get('collection_id', 0)
+    collection = get_object_or_null_obj(Collection, pk=collection_id)
+
+    if not collection.id:
+        return JsonResponse({'type': 'error', 'message': 'Collection not found.'})
+
+    order = body_data.get('order', None)
+    if order is None:
+        return JsonResponse({'type': 'error', 'message': 'Order must be provided.'})
+
+    collection.services.ordering.reorder(
+        order=order,
+        new_parent_pk=body_data.get('parent', None),
+    )
+
+    return JsonResponse({'type': 'success'})

django_spire/knowledge/collection/views/page_views.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from django.core.handlers.wsgi import WSGIRequest
+from django.shortcuts import get_object_or_404
+from django.template.response import TemplateResponse
+from django.urls import reverse
+
+from django_spire.auth.controller.controller import AppAuthController
+from django_spire.contrib import Breadcrumbs
+from django_spire.contrib.generic_views import portal_views
+from django_spire.knowledge.collection.models import Collection
+
+
+@AppAuthController('knowledge').permission_required('can_view')
+def top_level_collection_view(request: WSGIRequest, pk: int) -> TemplateResponse:
+    collection = get_object_or_404(Collection, pk=pk)
+
+    breadcrumbs = Breadcrumbs()
+    breadcrumbs.add_breadcrumb('Knowledge', reverse('django_spire:knowledge:page:home'))
+    breadcrumbs.add_base_breadcrumb(collection)
+
+    return portal_views.template_view(
+        request,
+        page_title='Knowledge Collection',
+        page_description='',
+        breadcrumbs=breadcrumbs,
+        context_data={
+            'collection': collection,
+            'collection_tree_json': Collection.services.transformation.to_hierarchy_json(
+                request=request, parent_id=collection.id
+            ),
+        },
+        template='django_spire/knowledge/collection/page/display_page.html',
+    )
+
+
+@AppAuthController('knowledge').permission_required('can_delete')
+def delete_view(request: WSGIRequest, pk: int) -> TemplateResponse:
+    collection = get_object_or_404(Collection, pk=pk)
+
+    if collection.parent:
+        return_url = request.GET.get(
+            'return_url',
+            reverse(
+                'django_spire:knowledge:collection:page:top_level',
+                kwargs={'pk': collection.parent_id}
+            )
+        )
+    else:
+        return_url = request.GET.get('return_url', reverse('django_spire:knowledge:page:home'))
+
+    return portal_views.delete_form_view(
+        request,
+        obj=collection,
+        delete_func=collection.services.processor.set_deleted,
+        return_url=return_url
+    )

django_spire/knowledge/entry/admin.py

@@ -0,0 +1,44 @@
+from django.contrib import admin, messages
+from django.db.models import QuerySet
+from django.urls import reverse
+from django.utils.html import format_html
+from django.utils.http import urlencode
+
+from django_spire.knowledge.entry.models import Entry
+
+
+@admin.register(Entry)
+class EntryAdmin(admin.ModelAdmin):
+    list_display = ['name', 'current_version_link', 'collection', 'is_deleted', 'tag_count']
+    list_select_related = ['collection', 'current_version']
+    list_filter = ['is_deleted', 'is_active']
+    search_fields = ['name', 'collection__name']
+    ordering = ['name']
+    autocomplete_fields = ['collection', 'current_version']
+    actions = ['set_tags_for_entries']
+
+    def current_version_link(self, entry: Entry) -> str:
+        url = (
+            reverse('admin:django_spire_knowledge_entryversion_changelist')
+            + '?'
+            + urlencode({'entry_id': f'{entry.id}'})
+        )
+
+        return format_html(f'<a href="{url}">View Versions</a>')
+
+    current_version_link.short_description = 'Current Version'
+    current_version_link.allow_tags = True
+
+    @admin.action(description="Set Tags for Entries (Allow 5 Seconds Per)")
+    def set_tags_for_entries(self, request, queryset: QuerySet[Entry]):
+        processed = 0
+        for entry in queryset:
+            entry.services.tag.process_and_set_tags()
+            processed += 1
+
+        messages.success(request, f'Successfully processed {processed} entries.')
+
+    def tag_count(self, entry: Entry):
+        return entry.tags.count()
+
+    tag_count.short_description = 'Tags'

django_spire/knowledge/entry/forms.py

@@ -0,0 +1,14 @@
+from django import forms
+
+from django_spire.knowledge.entry.models import Entry
+
+
+class EntryForm(forms.ModelForm):
+    class Meta:
+        model = Entry
+        exclude = ['current_version', 'collection', 'order']
+
+
+class EntryFilesForm(forms.Form):
+    collection = forms.IntegerField(required=True)
+    import_files = forms.FileField()

django_spire/knowledge/entry/models.py

@@ -0,0 +1,75 @@
+from django.db import models
+from django.urls import reverse
+
+from django_spire.contrib import Breadcrumbs
+from django_spire.contrib.ordering.mixins import OrderingModelMixin
+from django_spire.core.tag.mixins import TagModelMixin
+from django_spire.contrib.utils import truncate_string
+from django_spire.history.mixins import HistoryModelMixin
+from django_spire.knowledge.collection.models import Collection
+from django_spire.knowledge.entry.querysets import EntryQuerySet
+from django_spire.knowledge.entry.services.service import EntryService
+from django_spire.knowledge.entry.version.models import EntryVersion
+
+
+class Entry(
+    HistoryModelMixin,
+    OrderingModelMixin,
+    TagModelMixin
+):
+    collection = models.ForeignKey(
+        Collection,
+        on_delete=models.CASCADE,
+        related_name='entries',
+        related_query_name='entry'
+    )
+    current_version = models.OneToOneField(
+        EntryVersion,
+        on_delete=models.CASCADE,
+        related_name='current_version',
+        related_query_name='current_version',
+        null=True,
+        blank=True,
+    )
+
+    name = models.CharField(max_length=255)
+
+    objects = EntryQuerySet.as_manager()
+    services = EntryService()
+
+    def __str__(self):
+        return self.name
+
+    @property
+    def name_short(self) -> str:
+        return truncate_string(self.name, 32)
+
+    @property
+    def top_level_collection(self) -> Collection:
+        return self.collection.top_level_parent
+
+    def base_breadcrumb(self) -> Breadcrumbs:
+        bread_crumbs = Breadcrumbs()
+
+        bread_crumbs.add_breadcrumb(
+            self.top_level_collection.name_short,
+            reverse(
+                'django_spire:knowledge:collection:page:top_level',
+                kwargs={'pk': self.top_level_collection.pk}
+            )
+        )
+
+        bread_crumbs.add_breadcrumb(
+            self.collection.name_short
+        )
+
+        bread_crumbs.add_breadcrumb(
+            self.name_short,
+        )
+
+        return bread_crumbs
+
+    class Meta:
+        verbose_name = 'Entry'
+        verbose_name_plural = 'Entries'
+        db_table = 'django_spire_knowledge_entry'

django_spire/knowledge/entry/querysets.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django.db.models import Q
+from django_spire.contrib.ordering.querysets import OrderingQuerySetMixin
+from django_spire.history.querysets import HistoryQuerySet
+from django_spire.knowledge.entry.version.choices import EntryVersionStatusChoices
+
+if TYPE_CHECKING:
+    from django_spire.auth.user.models import AuthUser
+    from django.db.models import QuerySet
+    from django_spire.knowledge.entry.models import Entry
+
+
+class EntryQuerySet(HistoryQuerySet, OrderingQuerySetMixin):
+    def has_current_version(self) -> QuerySet[Entry]:
+        return self.filter(current_version__isnull=False)
+
+    def id_in(self, ids: list[int]) -> QuerySet[Entry]:
+        return self.filter(id__in=ids)
+
+    def user_has_access(self, user: AuthUser) -> QuerySet[Entry]:
+        return self.filter(
+            Q(
+                current_version__status=EntryVersionStatusChoices.PUBLISHED
+            ) |
+            Q(
+                current_version__author=user,
+                current_version__status=EntryVersionStatusChoices.DRAFT
+            )
+        )
+
+    def get_by_version_block_id(self, version_block_id: int) -> Entry:
+        return self.get(
+            current_version__block__id=version_block_id
+        )

django_spire/knowledge/entry/seeding/seed.py

@@ -0,0 +1,3 @@
+from django_spire.knowledge.entry.seeding.seeder import EntrySeeder
+
+EntrySeeder.seed_database(count=50)

django_spire/knowledge/entry/seeding/seeder.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from django_spire.knowledge.collection.models import Collection
+from django_spire.knowledge.entry import models
+
+from django_spire.contrib.seeding import DjangoModelSeeder
+from django_spire.knowledge.entry.version.seeding.seeder import EntryVersionSeeder
+
+
+class EntrySeeder(DjangoModelSeeder):
+    model_class = models.Entry
+    cache_name = 'entry_seeder'
+    fields = {
+        'id': 'exclude',
+        'current_version': 'exclude',
+        'collection_id': ('custom', 'fk_random', {'model_class': Collection}),
+        'name': (
+            'llm',
+            'A name for a document. Make it fun and give it a theme'
+        ),
+    }
+
+    @classmethod
+    def _correct_order(cls, entries: list[models.Entry]) -> list[models.Entry]:
+        for collection in Collection.objects.all():
+            collection_entries = collection.entries.all()
+
+            for idx, entry in enumerate(collection_entries):
+                entry.order = idx
+
+            cls.model_class.objects.bulk_update(collection_entries, ['order'])
+
+        return entries
+
+    @classmethod
+    def seed_database(
+        cls,
+        count: int = 1,
+        fields: dict | None = None
+    ) -> list[models.Entry]:
+        entries = super().seed_database(
+            count=count,
+            fields=fields
+        )
+
+        cls._correct_order(entries)
+        entries = cls._set_current_version(entries=entries, count=count)
+
+        for entry in entries:
+            entry.services.tag.process_and_set_tags()
+
+        return entries
+
+    @classmethod
+    def _set_current_version(cls, entries: list[models.Entry], count: int = 1):
+        entry_versions = EntryVersionSeeder.seed_database(count=count)
+
+        for entry, entry_version in zip(entries, entry_versions, strict=False):
+            entry_version.entry = entry
+            entry.current_version = entry_version
+
+        cls.model_class.objects.bulk_update(entries, ['current_version'])
+        EntryVersionSeeder.model_class.objects.bulk_update(entry_versions, ['entry'])
+        return entries

django_spire/knowledge/entry/services/automation_service.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import traceback
+from typing import TYPE_CHECKING
+
+import json
+
+from django_spire.contrib.service import BaseDjangoModelService
+from django_spire.core.decorators import close_db_connections
+from django_spire.knowledge.entry.version.block.models import EntryVersionBlock
+from django_spire.knowledge.exceptions import KnowledgeBaseConversionException
+
+if TYPE_CHECKING:
+    from django_spire.knowledge.entry.models import Entry
+
+
+class EntryAutomationService(BaseDjangoModelService['Entry']):
+    obj: Entry
+
+    @close_db_connections
+    def convert_files_to_model_objects(self) -> str:
+        file_objects = self.obj_class.services.tool.get_files_to_convert()
+
+        entries = self.obj_class.objects.id_in(
+            list({file_object.object_id for file_object in file_objects})
+        ).select_related('current_version')
+
+        entry_pk_map = {entry.pk: entry for entry in entries}
+
+        errored = []
+        for file_object in file_objects:
+            try:
+                EntryVersionBlock.services.factory.create_blocks_from_file(
+                    file=file_object,
+                    entry_version=entry_pk_map[file_object.object_id].current_version,
+                )
+            except Exception as e:
+                errored.append({'file': file_object.name, 'error': traceback.format_exc()})
+                file_object.set_deleted()
+            else:
+                file_object.set_deleted()
+
+        message = f'Files Converted: {len(file_objects) - len(errored)}'
+        if errored:
+            error_string = f'\n{message}\nFiles Errored:'
+            for error in errored:
+                error_string += f'    File Name: {error["file"]}\n    Error: {error["error"]}'
+
+            raise KnowledgeBaseConversionException(error_string)
+
+        return message

django_spire/knowledge/entry/services/factory_service.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django.contrib.contenttypes.models import ContentType
+
+from django_spire.auth.user.models import AuthUser
+from django_spire.contrib.service import BaseDjangoModelService
+from django_spire.file.models import File
+
+if TYPE_CHECKING:
+    from django_spire.knowledge.entry.models import Entry
+    from django_spire.knowledge.collection.models import Collection
+
+
+class EntryFactoryService(BaseDjangoModelService['Entry']):
+    obj: Entry
+
+    def create_from_files(
+            self,
+            author: AuthUser,
+            collection: Collection,
+            files: list[File],
+    ) -> list[Entry]:
+        entries = []
+        for file in files:
+            entry, _ = self.obj_class.services.save_model_obj(
+                name=file.name,
+                author=author,
+                collection=collection
+            )
+            entries.append(entry)
+
+            file.content_type = ContentType.objects.get_for_model(entry.__class__)
+            file.object_id = entry.id
+            file.related_field = None
+
+            entry.ordering_services.processor.move_to_position(
+                destination_objects=collection.entries.active(),
+                position=0,
+            )
+
+        File.objects.bulk_update(files, ['content_type', 'object_id', 'related_field'])
+
+        return entries

django_spire/knowledge/entry/services/processor_service.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django_spire.contrib.service import BaseDjangoModelService
+
+if TYPE_CHECKING:
+    from django_spire.knowledge.entry.models import Entry
+
+
+class EntryProcessorService(BaseDjangoModelService['Entry']):
+    obj: Entry
+
+    def set_deleted(self):
+        self.obj.ordering_services.processor.remove_from_objects(
+            destination_objects=self.obj.collection.entries.active()
+        )
+        self.obj.set_deleted()