[Feature] External Identifier/References

Co-authored-by: Tim Lorsbach <tim@lorsba.ch>
Reviewed-on: enviPath/enviPy#139

epdb/admin.py

@@ -16,7 +16,9 @@ from .models import (
     Node,
     Edge,
     Scenario,
-    Setting
+    Setting,
+    ExternalDatabase,
+    ExternalIdentifier
 )
 
 
@@ -43,6 +45,7 @@ class EPAdmin(admin.ModelAdmin):
 class PackageAdmin(EPAdmin):
     pass
 
+
 class MLRelativeReasoningAdmin(EPAdmin):
     pass
 
@@ -87,6 +90,14 @@ class SettingAdmin(EPAdmin):
     pass
 
 
+class ExternalDatabaseAdmin(admin.ModelAdmin):
+    pass
+
+
+class ExternalIdentifierAdmin(admin.ModelAdmin):
+    pass
+
+
 admin.site.register(User, UserAdmin)
 admin.site.register(UserPackagePermission, UserPackagePermissionAdmin)
 admin.site.register(Group, GroupAdmin)
@@ -103,3 +114,5 @@ admin.site.register(Node, NodeAdmin)
 admin.site.register(Edge, EdgeAdmin)
 admin.site.register(Setting, SettingAdmin)
 admin.site.register(Scenario, ScenarioAdmin)
+admin.site.register(ExternalDatabase, ExternalDatabaseAdmin)
+admin.site.register(ExternalIdentifier, ExternalIdentifierAdmin)

epdb/management/commands/bootstrap.py

@@ -116,7 +116,7 @@ class Command(BaseCommand):
                 'full_name': 'KEGG Reaction Database',
                 'description': 'Database of biochemical reactions',
                 'base_url': 'https://www.genome.jp',
-                'url_pattern': 'https://www.genome.jp/entry/reaction+{id}'
+                'url_pattern': 'https://www.genome.jp/entry/{id}'
             },
             {
                 'name': 'UniProt',

epdb/management/commands/import_external_identifiers.py

@@ -0,0 +1,57 @@
+from csv import DictReader
+
+from django.core.management.base import BaseCommand
+
+from epdb.models import *
+
+
+class Command(BaseCommand):
+    STR_TO_MODEL = {
+        'Compound': Compound,
+        'CompoundStructure': CompoundStructure,
+        'Reaction': Reaction,
+    }
+
+    STR_TO_DATABASE = {
+        'ChEBI': ExternalDatabase.objects.get(name='ChEBI'),
+        'RHEA': ExternalDatabase.objects.get(name='RHEA'),
+        'KEGG Reaction': ExternalDatabase.objects.get(name='KEGG Reaction'),
+        'PubChem Compound': ExternalDatabase.objects.get(name='PubChem Compound'),
+        'PubChem Substance': ExternalDatabase.objects.get(name='PubChem Substance'),
+    }
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--data',
+            type=str,
+            help='Path of the ID Mapping file.',
+            required=True,
+        )
+
+        parser.add_argument(
+            '--replace-host',
+            type=str,
+            help='Replace https://envipath.org/ with this host, e.g. http://localhost:8000/',
+        )
+
+    @transaction.atomic
+    def handle(self, *args, **options):
+        with open(options['data']) as fh:
+            reader = DictReader(fh)
+            for row in reader:
+                clz = self.STR_TO_MODEL[row['model']]
+
+                url = row['url']
+                if options['replace_host']:
+                    url = url.replace('https://envipath.org/', options['replace_host'])
+
+                instance = clz.objects.get(url=url)
+                db = self.STR_TO_DATABASE[row['identifier_type']]
+
+                ExternalIdentifier.objects.create(
+                    content_object=instance,
+                    database=db,
+                    identifier_value=row['identifier_value'],
+                    url=db.url_pattern.format(id=row['identifier_value']),
+                    is_primary=False
+                )

epdb/models.py

@@ -277,6 +277,53 @@ class ExternalDatabase(TimeStampedModel):
             return self.url_pattern.format(id=identifier_value)
         return None
 
+    @staticmethod
+    def get_databases():
+        return {
+            'compound': [
+                {
+                    'database': ExternalDatabase.objects.get(name='PubChem Compound'),
+                    'placeholder': 'PubChem Compound ID e.g. 12345',
+                }, {
+                    'database': ExternalDatabase.objects.get(name='PubChem Substance'),
+                    'placeholder': 'PubChem Substance ID e.g. 12345',
+                }, {
+                    'database': ExternalDatabase.objects.get(name='KEGG Reaction'),
+                    'placeholder': 'KEGG ID including entity Prefix e.g. C12345',
+                }, {
+                    'database': ExternalDatabase.objects.get(name='ChEBI'),
+                    'placeholder': 'ChEBI ID without prefix e.g. 12345',
+                },
+            ],
+            'structure': [
+                {
+                    'database': ExternalDatabase.objects.get(name='PubChem Compound'),
+                    'placeholder': 'PubChem Compound ID e.g. 12345',
+                }, {
+                    'database': ExternalDatabase.objects.get(name='PubChem Substance'),
+                    'placeholder': 'PubChem Substance ID e.g. 12345',
+                }, {
+                    'database': ExternalDatabase.objects.get(name='KEGG Reaction'),
+                    'placeholder': 'KEGG ID including entity Prefix e.g. C12345',
+                }, {
+                    'database': ExternalDatabase.objects.get(name='ChEBI'),
+                    'placeholder': 'ChEBI ID without prefix e.g. 12345',
+                },
+            ],
+            'reaction': [
+                {
+                    'database': ExternalDatabase.objects.get(name='KEGG Reaction'),
+                    'placeholder': 'KEGG ID including entity Prefix e.g. C12345',
+                }, {
+                    'database': ExternalDatabase.objects.get(name='RHEA'),
+                    'placeholder': 'RHEA ID without Prefix e.g. 12345',
+                }, {
+                    'database': ExternalDatabase.objects.get(name='UniProt'),
+                    'placeholder': 'Query ID for UniPro e.g. rhea:12345',
+                }
+            ]
+        }
+
 
 class ExternalIdentifier(TimeStampedModel):
     uuid = models.UUIDField(default=uuid4, editable=False, unique=True)

epdb/views.py

@@ -17,7 +17,7 @@ from utilities.misc import HTMLGenerator
 from .logic import GroupManager, PackageManager, UserManager, SettingManager, SearchManager, EPDBURLParser
 from .models import Package, GroupPackagePermission, Group, CompoundStructure, Compound, Reaction, Rule, Pathway, Node, \
     EPModel, EnviFormer, MLRelativeReasoning, RuleBasedRelativeReasoning, Scenario, SimpleAmbitRule, APIToken, \
-    UserPackagePermission, Permission, License, User, Edge
+    UserPackagePermission, Permission, License, User, Edge, ExternalDatabase, ExternalIdentifier
 
 logger = logging.getLogger(__name__)
 
@@ -194,6 +194,7 @@ def get_base_context(request, for_user=None) -> Dict[str, Any]:
             'available_settings': SettingManager.get_all_settings(current_user),
             'enabled_features': s.FLAGS,
             'debug': s.DEBUG,
+            'external_databases': ExternalDatabase.get_databases(),
         },
     }
 
@@ -249,6 +250,9 @@ def copy_object(current_user, target_package: 'Package', source_object_url: str)
     # Ensures that source is readable
     source_package = PackageManager.get_package_by_url(current_user, source_object_url)
 
+    if source_package == target_package:
+        raise ValueError(f"Can't copy object {source_object_url} to the same package!")
+
     parser = EPDBURLParser(source_object_url)
 
     # if the url won't contain a package or is a plain package
@@ -892,7 +896,11 @@ def package(request, package_uuid):
                 if not object_to_copy:
                     return error(request, 'No object to copy', 'There was no object to copy.')
 
-                copied_object = copy_object(current_user, current_package, object_to_copy)
+                try:
+                    copied_object = copy_object(current_user, current_package, object_to_copy)
+                except ValueError as e:
+                    return JsonResponse({'error': f"Can't copy object {object_to_copy} to the same package!"}, status=400)
+
                 return JsonResponse({'success': copied_object.url})
             else:
                 return HttpResponseBadRequest()
@@ -1043,8 +1051,8 @@ def package_compound(request, package_uuid, compound_uuid):
             set_scenarios(current_user, current_compound, selected_scenarios)
             return redirect(current_compound.url)
 
-        new_compound_name = request.POST.get('compound-name')
+        new_compound_name = request.POST.get('compound-name', '').strip()
-        new_compound_description = request.POST.get('compound-description')
+        new_compound_description = request.POST.get('compound-description', '').strip()
 
         if new_compound_name:
             current_compound.name = new_compound_name
@@ -1055,6 +1063,20 @@ def package_compound(request, package_uuid, compound_uuid):
         if any([new_compound_name, new_compound_description]):
             current_compound.save()
             return redirect(current_compound.url)
+
+        selected_database = request.POST.get('selected-database', '').strip()
+        external_identifier = request.POST.get('identifier', '').strip()
+
+        if selected_database and external_identifier:
+            db = ExternalDatabase.objects.get(id=int(selected_database))
+            ExternalIdentifier.objects.create(
+                content_object=current_compound,
+                database=db,
+                identifier_value=external_identifier,
+                url=db.url_pattern.format(id=external_identifier),
+                is_primary=False
+            )
+            return redirect(current_compound.url)
         else:
             return HttpResponseBadRequest()
 
@@ -1146,12 +1168,39 @@ def package_compound_structure(request, package_uuid, compound_uuid, structure_u
             else:
                 return HttpResponseBadRequest()
 
+        new_structure_name = request.POST.get('compound-structure-name', '').strip()
+        new_structure_description = request.POST.get('compound-structure-description', '').strip()
+
+        if new_structure_name:
+            current_structure.name = new_structure_name
+
+        if new_structure_description:
+            current_structure.description = new_structure_description
+
+        if any([new_structure_name, new_structure_description]):
+            current_structure.save()
+            return redirect(current_structure.url)
+
         if 'selected-scenarios' in request.POST:
             selected_scenarios = request.POST.getlist('selected-scenarios')
 
             set_scenarios(current_user, current_structure, selected_scenarios)
             return redirect(current_structure.url)
 
+        selected_database = request.POST.get('selected-database', '').strip()
+        external_identifier = request.POST.get('identifier', '').strip()
+
+        if selected_database and external_identifier:
+            db = ExternalDatabase.objects.get(id=int(selected_database))
+            ExternalIdentifier.objects.create(
+                content_object=current_structure,
+                database=db,
+                identifier_value=external_identifier,
+                url=db.url_pattern.format(id=external_identifier),
+                is_primary=False
+            )
+            return redirect(current_structure.url)
+
         return HttpResponseBadRequest()
     else:
         return HttpResponseNotAllowed(['GET', ])
@@ -1382,8 +1431,8 @@ def package_reaction(request, package_uuid, reaction_uuid):
             set_scenarios(current_user, current_reaction, selected_scenarios)
             return redirect(current_reaction.url)
 
-        new_reaction_name = request.POST.get('reaction-name')
+        new_reaction_name = request.POST.get('reaction-name', '').strip()
-        new_reaction_description = request.POST.get('reaction-description')
+        new_reaction_description = request.POST.get('reaction-description', '').strip()
 
         if new_reaction_name:
             current_reaction.name = new_reaction_name
@@ -1394,8 +1443,22 @@ def package_reaction(request, package_uuid, reaction_uuid):
         if any([new_reaction_name, new_reaction_description]):
             current_reaction.save()
             return redirect(current_reaction.url)
-        else:
+
-            return HttpResponseBadRequest()
+        selected_database = request.POST.get('selected-database', '').strip()
+        external_identifier = request.POST.get('identifier', '').strip()
+
+        if selected_database and external_identifier:
+            db = ExternalDatabase.objects.get(id=int(selected_database))
+            ExternalIdentifier.objects.create(
+                content_object=current_reaction,
+                database=db,
+                identifier_value=external_identifier,
+                url=db.url_pattern.format(id=external_identifier),
+                is_primary=False
+            )
+            return redirect(current_reaction.url)
+
+        return HttpResponseBadRequest()
 
     else:
         return HttpResponseNotAllowed(['GET', 'POST'])

templates/actions/objects/compound.html

@@ -11,6 +11,10 @@
         <a role="button" data-toggle="modal" data-target="#set_scenario_modal">
             <i class="glyphicon glyphicon-plus"></i> Set Scenarios</a>
     </li>
+    <li>
+        <a role="button" data-toggle="modal" data-target="#generic_set_external_reference_modal">
+            <i class="glyphicon glyphicon-plus"></i> Set External Reference</a>
+    </li>
 {% endif %}
     <li>
         <a role="button" data-toggle="modal" data-target="#generic_copy_object_modal">

templates/actions/objects/compound_structure.html

@@ -7,6 +7,10 @@
         <a role="button" data-toggle="modal" data-target="#set_scenario_modal">
             <i class="glyphicon glyphicon-plus"></i> Set Scenarios</a>
     </li>
+    <li>
+        <a role="button" data-toggle="modal" data-target="#generic_set_external_reference_modal">
+            <i class="glyphicon glyphicon-plus"></i> Set External Reference</a>
+    </li>
     <li>
         <a class="button" data-toggle="modal" data-target="#generic_delete_modal">
             <i class="glyphicon glyphicon-trash"></i> Delete Compound Structure</a>

templates/actions/objects/reaction.html

@@ -7,6 +7,10 @@
         <a role="button" data-toggle="modal" data-target="#set_scenario_modal">
             <i class="glyphicon glyphicon-plus"></i> Set Scenarios</a>
     </li>
+    <li>
+        <a role="button" data-toggle="modal" data-target="#generic_set_external_reference_modal">
+            <i class="glyphicon glyphicon-plus"></i> Set External Reference</a>
+    </li>
 {% endif %}
     <li>
         <a role="button" data-toggle="modal" data-target="#generic_copy_object_modal">

templates/modals/objects/edit_compound_structure_modal.html

@@ -15,12 +15,12 @@
                     {% csrf_token %}
                     <p>
                         <label for="compound-structure-name">Name</label>
-                        <input id="compound-structure-name" class="form-control" name="compound-structure-name" value="{{ structure.name }}">
+                        <input id="compound-structure-name" class="form-control" name="compound-structure-name" value="{{ compound_structure.name }}">
                     </p>
                     <p>
                         <label for="compound-structure-description">Description</label>
                         <input id="compound-structure-description" type="text" class="form-control"
-                               value="{{ structure.description }}" name="compound-structure-description">
+                               value="{{ compound_structure.description }}" name="compound-structure-description">
                     </p>
                 </form>
             </div>

templates/modals/objects/generic_copy_object_modal.html

@@ -23,6 +23,8 @@
                     </select>
                     <input type="hidden" name="hidden" value="copy">
                 </form>
+                <div id="copy-object-error-message" class="alert alert-danger" role="alert" style="display: none">
+                </div>
             </div>
             <div class="modal-footer">
                 <button type="button" class="btn btn-secondary" data-dismiss="modal">Close</button>
@@ -38,6 +40,7 @@
 
         $('#generic-copy-object-modal-form-submit').click(function (e) {
             e.preventDefault();
+            $('#copy-object-error-message').hide()
 
             const packageUrl = $('#target-package').find(":selected").val();
 
@@ -49,12 +52,22 @@
                 object_to_copy: '{{ current_object.url }}',
             }
 
-            $.post(packageUrl, formData, function (response) {
+            $.ajax({
-                if (response.success) {
+                type: 'post',
-                    window.location.href = response.success;
+                data: formData,
+                url: packageUrl,
+                success: function (data, textStatus) {
+                    window.location.href = data.success;
+                },
+                error: function (jqXHR, textStatus, errorThrown) {
+                    if (jqXHR.responseJSON.error.indexOf('to the same package') > -1) {
+                        $('#copy-object-error-message').append('<p>The target Package is the same as the source Package. Please select another target!</p>');
+                    } else {
+                        $('#copy-object-error-message').append('<p>' + jqXHR.responseJSON.error + '</p>');
+                    }
+                    $('#copy-object-error-message').show();
                 }
             });
-
         });
 
     })

templates/modals/objects/generic_set_external_reference_modal.html

@@ -0,0 +1,60 @@
+{% load static %}
+<!-- Delete Object -->
+<div id="generic_set_external_reference_modal" class="modal" tabindex="-1">
+    <div class="modal-dialog">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3 class="modal-title">Add External References</h3>
+                <button type="button" class="close" data-dismiss="modal" aria-label="Close">
+                    <span aria-hidden="true">&times;</span>
+                </button>
+            </div>
+            <div class="modal-body">
+                <form id="generic-set-external-reference-modal-form" accept-charset="UTF-8"
+                      action="{{ current_object.url }}"
+                      data-remote="true" method="post">
+                    {% csrf_token %}
+                    <label for="database-select">Select the Database you want to attach an External Reference
+                        for</label>
+                    <select id="database-select" name="selected-database" data-actions-box='true' class="form-control"
+                            data-width='100%'>
+                        <option disabled selected>Select Database</option>
+                        {% for entity, databases in meta.external_databases.items %}
+                            {% if entity == object_type %}
+                                {% for db in databases %}
+                                    <option id="db-select-{{ db.database.pk }}" data-input-placeholder="{{ db.placeholder }}"
+                                            value="{{ db.database.id }}">{{ db.database.name }}</option>`
+                                {% endfor %}
+                            {% endif %}
+                        {% endfor %}
+                    </select>
+                    <p></p>
+                    <div id="input-div" style="display: none">
+                        <label for="identifier" >The reference</label>
+                        <input type="text" id="identifier" name="identifier" class="form-control" placeholder="">
+                    </div>
+                </form>
+            </div>
+            <div class="modal-footer">
+                <button type="button" class="btn btn-secondary" data-dismiss="modal">Close</button>
+                <button type="button" class="btn btn-primary" id="generic-set-external-reference-modal-form-submit">Submit</button>
+            </div>
+        </div>
+    </div>
+</div>
+<script>
+    $(function () {
+
+        $("#database-select").on("change", function () {
+            let selected = $(this).val();
+            $("#identifier").attr("placeholder", $('#db-select-' + selected).data('input-placeholder'));
+            $("#input-div").show();
+        });
+
+        $('#generic-set-external-reference-modal-form-submit').click(function (e) {
+            e.preventDefault();
+            $('#generic-set-external-reference-modal-form').submit();
+        });
+
+    })
+</script>

templates/objects/compound.html

@@ -6,6 +6,7 @@
         {% include "modals/objects/edit_compound_modal.html" %}
         {% include "modals/objects/add_structure_modal.html" %}
         {% include "modals/objects/generic_set_scenario_modal.html" %}
+        {% include "modals/objects/generic_set_external_reference_modal.html" %}
         {% include "modals/objects/generic_copy_object_modal.html" %}
         {% include "modals/objects/generic_delete_modal.html" %}
     {% endblock action_modals %}

templates/objects/compound_structure.html

@@ -5,6 +5,7 @@
 {% block action_modals %}
 {% include "modals/objects/edit_compound_structure_modal.html" %}
 {% include "modals/objects/generic_set_scenario_modal.html" %}
+{% include "modals/objects/generic_set_external_reference_modal.html" %}
 {% include "modals/objects/generic_delete_modal.html" %}
 {% endblock action_modals %}
 

templates/objects/reaction.html

@@ -6,6 +6,7 @@
         {% include "modals/objects/edit_reaction_modal.html" %}
         {% include "modals/objects/generic_set_scenario_modal.html" %}
         {% include "modals/objects/generic_copy_object_modal.html" %}
+        {% include "modals/objects/generic_set_external_reference_modal.html" %}
         {% include "modals/objects/generic_delete_modal.html" %}
     {% endblock action_modals %}
 

tests/views/test_compound_views.py

@@ -0,0 +1,315 @@
+from django.test import TestCase
+from django.urls import reverse
+from envipy_additional_information import Temperature, Interval
+
+from epdb.logic import UserManager, PackageManager
+from epdb.models import Compound, Scenario, ExternalIdentifier, ExternalDatabase
+
+
+class CompoundViewTest(TestCase):
+    fixtures = ["test_fixtures.jsonl.gz"]
+
+    @classmethod
+    def setUpClass(cls):
+        super(CompoundViewTest, cls).setUpClass()
+        cls.user1 = UserManager.create_user("user1", "user1@envipath.com", "SuperSafe",
+                                            set_setting=False, add_to_group=True, is_active=True)
+        cls.user1_default_package = cls.user1.default_package
+        cls.package = PackageManager.create_package(cls.user1, 'Test', 'Test Pack')
+
+    def setUp(self):
+        self.client.force_login(self.user1)
+
+    def test_create_compound(self):
+        response = self.client.post(
+            reverse("compounds"), {
+                "compound-name": "1,2-Dichloroethane",
+                "compound-description": "Eawag BBD compound c0001",
+                "compound-smiles": "C(CCl)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        compound_url = response.url
+
+        c = Compound.objects.get(url=compound_url)
+
+        self.assertEqual(c.package, self.user1_default_package)
+        self.assertEqual(c.name, "1,2-Dichloroethane")
+        self.assertEqual(c.description, "Eawag BBD compound c0001")
+        self.assertEqual(c.default_structure.smiles, "C(CCl)Cl")
+        self.assertEqual(c.default_structure.canonical_smiles, 'ClCCCl')
+        self.assertEqual(c.structures.all().count(), 2)
+        self.assertEqual(self.user1_default_package.compounds.count(), 1)
+
+        # Adding the same rule again should return the existing one, hence not increasing the number of rules
+        response = self.client.post(
+            reverse("compounds"), {
+                "compound-name": "1,2-Dichloroethane",
+                "compound-description": "Eawag BBD compound c0001",
+                "compound-smiles": "C(CCl)Cl",
+            }
+        )
+
+        self.assertEqual(response.url, compound_url)
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(self.user1_default_package.compounds.count(), 1)
+
+        # Adding the same rule in a different package should create a new rule
+        response = self.client.post(
+            reverse("package compound list", kwargs={'package_uuid': self.package.uuid}), {
+                "compound-name": "1,2-Dichloroethane",
+                "compound-description": "Eawag BBD compound c0001",
+                "compound-smiles": "C(CCl)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        self.assertNotEqual(compound_url, response.url)
+
+        # adding another reaction should increase count
+        response = self.client.post(
+            reverse("compounds"), {
+                "compound-name": "2-Chloroethanol",
+                "compound-description": "Eawag BBD compound c0005",
+                "compound-smiles": "C(CO)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(self.user1_default_package.compounds.count(), 2)
+
+    # Edit
+    def test_edit_rule(self):
+        response = self.client.post(
+            reverse("compounds"), {
+                "compound-name": "1,2-Dichloroethane",
+                "compound-description": "Eawag BBD compound c0001",
+                "compound-smiles": "C(CCl)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        compound_url = response.url
+
+        c = Compound.objects.get(url=compound_url)
+
+        response = self.client.post(
+            reverse("package compound detail", kwargs={
+                'package_uuid': str(self.user1_default_package.uuid),
+                'compound_uuid': str(c.uuid)
+            }), {
+                "compound-name": "Test Compound Adjusted",
+                "compound-description": "New Description",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        c = Compound.objects.get(url=compound_url)
+        self.assertEqual(c.name, "Test Compound Adjusted")
+        self.assertEqual(c.description, "New Description")
+
+        # Rest stays untouched
+        self.assertEqual(c.default_structure.smiles, "C(CCl)Cl")
+        self.assertEqual(self.user1_default_package.compounds.count(), 1)
+
+    # Scenario
+    def test_set_scenario(self):
+        s1 = Scenario.create(
+            self.user1_default_package,
+            "Test Scen",
+            "Test Desc",
+            "2025-10",
+            "soil",
+            [Temperature(interval=Interval(start=20, end=30))]
+        )
+
+        s2 = Scenario.create(
+            self.user1_default_package,
+            "Test Scen2",
+            "Test Desc2",
+            "2025-10",
+            "soil",
+            [Temperature(interval=Interval(start=10, end=20))]
+        )
+
+        response = self.client.post(
+            reverse("compounds"), {
+                "compound-name": "1,2-Dichloroethane",
+                "compound-description": "Eawag BBD compound c0001",
+                "compound-smiles": "C(CCl)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        compound_url = response.url
+
+        c = Compound.objects.get(url=compound_url)
+
+        response = self.client.post(
+            reverse("package compound detail", kwargs={
+                'package_uuid': str(c.package.uuid),
+                'compound_uuid': str(c.uuid)
+            }), {
+                "selected-scenarios": [s1.url, s2.url]
+            }
+        )
+
+        self.assertEqual(len(c.scenarios.all()), 2)
+
+        response = self.client.post(
+            reverse("package compound detail", kwargs={
+                'package_uuid': str(c.package.uuid),
+                'compound_uuid': str(c.uuid)
+            }), {
+                "selected-scenarios": [s1.url]
+            }
+        )
+
+        self.assertEqual(len(c.scenarios.all()), 1)
+        self.assertEqual(c.scenarios.first().url, s1.url)
+
+        response = self.client.post(
+            reverse("package compound detail", kwargs={
+                'package_uuid': str(c.package.uuid),
+                'compound_uuid': str(c.uuid)
+            }), {
+                # We have to set an empty string to avoid that the parameter is removed
+                "selected-scenarios": ""
+            }
+        )
+
+        self.assertEqual(len(c.scenarios.all()), 0)
+
+    #
+    def test_copy(self):
+        response = self.client.post(
+            reverse("compounds"), {
+                "compound-name": "1,2-Dichloroethane",
+                "compound-description": "Eawag BBD compound c0001",
+                "compound-smiles": "C(CCl)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        compound_url = response.url
+        c = Compound.objects.get(url=compound_url)
+
+        response = self.client.post(
+            reverse("package detail", kwargs={
+                'package_uuid': str(self.package.uuid),
+            }), {
+                "hidden": "copy",
+                "object_to_copy": c.url
+            }
+        )
+
+        self.assertEqual(response.status_code, 200)
+
+        copied_object_url = response.json()["success"]
+        copied_compound = Compound.objects.get(url=copied_object_url)
+
+        self.assertEqual(copied_compound.name, c.name)
+        self.assertEqual(copied_compound.description, c.description)
+        self.assertEqual(copied_compound.default_structure.smiles, c.default_structure.smiles)
+
+        # Copy to the same package should fail
+        response = self.client.post(
+            reverse("package detail", kwargs={
+                'package_uuid': str(c.package.uuid),
+            }), {
+                "hidden": "copy",
+                "object_to_copy": c.url
+            }
+        )
+
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response.json()['error'], f"Can't copy object {compound_url} to the same package!")
+
+    def test_references(self):
+        ext_db, _ = ExternalDatabase.objects.get_or_create(
+            name='PubChem Compound',
+            defaults={
+                'full_name': 'PubChem Compound Database',
+                'description': 'Chemical database of small organic molecules',
+                'base_url': 'https://pubchem.ncbi.nlm.nih.gov',
+                'url_pattern': 'https://pubchem.ncbi.nlm.nih.gov/compound/{id}'
+            }
+        )
+
+        ext_db2, _ = ExternalDatabase.objects.get_or_create(
+            name='PubChem Substance',
+            defaults={
+                'full_name': 'PubChem Substance Database',
+                'description': 'Database of chemical substances',
+                'base_url': 'https://pubchem.ncbi.nlm.nih.gov',
+                'url_pattern': 'https://pubchem.ncbi.nlm.nih.gov/substance/{id}'
+            }
+        )
+
+        response = self.client.post(
+            reverse("compounds"), {
+                "compound-name": "1,2-Dichloroethane",
+                "compound-description": "Eawag BBD compound c0001",
+                "compound-smiles": "C(CCl)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        compound_url = response.url
+        c = Compound.objects.get(url=compound_url)
+
+        response = self.client.post(
+            reverse("package compound detail", kwargs={
+                'package_uuid': str(c.package.uuid),
+                'compound_uuid': str(c.uuid),
+            }), {
+                'selected-database': ext_db.pk,
+                'identifier': '25154249'
+            }
+        )
+
+        self.assertEqual(c.external_identifiers.count(), 1)
+        self.assertEqual(c.external_identifiers.first().database, ext_db)
+        self.assertEqual(c.external_identifiers.first().identifier_value, '25154249')
+        self.assertEqual(c.external_identifiers.first().url, 'https://pubchem.ncbi.nlm.nih.gov/compound/25154249')
+
+        response = self.client.post(
+            reverse("package compound detail", kwargs={
+                'package_uuid': str(c.package.uuid),
+                'compound_uuid': str(c.uuid),
+            }), {
+                'selected-database': ext_db2.pk,
+                'identifier': '25154249'
+            }
+        )
+
+        self.assertEqual(c.external_identifiers.count(), 2)
+        self.assertEqual(c.external_identifiers.last().database, ext_db2)
+        self.assertEqual(c.external_identifiers.last().identifier_value, '25154249')
+        self.assertEqual(c.external_identifiers.last().url, 'https://pubchem.ncbi.nlm.nih.gov/substance/25154249')
+
+    def test_delete(self):
+        response = self.client.post(
+            reverse("compounds"), {
+                "compound-name": "1,2-Dichloroethane",
+                "compound-description": "Eawag BBD compound c0001",
+                "compound-smiles": "C(CCl)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        compound_url = response.url
+
+        c = Compound.objects.get(url=compound_url)
+
+        response = self.client.post(
+            reverse("package compound detail", kwargs={
+                'package_uuid': str(c.package.uuid),
+                'compound_uuid': str(c.uuid)
+            }), {
+                "hidden": "delete"
+            }
+        )
+
+        self.assertEqual(self.user1_default_package.compounds.count(), 0)

tests/views/test_reaction_views.py

@@ -0,0 +1,313 @@
+from django.test import TestCase
+from django.urls import reverse
+from envipy_additional_information import Temperature, Interval
+
+from epdb.logic import UserManager, PackageManager
+from epdb.models import Reaction, Scenario, ExternalIdentifier, ExternalDatabase
+
+
+class ReactionViewTest(TestCase):
+    fixtures = ["test_fixtures.jsonl.gz"]
+
+    @classmethod
+    def setUpClass(cls):
+        super(ReactionViewTest, cls).setUpClass()
+        cls.user1 = UserManager.create_user("user1", "user1@envipath.com", "SuperSafe",
+                                            set_setting=False, add_to_group=True, is_active=True)
+        cls.user1_default_package = cls.user1.default_package
+        cls.package = PackageManager.create_package(cls.user1, 'Test', 'Test Pack')
+
+    def setUp(self):
+        self.client.force_login(self.user1)
+
+    def test_create_reaction(self):
+        response = self.client.post(
+            reverse("reactions"), {
+                "reaction-name": "Eawag BBD reaction r0001",
+                "reaction-description": "Description for Eawag BBD reaction r0001",
+                "reaction-smirks": "C(CCl)Cl>>C(CO)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        reaction_url = response.url
+
+        r = Reaction.objects.get(url=reaction_url)
+
+        self.assertEqual(r.package, self.user1_default_package)
+        self.assertEqual(r.name, "Eawag BBD reaction r0001")
+        self.assertEqual(r.description, "Description for Eawag BBD reaction r0001")
+        self.assertEqual(r.smirks(), "C(CCl)Cl>>C(CO)Cl")
+        self.assertEqual(self.user1_default_package.reactions.count(), 1)
+
+        # Adding the same rule again should return the existing one, hence not increasing the number of rules
+        response = self.client.post(
+            reverse("reactions"), {
+                "reaction-name": "Eawag BBD reaction r0001",
+                "reaction-description": "Description for Eawag BBD reaction r0001",
+                "reaction-smirks": "C(CCl)Cl>>C(CO)Cl",
+            }
+        )
+
+        self.assertEqual(response.url, reaction_url)
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(self.user1_default_package.reactions.count(), 1)
+
+        # Adding the same rule in a different package should create a new rule
+        response = self.client.post(
+            reverse("package reaction list", kwargs={'package_uuid': self.package.uuid}), {
+                "reaction-name": "Eawag BBD reaction r0001",
+                "reaction-description": "Description for Eawag BBD reaction r0001",
+                "reaction-smirks": "C(CCl)Cl>>C(CO)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        self.assertNotEqual(reaction_url, response.url)
+
+        # adding another reaction should increase count
+        response = self.client.post(
+            reverse("reactions"), {
+                "reaction-name": "Eawag BBD reaction r0002",
+                "reaction-description": "Description for Eawag BBD reaction r0002",
+                "reaction-smirks": "C(CO)Cl>>C(C=O)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(self.user1_default_package.reactions.count(), 2)
+
+    # Edit
+    def test_edit_rule(self):
+        response = self.client.post(
+            reverse("reactions"), {
+                "reaction-name": "Eawag BBD reaction r0001",
+                "reaction-description": "Description for Eawag BBD reaction r0001",
+                "reaction-smirks": "C(CCl)Cl>>C(CO)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        reaction_url = response.url
+
+        r = Reaction.objects.get(url=reaction_url)
+
+        response = self.client.post(
+            reverse("package reaction detail", kwargs={
+                'package_uuid': str(self.user1_default_package.uuid),
+                'reaction_uuid': str(r.uuid)
+            }), {
+                "reaction-name": "Test Reaction Adjusted",
+                "reaction-description": "New Description",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        r = Reaction.objects.get(url=reaction_url)
+        self.assertEqual(r.name, "Test Reaction Adjusted")
+        self.assertEqual(r.description, "New Description")
+
+        # Rest stays untouched
+        self.assertEqual(r.smirks(), "C(CCl)Cl>>C(CO)Cl")
+        self.assertEqual(self.user1_default_package.reactions.count(), 1)
+
+    # Scenario
+    def test_set_scenario(self):
+        s1 = Scenario.create(
+            self.user1_default_package,
+            "Test Scen",
+            "Test Desc",
+            "2025-10",
+            "soil",
+            [Temperature(interval=Interval(start=20, end=30))]
+        )
+
+        s2 = Scenario.create(
+            self.user1_default_package,
+            "Test Scen2",
+            "Test Desc2",
+            "2025-10",
+            "soil",
+            [Temperature(interval=Interval(start=10, end=20))]
+        )
+
+        response = self.client.post(
+            reverse("reactions"), {
+                "reaction-name": "Eawag BBD reaction r0001",
+                "reaction-description": "Description for Eawag BBD reaction r0001",
+                "reaction-smirks": "C(CCl)Cl>>C(CO)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        reaction_url = response.url
+        r = Reaction.objects.get(url=reaction_url)
+
+        response = self.client.post(
+            reverse("package reaction detail", kwargs={
+                'package_uuid': str(r.package.uuid),
+                'reaction_uuid': str(r.uuid)
+            }), {
+                "selected-scenarios": [s1.url, s2.url]
+            }
+        )
+
+        self.assertEqual(len(r.scenarios.all()), 2)
+
+        response = self.client.post(
+            reverse("package reaction detail", kwargs={
+                'package_uuid': str(r.package.uuid),
+                'reaction_uuid': str(r.uuid)
+            }), {
+                "selected-scenarios": [s1.url]
+            }
+        )
+
+        self.assertEqual(len(r.scenarios.all()), 1)
+        self.assertEqual(r.scenarios.first().url, s1.url)
+
+        response = self.client.post(
+            reverse("package reaction detail", kwargs={
+                'package_uuid': str(r.package.uuid),
+                'reaction_uuid': str(r.uuid)
+            }), {
+                # We have to set an empty string to avoid that the parameter is removed
+                "selected-scenarios": ""
+            }
+        )
+
+        self.assertEqual(len(r.scenarios.all()), 0)
+
+    def test_copy(self):
+        response = self.client.post(
+            reverse("reactions"), {
+                "reaction-name": "Eawag BBD reaction r0001",
+                "reaction-description": "Description for Eawag BBD reaction r0001",
+                "reaction-smirks": "C(CCl)Cl>>C(CO)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        reaction_url = response.url
+        r = Reaction.objects.get(url=reaction_url)
+
+        response = self.client.post(
+            reverse("package detail", kwargs={
+                'package_uuid': str(self.package.uuid),
+            }), {
+                "hidden": "copy",
+                "object_to_copy": r.url
+            }
+        )
+
+        self.assertEqual(response.status_code, 200)
+
+        copied_object_url = response.json()["success"]
+        copied_reaction = Reaction.objects.get(url=copied_object_url)
+
+        self.assertEqual(copied_reaction.name, r.name)
+        self.assertEqual(copied_reaction.description, r.description)
+        self.assertEqual(copied_reaction.smirks(), r.smirks())
+
+        # Copy to the same package should fail
+        response = self.client.post(
+            reverse("package detail", kwargs={
+                'package_uuid': str(r.package.uuid),
+            }), {
+                "hidden": "copy",
+                "object_to_copy": r.url
+            }
+        )
+
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response.json()['error'], f"Can't copy object {reaction_url} to the same package!")
+
+    def test_references(self):
+        ext_db, _ = ExternalDatabase.objects.get_or_create(
+            name='KEGG Reaction',
+            defaults={
+                'full_name': 'KEGG Reaction Database',
+                'description': 'Database of biochemical reactions',
+                'base_url': 'https://www.genome.jp',
+                'url_pattern': 'https://www.genome.jp/entry/{id}'
+            }
+        )
+
+        ext_db2, _ = ExternalDatabase.objects.get_or_create(
+            name='RHEA',
+            defaults={
+                'full_name': 'RHEA Reaction Database',
+                'description': 'Comprehensive resource of biochemical reactions',
+                'base_url': 'https://www.rhea-db.org',
+                'url_pattern': 'https://www.rhea-db.org/rhea/{id}'
+            },
+        )
+
+        response = self.client.post(
+            reverse("reactions"), {
+                "reaction-name": "Eawag BBD reaction r0001",
+                "reaction-description": "Description for Eawag BBD reaction r0001",
+                "reaction-smirks": "C(CCl)Cl>>C(CO)Cl",
+            }
+        )
+
+        self.assertEqual(response.status_code, 302)
+        reaction_url = response.url
+        r = Reaction.objects.get(url=reaction_url)
+
+        response = self.client.post(
+            reverse("package reaction detail", kwargs={
+                'package_uuid': str(r.package.uuid),
+                'reaction_uuid': str(r.uuid),
+            }), {
+                'selected-database': ext_db.pk,
+                'identifier': 'C12345'
+            }
+        )
+
+        self.assertEqual(r.external_identifiers.count(), 1)
+        self.assertEqual(r.external_identifiers.first().database, ext_db)
+        self.assertEqual(r.external_identifiers.first().identifier_value, 'C12345')
+        # TODO Fixture contains old url template there the real test fails, use old value instead
+        # self.assertEqual(r.external_identifiers.first().url, 'https://www.genome.jp/entry/C12345')
+        self.assertEqual(r.external_identifiers.first().url, 'https://www.genome.jp/entry/reaction+C12345')
+
+        response = self.client.post(
+            reverse("package reaction detail", kwargs={
+                'package_uuid': str(r.package.uuid),
+                'reaction_uuid': str(r.uuid),
+            }), {
+                'selected-database': ext_db2.pk,
+                'identifier': '60116'
+            }
+        )
+
+        self.assertEqual(r.external_identifiers.count(), 2)
+        self.assertEqual(r.external_identifiers.last().database, ext_db2)
+        self.assertEqual(r.external_identifiers.last().identifier_value, '60116')
+        self.assertEqual(r.external_identifiers.last().url, 'https://www.rhea-db.org/rhea/60116')
+
+
+    def test_delete(self):
+        response = self.client.post(
+            reverse("reactions"), {
+                "reaction-name": "Eawag BBD reaction r0001",
+                "reaction-description": "Description for Eawag BBD reaction r0001",
+                "reaction-smirks": "C(CCl)Cl>>C(CO)Cl",
+            }
+        )
+        self.assertEqual(response.status_code, 302)
+
+        reaction_url = response.url
+        r = Reaction.objects.get(url=reaction_url)
+
+        response = self.client.post(
+            reverse("package reaction detail", kwargs={
+                'package_uuid': str(r.package.uuid),
+                'reaction_uuid': str(r.uuid)
+            }), {
+                "hidden": "delete"
+            }
+        )
+
+        self.assertEqual(self.user1_default_package.reactions.count(), 0)

tests/views/test_rule_views.py

@@ -184,7 +184,7 @@ class RuleViewTest(TestCase):
 
         response = self.client.post(
             reverse("package detail", kwargs={
-                'package_uuid': str(r.package.uuid),
+                'package_uuid': str(self.package.uuid),
             }), {
                 "hidden": "copy",
                 "object_to_copy": r.url
@@ -200,6 +200,20 @@ class RuleViewTest(TestCase):
         self.assertEqual(copied_rule.description, r.description)
         self.assertEqual(copied_rule.smirks, r.smirks)
 
+        # Copy to the same package should fail
+        response = self.client.post(
+            reverse("package detail", kwargs={
+                'package_uuid': str(r.package.uuid),
+            }), {
+                "hidden": "copy",
+                "object_to_copy": r.url
+            }
+        )
+
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response.json()['error'], f"Can't copy object {rule_url} to the same package!")
+
+
     def test_delete(self):
         response = self.client.post(
             reverse("rules"), {

utilities/ml.py

@@ -157,7 +157,7 @@ class Dataset:
                     for smi in prod_set:
 
                         try:
-                            smi = FormatConverter.standardize(smi)
+                            smi = FormatConverter.standardize(smi, remove_stereo=True)
                         except Exception:
                             # :shrug:
                             logger.debug(f'Standardizing SMILES failed for {smi}')
@@ -185,7 +185,7 @@ class Dataset:
                         smi = cs.smiles
 
                         try:
-                            smi = FormatConverter.standardize(smi)
+                            smi = FormatConverter.standardize(smi, remove_stereo=True)
                         except Exception as e:
                             # :shrug:
                             logger.debug(f'Standardizing SMILES failed for {smi}')