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

app_kit/appbuilder/AppReleaseBuilder.py

@@ -1959,6 +1959,63 @@ class AppReleaseBuilder(AppBuilderBase):
             localized_long_text = self.get_localized_taxonprofile_text(text_dict['longTextKey'], glossarized_locale, app_locale)
         
         return localized_short_text, localized_long_text
+    
+    def get_localized_taxon_profile(self, profile_json, language_code):
+        
+        glossarized_locale_filepath = self._app_glossarized_locale_filepath(language_code)
+                    
+        glossarized_locale = {}
+        
+        if os.path.isfile(glossarized_locale_filepath):
+            with open(glossarized_locale_filepath, 'r') as f:
+                glossarized_locale = json.loads(f.read())
+        
+        app_locale = self.meta_app.localizations[language_code]
+        
+        localized_profile_json = profile_json.copy()
+        
+        localized_short_profile = self.get_localized_taxonprofile_text(localized_profile_json['shortProfile'], glossarized_locale, app_locale)
+        localized_profile_json['shortProfile'] = localized_short_profile
+        
+        for index, text_dict in enumerate(profile_json['texts'], 0):
+            
+            localized_short_text, localized_long_text = self.get_localized_taxonprofile_taxon_text(text_dict, glossarized_locale, app_locale)
+                
+            localized_profile_json['texts'][index]['shortText'] = localized_short_text
+            localized_profile_json['texts'][index]['longText'] = localized_long_text
+            
+        
+        for c_index, category in enumerate(profile_json['categorizedTexts'], 0):
+            
+            localized_category = category.copy()
+            
+            localized_category_name = self.get_localized_taxonprofile_text(category['category'], glossarized_locale, app_locale)
+                
+            if localized_category:
+                localized_category['category'] = localized_category_name
+            
+            for index, text_dict in enumerate(category['texts'], 0):
+                localized_short_text, localized_long_text = self.get_localized_taxonprofile_taxon_text(text_dict, glossarized_locale, app_locale)
+                
+                localized_category['texts'][index]['shortText'] = localized_short_text
+                localized_category['texts'][index]['longText'] = localized_long_text
+                
+            localized_profile_json['categorizedTexts'][c_index] = localized_category
+            
+        # localize seo, no glossarized locale
+        localized_seo = localized_profile_json['seo'].copy()
+        title = localized_seo['title']
+        meta_description = localized_seo['metaDescription']
+        
+        if title and title in app_locale:
+            localized_seo = app_locale[title]
+            
+        if meta_description and meta_description in app_locale:
+            localized_seo['metaDescription'] = app_locale[meta_description]
+
+        localized_profile_json['seo'] = localized_seo
+        
+        return localized_profile_json
         
     def _build_TaxonProfiles(self, app_generic_content):
 
@@ -1993,6 +2050,11 @@ class AppReleaseBuilder(AppBuilderBase):
 
         if not os.path.isdir(app_absolute_taxonprofiles_path):
             os.makedirs(app_absolute_taxonprofiles_path)
+            
+        # morphotype paths
+        app_relative_morphotype_profiles_folder = os.path.join(app_relative_taxonprofiles_folder, 'morphotypes')
+        self.build_features[generic_content_type]['localizedMorphotypeFiles'] = {}
+        app_absolute_morphotype_profiles_path = os.path.join(app_absolute_taxonprofiles_path, 'morphotypes')
 
 
         collected_taxa = taxon_profiles.collected_taxa(published_only=True)
@@ -2081,8 +2143,10 @@ class AppReleaseBuilder(AppBuilderBase):
         self.build_features[generic_content_type]['localizedFiles'] = {}
         
         for profile_taxon in active_collected_taxa:
+            
+            morphotype = None
 
-            profile_json = jsonbuilder.build_taxon_profile(profile_taxon, 
+            profile_json = jsonbuilder.build_taxon_profile(profile_taxon, morphotype,
                                                            languages=self.meta_app.languages())
 
             if profile_json is not None:
@@ -2101,64 +2165,13 @@ class AppReleaseBuilder(AppBuilderBase):
                 # localized taxon profiles for faster language load
                 for language_code in self.meta_app.languages():
                     
-                    glossarized_locale_filepath = self._app_glossarized_locale_filepath(language_code)
-                    
-                    glossarized_locale = {}
-                    
-                    if os.path.isfile(glossarized_locale_filepath):
-                        with open(glossarized_locale_filepath, 'r') as f:
-                            glossarized_locale = json.loads(f.read())
+                    localized_profile_json = self.get_localized_taxon_profile(profile_json, language_code)
                     
                     relative_localized_taxonprofiles_folder = os.path.join(
                         app_relative_taxonprofiles_folder, language_code)
                     
                     if language_code not in self.build_features[generic_content_type]['localizedFiles']:
                         self.build_features[generic_content_type]['localizedFiles'][language_code] = '/{0}'.format(relative_localized_taxonprofiles_folder)
-        
-                    app_locale = self.meta_app.localizations[language_code]
-                    
-                    localized_profile_json = profile_json.copy()
-                    
-                    localized_short_profile = self.get_localized_taxonprofile_text(localized_profile_json['shortProfile'], glossarized_locale, app_locale)
-                    localized_profile_json['shortProfile'] = localized_short_profile
-                    
-                    for index, text_dict in enumerate(profile_json['texts'], 0):
-                        
-                        localized_short_text, localized_long_text = self.get_localized_taxonprofile_taxon_text(text_dict, glossarized_locale, app_locale)
-                            
-                        localized_profile_json['texts'][index]['shortText'] = localized_short_text
-                        localized_profile_json['texts'][index]['longText'] = localized_long_text
-                        
-                    
-                    for c_index, category in enumerate(profile_json['categorizedTexts'], 0):
-                        
-                        localized_category = category.copy()
-                        
-                        localized_category_name = self.get_localized_taxonprofile_text(category['category'], glossarized_locale, app_locale)
-                            
-                        if localized_category:
-                            localized_category['category'] = localized_category_name
-                        
-                        for index, text_dict in enumerate(category['texts'], 0):
-                            localized_short_text, localized_long_text = self.get_localized_taxonprofile_taxon_text(text_dict, glossarized_locale, app_locale)
-                            
-                            localized_category['texts'][index]['shortText'] = localized_short_text
-                            localized_category['texts'][index]['longText'] = localized_long_text
-                            
-                        localized_profile_json['categorizedTexts'][c_index] = localized_category
-                        
-                    # localize seo, no glossarized locale
-                    localized_seo = localized_profile_json['seo'].copy()
-                    title = localized_seo['title']
-                    meta_description = localized_seo['metaDescription']
-                    
-                    if title and title in app_locale:
-                        localized_seo = app_locale[title]
-                        
-                    if meta_description and meta_description in app_locale:
-                        localized_seo['metaDescription'] = app_locale[meta_description]
-
-                    localized_profile_json['seo'] = localized_seo
                     
                     absolute_localized_taxonprofiles_folder = os.path.join(
                         app_absolute_taxonprofiles_path, language_code)
@@ -2177,7 +2190,52 @@ class AppReleaseBuilder(AppBuilderBase):
 
                     with open(localized_profile_filepath, 'w', encoding='utf-8') as f:
                         json.dump(localized_profile_json, f, indent=4, ensure_ascii=False)
+                        
+            # build morphotype profiles
+            morphotypes = []
+            taxon_profile = TaxonProfile.objects.filter(taxon_profiles=taxon_profiles,
+                taxon_source=profile_taxon.taxon_source, taxon_latname=profile_taxon.taxon_latname,
+                taxon_author=profile_taxon.taxon_author).first()
+
+            if taxon_profile and taxon_profile.morphotype_profiles:
+                morphotypes = taxon_profile.morphotype_profiles.values_list('morphotype', flat=True)
                 
+                
+            for morphotype in morphotypes:
+
+                morphotype_profile_json = jsonbuilder.build_taxon_profile(profile_taxon, morphotype,
+                                                           languages=self.meta_app.languages())
+
+                if morphotype_profile_json is not None:
+
+                    for language_code in self.meta_app.languages():
+                        
+                        localized_profile_json = self.get_localized_taxon_profile(morphotype_profile_json, language_code)
+                        
+                        relative_localized_morphotype_profiles_folder = os.path.join(
+                            app_relative_morphotype_profiles_folder, language_code)
+                        
+                        if language_code not in self.build_features[generic_content_type]['localizedMorphotypeFiles']:
+                            self.build_features[generic_content_type]['localizedMorphotypeFiles'][language_code] = '/{0}'.format(relative_localized_morphotype_profiles_folder)
+                            
+                        
+                        absolute_localized_morphotype_profiles_folder = os.path.join(
+                            app_absolute_morphotype_profiles_path, language_code)
+                        
+                        if not os.path.isdir(absolute_localized_morphotype_profiles_folder):
+                            os.makedirs(absolute_localized_morphotype_profiles_folder)
+                        
+                        localized_source_folder = os.path.join(absolute_localized_morphotype_profiles_folder,
+                                                           profile_taxon.taxon_source)
+                        
+                        if not os.path.isdir(localized_source_folder):
+                            os.makedirs(localized_source_folder)
+                            
+                        localized_morphotype_profile_filepath = os.path.join(localized_source_folder,
+                                                              '{0}_{1}.json'.format(profile_taxon.name_uuid, morphotype))
+                        
+                        with open(localized_morphotype_profile_filepath, 'w', encoding='utf-8') as f:
+                            json.dump(morphotype_profile_json, f, indent=4, ensure_ascii=False)
 
 
         # build search index and registry

app_kit/appbuilder/JSONBuilders/TaxonProfilesJSONBuilder.py

@@ -52,7 +52,7 @@ class TaxonProfilesJSONBuilder(JSONBuilder):
         installed_taxonomic_sources = [s[0] for s in settings.TAXONOMY_DATABASES]
         return installed_taxonomic_sources
 
-
+    '''
     def collect_node_traits(self, node):
 
         #self.app_release_builder.logger.info('collecting node traits for {0}'.format(node.meta_node.name))
@@ -95,6 +95,7 @@ class TaxonProfilesJSONBuilder(JSONBuilder):
         #self.app_release_builder.logger.info('finished collecting')
 
         return node_traits
+    '''
     
 
     def get_vernacular_name_from_nature_guides(self, lazy_taxon):
@@ -109,7 +110,7 @@ class TaxonProfilesJSONBuilder(JSONBuilder):
         return template_contents
 
     # languages is for the vernacular name only, the rest are keys for translation
-    def build_taxon_profile(self, profile_taxon, languages):
+    def build_taxon_profile(self, profile_taxon, morphotype, languages):
         
         lazy_taxon = LazyTaxon(instance=profile_taxon)
 
@@ -118,7 +119,7 @@ class TaxonProfilesJSONBuilder(JSONBuilder):
         # get the profile
         db_profile = TaxonProfile.objects.filter(taxon_profiles=self.generic_content,
             taxon_source=profile_taxon.taxon_source, taxon_latname=profile_taxon.taxon_latname,
-            taxon_author=profile_taxon.taxon_author).first()
+            taxon_author=profile_taxon.taxon_author, morphotype=morphotype).first()
         
         
         taxon_profile_json = self.app_release_builder.taxa_builder.serialize_taxon_extended(lazy_taxon)
@@ -126,8 +127,9 @@ class TaxonProfilesJSONBuilder(JSONBuilder):
         # if the taxonomic db got updated, still use the old taxon latname and author here
         taxon_profile_json['taxonLatname'] = lazy_taxon.taxon_latname
         taxon_profile_json['taxonAuthor'] = lazy_taxon.taxon_author
+        images = []
         
-        images = self.app_release_builder.taxa_builder.serialize_taxon_images(lazy_taxon)
+        images = self.app_release_builder.taxa_builder.serialize_taxon_images(lazy_taxon, morphotype=morphotype)
 
         is_featured = False
         if db_profile:
@@ -139,6 +141,7 @@ class TaxonProfilesJSONBuilder(JSONBuilder):
 
         taxon_profile_json.update({
             'taxonProfileId': db_profile.id if db_profile else None,
+            'morphotype': db_profile.morphotype if db_profile else None,
             'vernacular' : {},
             'allVernacularNames' : {},
             'nodeNames' : [], # if the taxon occurs in a nature guide, primary_language only
@@ -151,7 +154,7 @@ class TaxonProfilesJSONBuilder(JSONBuilder):
             'synonyms' : [],
             'templateContents' : [],
             'genericForms' : self.collect_usable_generic_forms(profile_taxon),
-            'taxonRelationships': self.collect_taxon_relationships(profile_taxon),
+            'taxonRelationships': self.collect_taxon_relationships(profile_taxon) if not morphotype else [],
             'tags' : [],
             'seo': {
                 'title': None,
@@ -162,14 +165,15 @@ class TaxonProfilesJSONBuilder(JSONBuilder):
             'isFeatured': is_featured,
         })
 
-        synonyms = profile_taxon.synonyms()
-        for synonym in synonyms:
-            synonym_entry = {
-                'taxonLatname' : synonym.taxon_latname,
-                'taxonAuthor' : synonym.taxon_author,
-            }
+        if not morphotype:
+            synonyms = profile_taxon.synonyms()
+            for synonym in synonyms:
+                synonym_entry = {
+                    'taxonLatname' : synonym.taxon_latname,
+                    'taxonAuthor' : synonym.taxon_author,
+                }
 
-            taxon_profile_json['synonyms'].append(synonym_entry)
+                taxon_profile_json['synonyms'].append(synonym_entry)
 
         for language_code in languages:
 
@@ -186,6 +190,24 @@ class TaxonProfilesJSONBuilder(JSONBuilder):
             
             # template contents
             taxon_profile_json['templateContents'] = self.get_taxon_profile_template_content_links(profile_taxon, language_code)
+            
+        # respect additional languages for vernacular names as defined in taxon profiles options
+        include_vernacular_names_languages_option = self.generic_content.get_option(self.meta_app,
+                                                                                   'include_vernacular_names_languages')
+        if include_vernacular_names_languages_option:
+            additional_languages = [lang.strip() for lang in include_vernacular_names_languages_option.split(',') if lang.strip()]
+            for language_code in additional_languages:
+                if language_code not in languages:
+                    preferred_vernacular_name = lazy_taxon.get_preferred_vernacular_name(language_code,
+                                                                                        self.meta_app)
+
+                    taxon_profile_json['vernacular'][language_code] = preferred_vernacular_name
+
+                    all_vernacular_names = profile_taxon.all_vernacular_names(self.meta_app,
+                                                                              languages=[language_code])
+
+                    names_list = [name_reference['name'] for name_reference in all_vernacular_names]
+                    taxon_profile_json['allVernacularNames'][language_code] = names_list
 
         # get taxon_profile_images
         if db_profile:
@@ -207,7 +229,7 @@ class TaxonProfilesJSONBuilder(JSONBuilder):
         # get information (traits, node_names) from nature guides if possible
         # collect node images
         # only use occurrences in nature guides of this app
-        node_occurrences = self.app_release_builder.taxa_builder.get_nature_guide_occurrences(lazy_taxon)
+        node_occurrences = self.app_release_builder.taxa_builder.get_nature_guide_occurrences(lazy_taxon, morphotype=morphotype)
 
         # collect traits of upward branch in tree (higher taxa)
         parent_nuids = set([])
@@ -287,7 +309,8 @@ class TaxonProfilesJSONBuilder(JSONBuilder):
 
         if db_profile:
             
-            taxon_profile_json['morphotypeProfiles'] = self.collect_morphotype_profiles(db_profile, languages)
+            if not morphotype:
+                taxon_profile_json['morphotypeProfiles'] = self.collect_morphotype_profiles(db_profile, languages)
             
             taxon_profile_json['shortProfile'] = db_profile.short_profile
             
@@ -469,7 +492,7 @@ class TaxonProfilesJSONBuilder(JSONBuilder):
                 'taxonProfileId': morphotype.id,
                 'parentTaxonProfileId': taxon_profile.id,
                 'morphotype': morphotype.morphotype,
-                'taxon': self.app_release_builder.taxa_builder.serialize_taxon(lazy_taxon),
+                'taxon': self.app_release_builder.taxa_builder.serialize_taxon_extended(lazy_taxon),
                 'vernacular' : {},
                 'image': image_entry,
             }

app_kit/appbuilder/TaxonBuilder.py

@@ -41,8 +41,7 @@ class TaxaBuilder(ContentImagesJSONBuilder):
         
     def serialize_taxon(self, lazy_taxon):
         taxon_serializer = TaxonSerializer(lazy_taxon, self)
-        return taxon_serializer.serialize()
-    
+        return taxon_serializer.serialize()    
     
     def serialize_taxon_extended(self, lazy_taxon):
         taxon_serializer = TaxonSerializer(lazy_taxon, self)
@@ -66,9 +65,9 @@ class TaxaBuilder(ContentImagesJSONBuilder):
                                   accepted_name_uuid)
     
     
-    def serialize_taxon_images(self, lazy_taxon):
+    def serialize_taxon_images(self, lazy_taxon, morphotype=None):
         taxon_serializer = TaxonSerializer(lazy_taxon, self)
-        return taxon_serializer.serialize_images()
+        return taxon_serializer.serialize_images(morphotype=morphotype)
     
     
     def get_nature_guide_ids(self):
@@ -80,7 +79,7 @@ class TaxaBuilder(ContentImagesJSONBuilder):
         return self.nature_guide_ids
     
     
-    def get_nature_guide_occurrences(self, lazy_taxon):
+    def get_nature_guide_occurrences(self, lazy_taxon, morphotype=None):
         nature_guide_ids = self.get_nature_guide_ids()
         
         if lazy_taxon.taxon_source in self.installed_taxonomic_sources:
@@ -88,6 +87,7 @@ class TaxaBuilder(ContentImagesJSONBuilder):
             meta_nodes = MetaNode.objects.filter(
                 nature_guide_id__in=nature_guide_ids,
                 node_type='result',
+                morphotype=morphotype,
                 name_uuid = lazy_taxon.name_uuid).values_list('pk', flat=True)
 
             node_occurrences = NatureGuidesTaxonTree.objects.filter(nature_guide_id__in=nature_guide_ids,
@@ -211,12 +211,13 @@ class TaxonSerializer:
         
         return taxon_json_copy
     
-    def get_taxon_profile(self):
+    def get_taxon_profile(self, morphotype=None):
         taxon_profile = None
         
         taxon_profile_qry = TaxonProfile.objects.filter(
             taxon_profiles=self.taxa_builder.taxon_profiles,
-            name_uuid=self.lazy_taxon.name_uuid).first()
+            name_uuid=self.lazy_taxon.name_uuid,
+            morphotype=morphotype).first()
         
         if taxon_profile_qry and taxon_profile_qry.publication_status != 'draft':
             taxon_profile = taxon_profile_qry
@@ -224,19 +225,23 @@ class TaxonSerializer:
         return taxon_profile
         
     
-    def serialize_images(self):
+    def serialize_images(self, morphotype=None):
         
         name_uuid_str = str(self.lazy_taxon.name_uuid)
+        cache_key=name_uuid_str
+        
+        if morphotype:
+            cache_key = name_uuid_str + '_' + morphotype
         
-        if name_uuid_str in self.taxa_builder.cache['images']:
-            taxon_images = self.taxa_builder.cache['images'][name_uuid_str]
+        if cache_key in self.taxa_builder.cache['images']:
+            taxon_images = self.taxa_builder.cache['images'][cache_key]
         
         else:
                 
             collected_content_image_ids = set([])
             collected_image_store_ids = set([])
             
-            taxon_profile = self.get_taxon_profile()
+            taxon_profile = self.get_taxon_profile(morphotype=morphotype)
             
             taxon_images = {
                 'primary': None,
@@ -272,8 +277,9 @@ class TaxonSerializer:
                     taxon_images['primary'] = image_entry
             
             
+
             # images from nature guides
-            node_occurrences = self.taxa_builder.get_nature_guide_occurrences(self.lazy_taxon)
+            node_occurrences = self.taxa_builder.get_nature_guide_occurrences(self.lazy_taxon, morphotype=morphotype)
             
             for node in node_occurrences:
             
@@ -297,30 +303,31 @@ class TaxonSerializer:
                         
                         if taxon_images['primary'] == None:
                             taxon_images['primary'] = image_entry
-            
+                
                     
             # get taxonomic images
-            content_images_taxon = ContentImage.objects.filter(image_store__taxon_source=self.lazy_taxon.taxon_source,
-                                        image_store__taxon_latname=self.lazy_taxon.taxon_latname,
-                                        image_store__taxon_author=self.lazy_taxon.taxon_author).exclude(
-                                        pk__in=list(collected_content_image_ids))
+            if not morphotype:
+                content_images_taxon = ContentImage.objects.filter(image_store__taxon_source=self.lazy_taxon.taxon_source,
+                                            image_store__taxon_latname=self.lazy_taxon.taxon_latname,
+                                            image_store__taxon_author=self.lazy_taxon.taxon_author).exclude(
+                                            pk__in=list(collected_content_image_ids))
 
-            #self.app_release_builder.logger.info('Found {0} images for {1}'.format(taxon_images.count(), profile_taxon.taxon_latname))
+                #self.app_release_builder.logger.info('Found {0} images for {1}'.format(taxon_images.count(), profile_taxon.taxon_latname))
 
-            for taxon_image in content_images_taxon:
+                for taxon_image in content_images_taxon:
 
-                if taxon_image is not None and taxon_image.id not in collected_content_image_ids and taxon_image.image_store.id not in collected_image_store_ids:
+                    if taxon_image is not None and taxon_image.id not in collected_content_image_ids and taxon_image.image_store.id not in collected_image_store_ids:
 
-                    image_entry = self.taxa_builder.get_image_json(taxon_image)
-                    taxon_images['taxonImages'].append(image_entry)
-                    
-                    if taxon_images['primary'] == None:
-                        taxon_images['primary'] = image_entry
+                        image_entry = self.taxa_builder.get_image_json(taxon_image)
+                        taxon_images['taxonImages'].append(image_entry)
+                        
+                        if taxon_images['primary'] == None:
+                            taxon_images['primary'] = image_entry
 
-                    collected_content_image_ids.add(taxon_image.id)
-                    collected_image_store_ids.add(taxon_image.image_store.id)
+                        collected_content_image_ids.add(taxon_image.id)
+                        collected_image_store_ids.add(taxon_image.image_store.id)
     
-            self.taxa_builder.cache['images'][name_uuid_str] = taxon_images
+            self.taxa_builder.cache['images'][cache_key] = taxon_images
             
         taxon_images_copy = copy.deepcopy(taxon_images)
         

app_kit/features/backbonetaxonomy/templates/backbonetaxonomy/manage_taxon.html

@@ -29,7 +29,7 @@
             <div class="mt-5">
                 <h3>{% trans 'Taxon Profile' %}</h3>
                 {% if taxon_profile %}
-                    <a href="{% url 'manage_taxon_profile' meta_app.id taxon_profiles.id taxon.taxon_source taxon.name_uuid %}">{{ taxon }}</a>
+                    <a href="{% url 'manage_taxon_profile' meta_app.id taxon_profile.id %}">{{ taxon }}</a>
                 {% else %}
                     {% trans 'This taxon does not have a taxon profile' %}
                 {% endif %}

app_kit/features/taxon_profiles/forms.py

@@ -29,6 +29,9 @@ class TaxonProfilesOptionsForm(GenericFormChoicesMixin, GenericContentOptionsFor
     
     enable_taxonomic_navigation = forms.BooleanField(required=False, label=_('Enable Taxonomic Navigation'))
     
+    include_vernacular_names_languages = forms.CharField(required=False, label=_('Include Vernacular Names Languages'),
+        help_text=_('A comma-separated list of language codes (e.g. "en,de,fr") to include vernacular names from. Leave empty to include all available languages.'))
+    
     version = forms.CharField(help_text=_('You can manually set you own version here. This will not affect the automated versioning.'), required=False)
 
 
@@ -94,8 +97,6 @@ class ManageTaxonTextsForm(LocalizeableForm):
 
         self.layoutable_simple_fields = []
         
-        self.has_categories = False
-        
         super().__init__(*args, **kwargs)
         
         categories = [None] + list(TaxonTextTypeCategory.objects.filter(taxon_profiles=taxon_profiles))
@@ -105,34 +106,12 @@ class ManageTaxonTextsForm(LocalizeableForm):
         if taxon_profile.taxon_text_set:
             allowed_text_types = taxon_profile.taxon_text_set.text_types.values_list('pk', flat=True)
         
-        if len(categories) > 1:
-            self.has_categories = True
-        
-        for category_index, category in enumerate(categories, 1):
-
-            types = TaxonTextType.objects.filter(taxon_profiles=taxon_profiles, category=category, pk__in=allowed_text_types).order_by('category', 'position')
-
-            category_label = 'uncategorized'
-            if category:
-                category_label = category.name
-                
-            category_helper_field = forms.CharField(widget=forms.HiddenInput(), label=category_label, required=False)
-            category_helper_field.category = category
-            category_helper_field.is_category_field = True
-            category_helper_field.text_type_count = types.count()
-            category_helper_field.is_first_category = False
-            category_helper_field.is_last = False
-            
-            if category_index == 2:
-                category_helper_field.is_first_category = True
-                
-            if not types:
-                category_helper_field.is_last = True
+        for category in categories:
             
-            self.fields[category_label] = category_helper_field
+            types = TaxonTextType.objects.filter(taxon_profiles=taxon_profiles, category=category, pk__in=allowed_text_types).order_by('category', 'position')
             
             for field_index, text_type in enumerate(types, 1):
-
+                
                 short_text_field_name = text_type.text_type
                 
                 self.text_type_map[short_text_field_name] = text_type
@@ -143,14 +122,17 @@ class ManageTaxonTextsForm(LocalizeableForm):
                                         required=False, label=short_text_field_label, validators=[json_compatible])
                 short_text_field.taxon_text_type = text_type
                 short_text_field.is_short_version = True
-                short_text_field.is_last = False
                 short_text_field.taxon_text = None
+                short_text_field.category = None
 
                 self.fields[short_text_field_name] = short_text_field
                 self.localizeable_fields.append(short_text_field_name)
                 self.fields[short_text_field_name].language = self.language
                 self.layoutable_simple_fields.append(short_text_field_name)
                 
+                if field_index == 1:
+                    short_text_field.category = category
+                
 
                 if settings.APP_KIT_ENABLE_TAXON_PROFILES_LONG_TEXTS == True:
                     long_text_field_name = self.get_long_text_form_field_name(text_type)
@@ -162,19 +144,12 @@ class ManageTaxonTextsForm(LocalizeableForm):
                                             required=False, label=long_text_field_label, validators=[json_compatible])
                     long_text_field.taxon_text_type = text_type
                     long_text_field.is_short_version = False
-                    long_text_field.is_last = False
 
                     self.fields[long_text_field_name] = long_text_field
                     self.localizeable_fields.append(long_text_field_name)
                     self.fields[long_text_field_name].language = self.language
                     self.layoutable_simple_fields.append(long_text_field_name)
-                    
-                if field_index == len(types):
-                    if settings.APP_KIT_ENABLE_TAXON_PROFILES_LONG_TEXTS == True:
-                        long_text_field.is_last = True
-                    else:
-                        short_text_field.is_last = True
-
+                
                 if taxon_profile:
                     content = TaxonText.objects.filter(taxon_text_type=text_type,
                                     taxon_profile=taxon_profile).first()
@@ -185,7 +160,7 @@ class ManageTaxonTextsForm(LocalizeableForm):
                         if settings.APP_KIT_ENABLE_TAXON_PROFILES_LONG_TEXTS == True:
                             long_text_field.initial = content.long_text
                             long_text_field.taxon_text = content
-    
+            
     
     def get_long_text_form_field_name(self, text_type):