localcosmos-app-kit 0.9.15__py3-none-any.whl → 0.9.17__py3-none-any.whl

app_kit/admin_urls.py

@@ -136,4 +136,9 @@ urlpatterns = [
          views.ManageAppKitExternalMedia.as_view(), name='update_app_kit_external_media'),
     path('delete-external-media/<int:meta_app_id>/<int:pk>/',
          views.DeleteAppKitExternalMedia.as_view(), name='delete_app_kit_external_media'),
+    # licences
+    path('list-images-and-licences/<int:meta_app_id>/',
+         views.ListImagesAndLicences.as_view(), name='list_images_and_licences'),
+    path('manage-content-licence/<int:meta_app_id>/<int:registry_entry_id>/',
+         views.ManageContentLicence.as_view(), name='manage_content_licence'),
 ]

app_kit/appbuilder/TaxonBuilder.py

@@ -332,33 +332,41 @@ class TaxonSerializer:
         if name_type not in self.taxa_builder.cache['search']:
             self.taxa_builder.cache['search'][name_type] = {}
             
-        if name in self.taxa_builder.cache['search'][name_type]:
-            search_taxon_json = self.taxa_builder.cache['search'][name_type][name]
+        if name not in self.taxa_builder.cache['search'][name_type]:
+             # the same name might occur in different taxonomies
+            self.taxa_builder.cache['search'][name_type][name] = {}
             
-        else:
-        
-            if not accepted_name_uuid:
-                accepted_name_uuid = self.lazy_taxon.name_uuid
-                
-            if accepted_name_uuid:
-                accepted_name_uuid = str(accepted_name_uuid)
-                
-            has_taxon_profile = False
-            taxon_profile = self.get_taxon_profile()
-            if taxon_profile:
-                has_taxon_profile = True
+        if name in self.taxa_builder.cache['search'][name_type]:
+            # the same name might occur in different taxonomies
+            taxon_source = self.lazy_taxon.taxon_source
             
-            search_taxon_json = self.serialize_extended()
+            if taxon_source in self.taxa_builder.cache['search'][name_type][name]:
+                search_taxon_json = self.taxa_builder.cache['search'][name_type][name][taxon_source]
             
-            search_taxon_json.update({
-                'nameType': name_type,
-                'name': name,
-                'isPreferredName': is_preferred_name,
-                'acceptedNameUuid': accepted_name_uuid,
-                'hasTaxonProfile': has_taxon_profile,
-            })
+            else:
             
-            self.taxa_builder.cache['search'][name_type][name] = search_taxon_json
+                if not accepted_name_uuid:
+                    accepted_name_uuid = self.lazy_taxon.name_uuid
+                    
+                if accepted_name_uuid:
+                    accepted_name_uuid = str(accepted_name_uuid)
+                    
+                has_taxon_profile = False
+                taxon_profile = self.get_taxon_profile()
+                if taxon_profile:
+                    has_taxon_profile = True
+                
+                search_taxon_json = self.serialize_extended()
+                
+                search_taxon_json.update({
+                    'nameType': name_type,
+                    'name': name,
+                    'isPreferredName': is_preferred_name,
+                    'acceptedNameUuid': accepted_name_uuid,
+                    'hasTaxonProfile': has_taxon_profile,
+                })
+                
+                self.taxa_builder.cache['search'][name_type][name][taxon_source] = search_taxon_json
         
         search_taxon_json_copy = copy.deepcopy(search_taxon_json)
         

app_kit/features/taxon_profiles/templates/taxon_profiles/ajax/delete_all_manually_added_images.html

@@ -0,0 +1,37 @@
+{% extends "localcosmos_server/modals/modal_form.html" %}
+{% load i18n %}
+
+{% block title %}
+    {% trans 'Delete All Manually Added Images' %}
+{% endblock %}
+
+
+{% block action %}
+    {% url 'delete_all_manually_added_taxon_profile_images' meta_app.id taxon_profiles.id %}
+{% endblock %}
+
+{% block body %}
+    <p>
+        {% if success %}
+            <div class="alert alert-success">
+                {% trans 'All manually added images have been successfully deleted.' %}
+            </div>
+        {% else %}
+            <div class="alert alert-danger">
+                {% trans 'Are you sure you want to delete all manually added images across all taxon profiles? This action cannot be undone.' %}
+            </div>
+        {% endif %}
+    </p>
+{% endblock %}
+
+{% block footer %}
+    {% if success %}
+        {% include 'localcosmos_server/modals/footers/close.html' %}
+    {% else %}
+    	{% include 'localcosmos_server/modals/footers/delete.html' %}
+    {% endif %}
+{% endblock %}
+
+{% block script %}
+
+{% endblock %}

app_kit/features/taxon_profiles/templates/taxon_profiles/manage_taxon_profiles.html

@@ -168,6 +168,22 @@
 			</div>
 		</div>
 	</div>
+
+	<div class="mt-5">
+		<h3 class="text-danger">
+			{% trans 'Danger Zone' %}
+		</h3>
+	</div>
+	<div class="card mt-3">
+		<div class="card-body">
+			<div>
+				<button type="button" class="btn btn-outline-danger xhr" ajax-target="ModalContent" data-url="{% url 'delete_all_manually_added_taxon_profile_images' meta_app.id generic_content.id %}">{% trans 'Delete all Taxon Profile images that have been added manually' %}</button>
+			</div>
+			<div class="mt-3">
+				{% trans 'This will delete all manually added images across all taxon profiles.' %}
+			</div>
+		</div>
+	</div>
 {% endblock %}
 
 {% block extra_script %}

app_kit/features/taxon_profiles/tests/test_views.py

@@ -5,7 +5,7 @@ from django.urls import reverse
 
 from app_kit.tests.common import test_settings
 
-from app_kit.models import MetaAppGenericContent, ContentImage
+from app_kit.models import MetaAppGenericContent, ContentImage, MetaApp
 
 from app_kit.tests.mixins import (WithMetaApp, WithTenantClient, WithUser, WithLoggedInUser, WithAjaxAdminOnly,
                                   WithAdminOnly, ViewTestMixin, WithImageStore, WithMedia, WithFormTest)
@@ -20,7 +20,8 @@ from app_kit.features.taxon_profiles.views import (ManageTaxonProfiles, ManageTa
                 DeleteTaxonProfilesNavigationEntry, GetTaxonProfilesNavigation, ManageNavigationImage,
                 DeleteNavigationImage, DeleteTaxonProfilesNavigationEntryTaxon, DeleteTaxonTextTypeCategory,
                 ChangeNavigationEntryPublicationStatus, ManageTaxonTextTypeCategory, ManageTaxonTextSet,
-                DeleteTaxonTextSet, GetTaxonTextsManagement, SetTaxonTextSetForTaxonProfile)
+                DeleteTaxonTextSet, GetTaxonTextsManagement, SetTaxonTextSetForTaxonProfile,
+                DeleteAllManuallyAddedTaxonProfileImages)
 
 from app_kit.features.taxon_profiles.models import (TaxonProfiles, TaxonProfile, TaxonTextType,
                 TaxonText, TaxonProfilesNavigation, TaxonProfilesNavigationEntry,
@@ -2590,4 +2591,100 @@ class TestSetTaxonTextSetForTaxonProfile(WithTaxonProfile, WithTaxonProfiles, Vi
         
         self.taxon_profile.refresh_from_db()
         
-        self.assertEqual(self.taxon_profile.taxon_text_set, text_set)
+        self.assertEqual(self.taxon_profile.taxon_text_set, text_set)
+
+
+class TestDeleteAllManuallyAddedTaxonProfileImages(WithTaxonProfile, WithTaxonProfiles, ViewTestMixin,
+                WithImageStore, WithMedia, WithAjaxAdminOnly, WithUser, WithLoggedInUser, WithMetaApp, WithTenantClient, TenantTestCase):
+    
+    url_name = 'delete_all_manually_added_taxon_profile_images'
+    view_class = DeleteAllManuallyAddedTaxonProfileImages
+    
+    def get_url_kwargs(self):
+        url_kwargs = {
+            'meta_app_id': self.meta_app.id,
+            'taxon_profiles_id': self.generic_content.id,
+        }
+        return url_kwargs
+    
+    def create_content_images(self):
+
+        # taxon image
+        self.taxon_image_store = self.create_image_store()
+
+        # add image to nature guide meta node
+        self.meta_node_image = self.create_content_image(self.meta_app, self.user)
+
+        # add image to taxon profile
+        self.taxon_profile_image = self.create_content_image(self.taxon_profile, self.user)
+        
+
+    
+    @test_settings
+    def test_set_taxon_profiles(self):
+        
+        view = self.get_view()
+        view.meta_app = self.meta_app
+        view.set_taxon_profiles(**view.kwargs)
+        
+        self.assertEqual(view.taxon_profiles, self.generic_content)
+        
+    @test_settings
+    def test_get_context_data(self):
+        
+        view = self.get_view()
+        view.meta_app = self.meta_app
+        view.set_taxon_profiles(**view.kwargs)
+        
+        context = view.get_context_data(**view.kwargs)
+        
+        self.assertEqual(context['taxon_profiles'], self.generic_content)
+        self.assertFalse(context['success'])
+        
+    @test_settings
+    def test_post(self):
+        
+        view = self.get_view()
+        view.meta_app = self.meta_app
+        view.set_taxon_profiles(**view.kwargs)
+        
+        self.create_content_images()
+        
+        taxon_profile_ctype = ContentType.objects.get_for_model(TaxonProfile)
+        meta_app_ctype = ContentType.objects.get_for_model(MetaApp)
+        
+        # verify image exists
+        images_qry = ContentImage.objects.filter(
+            content_type=taxon_profile_ctype,
+            object_id=self.taxon_profile.id,
+        )
+        self.assertTrue(images_qry.exists())
+        
+        meta_app_images_qry = ContentImage.objects.filter(
+            content_type=meta_app_ctype,
+            object_id=self.meta_app.id,
+        )
+        
+        self.assertTrue(meta_app_images_qry.exists())
+        
+        # perform post to delete images
+        response = view.post(view.request, **view.kwargs)
+        
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(response.context_data['success'])
+        
+        # verify images deleted
+        images_qry = ContentImage.objects.filter(
+            content_type=taxon_profile_ctype,
+            object_id=self.taxon_profile.id,
+        )
+        self.assertFalse(images_qry.exists())
+        
+        # verify meta app image still exists
+        meta_app_images_qry = ContentImage.objects.filter(
+            content_type=meta_app_ctype,
+            object_id=self.meta_app.id,
+        )
+        self.assertTrue(meta_app_images_qry.exists())
+        
+        

app_kit/features/taxon_profiles/tests/test_zip_import.py

@@ -352,6 +352,10 @@ class TestTaxonProfilesZipImporter(WithMedia, WithTaxonProfiles, WithUser, WithM
                                                                   taxon_latname='Fraxinus excelsior', morphotype='leaf')
         self.assertEqual(fraxinus_excielior_leaf_profile.short_profile,'Fraxinus excelsior morphotype leaf short profile')
         
+        
+        
+    
+        
     @test_settings
     def test_partial_import(self):
         importer = self.get_zip_importer()

app_kit/features/taxon_profiles/urls.py

@@ -119,4 +119,7 @@ urlpatterns = [
      # move images
      path('move-taxon-profile-image-to-section/<int:meta_app_id>/<int:taxon_profile_id>/<int:content_image_id>/',
            views.MoveImageToSection.as_view(), name='move_taxon_profile_image_to_section'),
+     # delete all manually added images
+     path('delete-all-manually-added-taxon-profile-images/<int:meta_app_id>/<int:taxon_profiles_id>/',
+           views.DeleteAllManuallyAddedTaxonProfileImages.as_view(), name='delete_all_manually_added_taxon_profile_images'),
 ]

app_kit/features/taxon_profiles/views.py

@@ -1580,4 +1580,41 @@ class MoveImageToSection(MetaAppMixin, FormView):
         context['success'] = True
 
         return self.render_to_response(context)
-    
+    
+    
+class DeleteAllManuallyAddedTaxonProfileImages(MetaAppMixin, TemplateView):
+    
+    template_name = 'taxon_profiles/ajax/delete_all_manually_added_images.html'
+    
+    @method_decorator(ajax_required)
+    def dispatch(self, request, *args, **kwargs):
+        self.set_taxon_profiles(**kwargs)
+        return super().dispatch(request, *args, **kwargs)
+    
+    def set_taxon_profiles(self, **kwargs):
+        self.taxon_profiles = TaxonProfiles.objects.get(pk=kwargs['taxon_profiles_id'])
+        
+    def get_context_data(self, **kwargs):
+        context = super().get_context_data(**kwargs)
+        context['taxon_profiles'] = self.taxon_profiles
+        context['success'] = False
+        return context
+    
+    def post(self, request, *args, **kwargs):
+        
+        taxon_profile_ctype = ContentType.objects.get_for_model(TaxonProfile)
+        all_taxon_profiles = TaxonProfile.objects.filter(taxon_profiles=self.taxon_profiles)
+        
+        images_to_delete = ContentImage.objects.filter(
+            content_type=taxon_profile_ctype,
+            object_id__in=all_taxon_profiles.values_list('id', flat=True)
+        )
+        
+        deleted_count = images_to_delete.count()
+        images_to_delete.delete()
+        
+        context = self.get_context_data(**self.kwargs)
+        context['deleted_count'] = deleted_count
+        context['success'] = True
+        
+        return self.render_to_response(context)

app_kit/forms.py

@@ -18,6 +18,8 @@ from app_kit.appbuilder.AppBuilderBase import AppBuilderBase
 from taxonomy.models import MetaVernacularNames
 from taxonomy.lazy import LazyTaxon
 
+from content_licencing.mixins import LicencingFormMixin
+
 import base64, math, uuid
 
 from .definitions import TEXT_LENGTH_RESTRICTIONS
@@ -130,7 +132,13 @@ class AddLanguageForm(forms.Form):
 '''
 from localcosmos_server.forms import (ManageContentImageForm, ManageContentImageWithTextForm,
     ManageLocalizedContentImageForm, OptionalContentImageForm)
+
+class ManageContentLicenceForm(LicencingFormMixin):
+    content_field = None
     
+    def __init__(self, content_field, *args, **kwargs):
+        self.content_field = content_field
+        super().__init__(*args, **kwargs)
 
 class GenericContentOptionsForm(forms.Form):
 

app_kit/generic_content_zip_import.py

@@ -570,6 +570,180 @@ class GenericContentZipImporter:
                 'valid_media_types': ', '.join(AVAILABLE_EXTERNAL_MEDIA_TYPES),
             }
             self.add_cell_error(self.workbook_filename, sheet_name, 'B', row_index, message)
+            
+        if external_media_data['media_type']:
+            # call specific validator method for each media type
+            validator_method_name = 'validate_external_media_type_{0}'.format(
+                external_media_data['media_type'].lower()
+            )
+            validator_method = getattr(self, validator_method_name, None)
+            if validator_method:
+                validator_method(external_media_data, sheet_name, row_index)
+            
+    
+    
+    '''
+        image, youTube, vimeo, mp3, wav, pdf, website, file
+    '''
+    def validate_external_media_type_image(self, external_media_data, sheet_name, row_index):
+        # check that the url ends with a valid image extension
+        image_extension = os.path.splitext(external_media_data['url'])[1].lower()
+        if image_extension not in VALID_IMAGE_FORMATS:
+            message = _('Invalid image format in URL: %(cell_value)s. Valid formats are: %(valid_formats)s') % {
+                'cell_value': image_extension,
+                'valid_formats': ', '.join(VALID_IMAGE_FORMATS),
+            }
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+        
+        
+    
+    def validate_external_media_type_youtube(self, external_media_data, sheet_name, row_index):
+        url = (external_media_data.get('url') or '').strip()
+        if not url:
+            message = _('Invalid YouTube URL: empty value')
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        try:
+            from urllib.parse import urlparse, parse_qs
+            parsed = urlparse(url)
+            netloc = (parsed.netloc or '').lower()
+            path = parsed.path or ''
+            query = parse_qs(parsed.query or '')
+        except Exception:
+            message = _('Invalid YouTube URL: %(cell_value)s') % {'cell_value': url}
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        if parsed.scheme not in ('http', 'https'):
+            message = _('Invalid YouTube URL (scheme must be http/https): %(cell_value)s') % {'cell_value': url}
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        video_id = None
+
+        # youtu.be/<id>
+        if netloc.endswith('youtu.be'):
+            candidate = path.lstrip('/')
+            m = re.match(r'^([A-Za-z0-9_-]{11})(?:$|[/?#])', candidate)
+            if m:
+                video_id = m.group(1)
+
+        # *.youtube.com/... variants
+        if not video_id and netloc.endswith('youtube.com'):
+            # watch?v=<id>
+            vvals = query.get('v')
+            if vvals:
+                v = vvals[0]
+                if re.fullmatch(r'[A-Za-z0-9_-]{11}', v or ''):
+                    video_id = v
+            # /embed/<id>, /v/<id>, /shorts/<id>
+            if not video_id:
+                m = re.search(r'/(?:embed|v|shorts)/([A-Za-z0-9_-]{11})(?:$|[/?#])', path)
+                if m:
+                    video_id = m.group(1)
+
+        if not video_id:
+            message = _('Invalid YouTube URL or video id not found: %(cell_value)s') % {'cell_value': url}
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        # Optionally: could normalize/store the ID if needed
+        # external_media_data['video_id'] = video_id
+    
+    def validate_external_media_type_vimeo(self, external_media_data, sheet_name, row_index):
+        url = (external_media_data.get('url') or '').strip()
+        if not url:
+            message = _('Invalid Vimeo URL: empty value')
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        try:
+            from urllib.parse import urlparse
+            parsed = urlparse(url)
+            netloc = (parsed.netloc or '').lower()
+            path = parsed.path or ''
+        except Exception:
+            message = _('Invalid Vimeo URL: %(cell_value)s') % {'cell_value': url}
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        if parsed.scheme not in ('http', 'https'):
+            message = _('Invalid Vimeo URL (scheme must be http/https): %(cell_value)s') % {'cell_value': url}
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        video_id = None
+
+        if netloc.endswith('vimeo.com'):
+            # player.vimeo.com/video/<id>
+            m = re.search(r'/video/(\d+)(?:$|[/?#])', path)
+            if m:
+                video_id = m.group(1)
+            # vimeo.com/<id> or any path ending with /<digits>
+            if not video_id:
+                m = re.search(r'/(\d+)(?:$|[/?#])', path)
+                if m:
+                    video_id = m.group(1)
+
+        if not video_id:
+            message = _('Invalid Vimeo URL or video id not found: %(cell_value)s') % {'cell_value': url}
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+            return
+
+        # Optionally: could normalize/store the ID if needed
+        # external_media_data['video_id'] = video_id
+    
+    
+    def validate_external_media_type_mp3(self, external_media_data, sheet_name, row_index):
+        # has to end with .mp3
+        if not external_media_data['url'].lower().endswith('.mp3'):
+            message = _('Invalid mp3 format in URL: %(cell_value)s. URL has to end with .mp3') % {
+                'cell_value': external_media_data['url'],
+            }
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+    
+    def validate_external_media_type_wav(self, external_media_data, sheet_name, row_index):
+        # has to end with .wav
+        if not external_media_data['url'].lower().endswith('.wav'):
+            message = _('Invalid wav format in URL: %(cell_value)s. URL has to end with .wav') % {
+                'cell_value': external_media_data['url'],
+            }
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+    
+    def validate_external_media_type_pdf(self, external_media_data, sheet_name, row_index):
+        # has to end with .pdf
+        if not external_media_data['url'].lower().endswith('.pdf'):
+            message = _('Invalid pdf format in URL: %(cell_value)s. URL has to end with .pdf') % {
+                'cell_value': external_media_data['url'],
+            }
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+    
+    
+    def validate_external_media_type_website(self, external_media_data, sheet_name, row_index):
+        # Only flag as invalid if the PATH (not the domain) ends with a file extension
+        try:
+            from urllib.parse import urlparse
+            parsed = urlparse((external_media_data.get('url') or '').strip())
+            path = parsed.path or ''
+        except Exception:
+            path = ''
+
+        # Detect file-like endings in path (e.g., /file.jpg, /index.html)
+        if re.search(r'/[^/]+\.[a-zA-Z0-9]{2,5}$', path):
+            message = _('Invalid website format in URL: %(cell_value)s. URL should not end with a file extension.') % {
+                'cell_value': external_media_data['url'],
+            }
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
+    
+    
+    def validate_external_media_type_file(self, external_media_data, sheet_name, row_index):
+        # file endings: check if the url has a file extension
+        if not re.search(r'\.[a-zA-Z0-9]{2,5}($|\?)', external_media_data['url']):
+            message = _('Invalid file format in URL: %(cell_value)s. URL has to end with a file extension.') % {
+                'cell_value': external_media_data['url'],
+            }
+            self.add_cell_error(self.workbook_filename, sheet_name, 'A', row_index, message)
     
     
     def add_cell_error(self, filename, sheet_name, column, row, message):