From 81571c3e282e92640b4e8a944ecef1770b2055e1 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Thu, 2 Jan 2025 12:06:19 -0600
Subject: [PATCH 01/35] Added column for TDAMM tags

---
 .../static/css/delta_url_list.css               | 13 +++++++++++++
 sde_indexing_helper/static/js/delta_url_list.js | 17 +++++++++++++++++
 .../sde_collections/delta_urls_list.html        |  4 ++++
 3 files changed, 34 insertions(+)

diff --git a/sde_indexing_helper/static/css/delta_url_list.css b/sde_indexing_helper/static/css/delta_url_list.css
index 06689207..8fed929a 100644
--- a/sde_indexing_helper/static/css/delta_url_list.css
+++ b/sde_indexing_helper/static/css/delta_url_list.css
@@ -451,3 +451,16 @@ div.dt-container div.dt-paging ul.pagination {
     max-width: 100%;
     min-width: 100%;
 }
+
+.table_filter_row_input {
+    width: 100%;
+}
+
+.tdamm-tags {
+    color: white;
+    background-color: #3F4A58;
+    padding: 2px 6px;
+    border-radius: 4px;
+    margin: 2px;
+    display: inline-block;
+}
diff --git a/sde_indexing_helper/static/js/delta_url_list.js b/sde_indexing_helper/static/js/delta_url_list.js
index e27ed72f..b6347ac2 100644
--- a/sde_indexing_helper/static/js/delta_url_list.js
+++ b/sde_indexing_helper/static/js/delta_url_list.js
@@ -257,6 +257,7 @@ function initializeDataTable() {
       getScrapedTitleColumn(),
       getGeneratedTitleColumn(),
       getDocumentTypeColumn(),
+      getTdammTagColumn(),
       getDivisionColumn(),
       { data: "id", visible: false, searchable: false },
       { data: "generated_title_id", visible: false, searchable: false },
@@ -472,6 +473,7 @@ function initializeDataTable() {
       getCuratedScrapedTitleColumn(),
       getCuratedGeneratedTitleColumn(),
       getCuratedDocumentTypeColumn(),
+      getTdammTagColumn(),
       getCuratedDivisionColumn(),
       { data: "id", visible: false, searchable: false },
       { data: "generated_title_id", visible: false, searchable: false },
@@ -787,6 +789,10 @@ function initializeDataTable() {
     title_patterns_table.columns(2).search(this.value).draw();
   });
 
+  $("#deltaTdammTagFilter").on("beforeinput", DataTable.util.debounce(function (val) {
+    delta_urls_table.column('tdamm_tag:name').search(this.value).draw();
+  }, 1000));
+
   var document_type_patterns_table = $(
     "#document_type_patterns_table"
   ).DataTable({
@@ -1304,6 +1310,17 @@ function getCuratedExcludedColumn(true_icon, false_icon) {
   };
 }
 
+function getTdammTagColumn() {
+  return {
+    data: "tdamm_tag",
+    width: "10%",
+    className: "text-center whiteText",  // Changed from class to className
+    render: function (data, type, row) {
+      return data && data.length ? data.join(", ") : "None";
+    }
+  };
+}
+
 function getDocumentTypeColumn() {
   return {
     data: "document_type",
diff --git a/sde_indexing_helper/templates/sde_collections/delta_urls_list.html b/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
index 20bfc6e5..9df45049 100644
--- a/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
+++ b/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
@@ -112,6 +112,7 @@ <h3 class="whiteText deltaTitle">
                         <th scope="col" class="text-center col-1"><div class="header-title">Scraped Title</div></th>
                         <th scope="col" class="text-center col-1"><div class="header-title">New Title</div></th>
                         <th scope="col" class="text-center col-1"><div class="header-title">Document Type</div></th>
+                        <th scope="col" class="text-center col-1"><div class="header-title">TDAMM Tags</div></th>
                         <th scope="col" class="text-center col-1"><div class="header-title">Division</div></th>
                         <th scope="col" class="text-center col-1"><div class="header-title">ID</div></th>
                         <th></th>
@@ -145,6 +146,7 @@ <h3 class="whiteText deltaTitle">
                         <option value="4">Software and Tools</option>
                         <option value="5">Missions and Instruments</option>
                         </select></td>
+                        <td><input type="text" class="table_filter_row_input textBoxStyling" id="deltaTdammTagFilter" placeholder="TDAMM Tags" /></td>
                         <td><select class="dropdown-5 select-dropdown selectStyling"><option value="">SELECT</option>
                         <option value="0">None</option>
                         <option value="1">Astrophysics</option>
@@ -174,6 +176,7 @@ <h3 class="whiteText deltaTitle">
                         <th scope="col" class="text-center col-1"><div class="header-title">Scraped Title</div></th>
                         <th scope="col" class="text-center col-1"><div class="header-title">New Title</div></th>
                         <th scope="col" class="text-center col-1"><div class="header-title">Document Type</div></th>
+                        <th scope="col" class="text-center col-1"><div class="header-title">TDAMM Tags</div></th>
                         <th scope="col" class="text-center col-1"><div class="header-title">Division</div></th>
                         <th scope="col" class="text-center col-1"><div class="header-title">ID</div></th>
                         <th></th>
@@ -203,6 +206,7 @@ <h3 class="whiteText deltaTitle">
                         <option value="4">Software and Tools</option>
                         <option value="5">Missions and Instruments</option>
                         </select></td>
+                        <td><input type="text" class="table_filter_row_input textBoxStyling" id="deltaTdammTagFilter" placeholder="TDAMM Tags" /></td>
                         <td><select class="dropdown-5 select-dropdown selectStyling"><option value="">SELECT</option>
                         <option value="0">None</option>
                         <option value="1">Astrophysics</option>

From 3f1eb6b68a333ed5429491a8919d6d331eb04281 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Fri, 31 Jan 2025 15:15:29 -0600
Subject: [PATCH 02/35] Added get_tag_source method in delta_url model

---
 sde_collections/models/delta_url.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/sde_collections/models/delta_url.py b/sde_collections/models/delta_url.py
index 88df502b..312ab414 100644
--- a/sde_collections/models/delta_url.py
+++ b/sde_collections/models/delta_url.py
@@ -134,6 +134,14 @@ def splits(self) -> list[tuple[str, str]]:
                 parts.append((part_string, part))
         return parts
 
+    def get_tag_source(self):
+        """Returns the source of the TDAMM tags: 'manual', 'ml', or 'Not Set'"""
+        if self.tdamm_tag_manual and self.tdamm_tag_manual != []:
+            return "manual"
+        elif self.tdamm_tag_ml and self.tdamm_tag_ml != []:
+            return "ml"
+        return "Not Set"
+
     @property
     def path(self) -> str:
         parsed = urlparse(self.url)

From ab90a0e97a06e2158302907ef97e28b3f2b86070 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Fri, 31 Jan 2025 15:17:13 -0600
Subject: [PATCH 03/35] Added get_tag_source to delta and curated serializers

---
 sde_collections/serializers.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/sde_collections/serializers.py b/sde_collections/serializers.py
index 1a4ac099..ced52f44 100644
--- a/sde_collections/serializers.py
+++ b/sde_collections/serializers.py
@@ -73,11 +73,15 @@ class DeltaURLSerializer(serializers.ModelSerializer):
     match_pattern_type = serializers.SerializerMethodField(read_only=True)
     delta_urls_count = serializers.SerializerMethodField(read_only=True)
     tdamm_tag = serializers.SerializerMethodField()
+    tag_source = serializers.SerializerMethodField()
 
     def get_tdamm_tag(self, obj):
         tags = obj.tdamm_tag
         return tags if tags is not None else []
 
+    def get_tag_source(self, obj):
+        return obj.get_tag_source()
+
     def get_delta_urls_count(self, obj):
         titlepattern = obj.deltatitlepatterns.last()
         return titlepattern.delta_urls.count() if titlepattern else 0
@@ -108,6 +112,7 @@ class Meta:
             "division_display",
             "visited",
             "tdamm_tag",
+            "tag_source",
         )
 
 
@@ -120,11 +125,15 @@ class CuratedURLSerializer(serializers.ModelSerializer):
     match_pattern_type = serializers.SerializerMethodField(read_only=True)
     curated_urls_count = serializers.SerializerMethodField(read_only=True)
     tdamm_tag = serializers.SerializerMethodField()
+    tag_source = serializers.SerializerMethodField()
 
     def get_tdamm_tag(self, obj):
         tags = obj.tdamm_tag
         return tags if tags is not None else []
 
+    def get_tag_source(self, obj):
+        return obj.get_tag_source()
+
     def get_curated_urls_count(self, obj):
         titlepattern = obj.deltatitlepatterns.last()
         return titlepattern.curated_urls.count() if titlepattern else 0
@@ -154,6 +163,7 @@ class Meta:
             "division_display",
             "visited",
             "tdamm_tag",
+            "tag_source",
         )
 
 

From 58db367e8288438b4e8a66f584eadaa76c808627 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Fri, 31 Jan 2025 15:18:06 -0600
Subject: [PATCH 04/35] Added CSS background-color for manual tdamm tag

---
 sde_indexing_helper/static/css/delta_url_list.css | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/sde_indexing_helper/static/css/delta_url_list.css b/sde_indexing_helper/static/css/delta_url_list.css
index 8fed929a..e29ebd92 100644
--- a/sde_indexing_helper/static/css/delta_url_list.css
+++ b/sde_indexing_helper/static/css/delta_url_list.css
@@ -464,3 +464,7 @@ div.dt-container div.dt-paging ul.pagination {
     margin: 2px;
     display: inline-block;
 }
+
+.tdamm-tag-manual {
+    background-color: #28a745; /* Green background */
+}

From 520fdaf2d9e31524119457f323900fe793b9b759 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Mon, 3 Feb 2025 13:26:05 -0600
Subject: [PATCH 05/35] TDAMM tags is dynamically visible based on presence of
 the tag

---
 sde_collections/models/collection.py           | 18 ++++++++++++++++++
 sde_collections/views.py                       |  1 +
 .../static/js/delta_url_list.js                |  3 ++-
 .../sde_collections/delta_urls_list.html       |  1 +
 4 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/sde_collections/models/collection.py b/sde_collections/models/collection.py
index 0f1162e1..82811309 100644
--- a/sde_collections/models/collection.py
+++ b/sde_collections/models/collection.py
@@ -256,6 +256,24 @@ def add_to_public_query(self):
         scraper_content = scraper_editor.update_config_xml()
         gh.create_or_update_file(query_path, scraper_content)
 
+    def has_tdamm_tags(self):
+        """Check if any URLs in this collection have TDAMM tags."""
+        # Check DeltaUrls
+        has_delta_tags = (
+            self.delta_urls.filter(models.Q(tdamm_tag_manual__isnull=False) | models.Q(tdamm_tag_ml__isnull=False))
+            .exclude(models.Q(tdamm_tag_manual=[]) & models.Q(tdamm_tag_ml=[]))
+            .exists()
+        )
+
+        # Check CuratedUrls
+        has_curated_tags = (
+            self.curated_urls.filter(models.Q(tdamm_tag_manual__isnull=False) | models.Q(tdamm_tag_ml__isnull=False))
+            .exclude(models.Q(tdamm_tag_manual=[]) & models.Q(tdamm_tag_ml=[]))
+            .exists()
+        )
+
+        return has_delta_tags or has_curated_tags
+
     @property
     def _scraper_config_path(self) -> str:
         return f"sources/scrapers/{self.config_folder}/default.xml"
diff --git a/sde_collections/views.py b/sde_collections/views.py
index 8b3f1727..90638ec6 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -230,6 +230,7 @@ def get_context_data(self, **kwargs):
         context["workflow_status_choices"] = WorkflowStatusChoices
         context["reindexing_status_choices"] = ReindexingStatusChoices
         context["is_multi_division"] = self.collection.is_multi_division
+        context["has_tdamm_tags"] = self.collection.has_tdamm_tags()
 
         return context
 
diff --git a/sde_indexing_helper/static/js/delta_url_list.js b/sde_indexing_helper/static/js/delta_url_list.js
index b6347ac2..018cb7ce 100644
--- a/sde_indexing_helper/static/js/delta_url_list.js
+++ b/sde_indexing_helper/static/js/delta_url_list.js
@@ -1314,7 +1314,8 @@ function getTdammTagColumn() {
   return {
     data: "tdamm_tag",
     width: "10%",
-    className: "text-center whiteText",  // Changed from class to className
+    visible: (has_tdamm_tags === 'true'),
+    className: "text-center whiteText",
     render: function (data, type, row) {
       return data && data.length ? data.join(", ") : "None";
     }
diff --git a/sde_indexing_helper/templates/sde_collections/delta_urls_list.html b/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
index 9df45049..dd057260 100644
--- a/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
+++ b/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
@@ -690,6 +690,7 @@ <h5 class="modal-title">Are you sure?</h5>
     {{ block.super }}
     <script>var collection_id = "{{ collection.id }}";</script>
     <script>var is_multi_division = "{{ is_multi_division|lower }}";</script>
+    <script>var has_tdamm_tags = "{{ has_tdamm_tags|lower }}";</script>
     <script src="//cdnjs.cloudflare.com/ajax/libs/pdfmake/0.2.7/pdfmake.min.js"></script>
     <script src="//cdnjs.cloudflare.com/ajax/libs/pdfmake/0.2.7/vfs_fonts.js"></script>
     <script src="//cdn.datatables.net/v/bs4/jszip-3.10.1/dt-2.0.5/af-2.7.0/b-3.0.2/b-colvis-3.0.2/b-html5-3.0.2/b-print-3.0.2/cr-2.0.1/fc-5.0.0/fh-4.0.1/kt-2.12.0/r-3.0.2/rg-1.5.0/rr-1.5.0/sc-2.4.1/sp-2.3.1/sl-2.0.1/datatables.min.js"></script>

From 17551787462a77cec30def1e6ccbd5485bc0d741 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Tue, 4 Feb 2025 10:22:49 -0600
Subject: [PATCH 06/35] Deletion logic in place and functional

---
 sde_collections/models/delta_url.py           | 22 +++++-
 sde_collections/serializers.py                |  5 ++
 sde_collections/views.py                      | 40 +++++++++++
 .../static/css/delta_url_list.css             | 33 +++++++++
 .../static/js/delta_url_list.js               | 68 ++++++++++++++++++-
 5 files changed, 163 insertions(+), 5 deletions(-)

diff --git a/sde_collections/models/delta_url.py b/sde_collections/models/delta_url.py
index 312ab414..684f0988 100644
--- a/sde_collections/models/delta_url.py
+++ b/sde_collections/models/delta_url.py
@@ -136,10 +136,28 @@ def splits(self) -> list[tuple[str, str]]:
 
     def get_tag_source(self):
         """Returns the source of the TDAMM tags: 'manual', 'ml', or 'Not Set'"""
-        if self.tdamm_tag_manual and self.tdamm_tag_manual != []:
+        # print("Checking tag sources for URL:", self.url)
+        # print("Manual tags:", self.tdamm_tag_manual)
+        # print("ML tags:", self.tdamm_tag_ml)
+
+        # if self.tdamm_tag_manual and self.tdamm_tag_manual != []:
+        #     print("Using manual tags")
+        #     return "manual"
+        # elif self.tdamm_tag_ml and self.tdamm_tag_ml != []:
+        #     print("Using ML tags")
+        #     return "ml"
+
+        # print("No tags found, using 'Not Set'")
+        # return "Not Set"
+        # Convert None to empty list for comparison
+        manual_tags = self.tdamm_tag_manual or []
+        ml_tags = self.tdamm_tag_ml or []
+
+        if manual_tags and manual_tags != []:
             return "manual"
-        elif self.tdamm_tag_ml and self.tdamm_tag_ml != []:
+        elif ml_tags and ml_tags != []:
             return "ml"
+
         return "Not Set"
 
     @property
diff --git a/sde_collections/serializers.py b/sde_collections/serializers.py
index ced52f44..3ea315c9 100644
--- a/sde_collections/serializers.py
+++ b/sde_collections/serializers.py
@@ -77,9 +77,14 @@ class DeltaURLSerializer(serializers.ModelSerializer):
 
     def get_tdamm_tag(self, obj):
         tags = obj.tdamm_tag
+        # print(f"TDAMM tags for {obj.url}:")
+        # print(f"- Raw tags: {tags}")
+        # print(f"- Manual tags: {obj.tdamm_tag_manual}")
+        # print(f"- ML tags: {obj.tdamm_tag_ml}")
         return tags if tags is not None else []
 
     def get_tag_source(self, obj):
+        # print(f"get_tag_source called for {obj.url}, returning: {obj.get_tag_source()}")
         return obj.get_tag_source()
 
     def get_delta_urls_count(self, obj):
diff --git a/sde_collections/views.py b/sde_collections/views.py
index 90638ec6..250cc898 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -12,6 +12,7 @@
 from django.views.generic.edit import DeleteView
 from django.views.generic.list import ListView
 from rest_framework import generics, status, viewsets
+from rest_framework.decorators import action
 from rest_framework.exceptions import ValidationError
 from rest_framework.generics import ListAPIView
 from rest_framework.response import Response
@@ -292,6 +293,45 @@ def update_division(self, request, pk=None):
             return Response(status=status.HTTP_200_OK)
         return Response(status=status.HTTP_400_BAD_REQUEST, data={"error": "Division is required."})
 
+    @action(detail=True, methods=["post"], url_path="remove_tag")
+    def remove_tag(self, request, pk=None):
+        delta_url = self.get_object()
+        tag_to_remove = request.data.get("tag")
+        source = request.data.get("source")
+
+        if not tag_to_remove:
+            return Response({"error": "Tag to remove not specified"}, status=status.HTTP_400_BAD_REQUEST)
+
+        try:
+            # print(f"Current state - ML tags: {delta_url.tdamm_tag_ml}, Manual tags: {delta_url.tdamm_tag_manual}")
+            # print(f"Source: {source}, Tag to remove: {tag_to_remove}")
+
+            if source == "ml":
+                # Get current ML tags
+                ml_tags = delta_url.tdamm_tag_ml
+                if ml_tags:
+                    # Create a new list from ML tags, excluding the one to remove
+                    new_manual_tags = [tag for tag in ml_tags if tag != tag_to_remove]
+                    # Set the new list to manual tags
+                    delta_url.tdamm_tag_manual = new_manual_tags
+                    # print(f"New manual tags after copy and remove: {delta_url.tdamm_tag_manual}")
+            else:
+                if delta_url.tdamm_tag_manual:
+                    manual_tags = delta_url.tdamm_tag_manual
+                    if tag_to_remove in manual_tags:
+                        manual_tags.remove(tag_to_remove)
+                        delta_url.tdamm_tag_manual = manual_tags
+                        # print(f"New manual tags after remove: {delta_url.tdamm_tag_manual}")
+
+            delta_url.save()
+            # print(f"Final state - ML tags: {delta_url.tdamm_tag_ml}, Manual tags: {delta_url.tdamm_tag_manual}")
+
+            return Response({"status": "success"})
+
+        except Exception as e:
+            print(f"Error occurred: {str(e)}")
+            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
 
 class CuratedURLViewSet(CollectionFilterMixin, viewsets.ModelViewSet):
     queryset = CuratedUrl.objects.all()
diff --git a/sde_indexing_helper/static/css/delta_url_list.css b/sde_indexing_helper/static/css/delta_url_list.css
index e29ebd92..907475c8 100644
--- a/sde_indexing_helper/static/css/delta_url_list.css
+++ b/sde_indexing_helper/static/css/delta_url_list.css
@@ -468,3 +468,36 @@ div.dt-container div.dt-paging ul.pagination {
 .tdamm-tag-manual {
     background-color: #28a745; /* Green background */
 }
+
+.tdamm-tags-container {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 4px;
+    justify-content: center;
+}
+
+.tdamm-tag {
+    display: inline-flex;
+    align-items: center;
+    background: #304050;
+    border-radius: 16px;
+    padding: 2px 8px;
+    margin: 2px;
+    color: white;
+    font-size: 0.9em;
+}
+
+.delete-tag {
+    background: none;
+    border: none;
+    color: #ff9999;
+    margin-left: 4px;
+    padding: 0 4px;
+    cursor: pointer;
+    font-size: 1.2em;
+    line-height: 1;
+}
+
+.delete-tag:hover {
+    color: #ff0000;
+}
diff --git a/sde_indexing_helper/static/js/delta_url_list.js b/sde_indexing_helper/static/js/delta_url_list.js
index 018cb7ce..9ad45cb1 100644
--- a/sde_indexing_helper/static/js/delta_url_list.js
+++ b/sde_indexing_helper/static/js/delta_url_list.js
@@ -264,6 +264,7 @@ function initializeDataTable() {
       { data: "match_pattern_type", visible: false, searchable: false },
       { data: "delta_urls_count", visible: false, searchable: false },
       { data: "excluded", visible: false, searchable: false },
+      { data: "tag_source", visible: false, searchable: false },
       {
         data: null,
         render: function (data, type, row) {
@@ -480,6 +481,7 @@ function initializeDataTable() {
       { data: "match_pattern_type", visible: false, searchable: false },
       { data: "curated_urls_count", visible: false, searchable: false },
       { data: "excluded", visible: false, searchable: false },
+      { data: "tag_source", visible: false, searchable: false },
       {
         data: null,
         render: function (data, type, row) {
@@ -1042,6 +1044,7 @@ function setupClickHandlers() {
   handleDivisionSelect();
   handleExcludeIndividualUrlClick();
   handleNewTitleChange();
+  handleTagDeletion();
 
   handleUrlLinkClick();
   handleTabsClick();
@@ -1315,9 +1318,28 @@ function getTdammTagColumn() {
     data: "tdamm_tag",
     width: "10%",
     visible: (has_tdamm_tags === 'true'),
-    className: "text-center whiteText",
-    render: function (data, type, row) {
-      return data && data.length ? data.join(", ") : "None";
+    className: "text-center",
+    render: function(data, type, row) {
+      if (!data || !data.length) return "None";
+
+      // console.log('Row data for tags:', {
+      //   data,
+      //   tagSource: row.tag_source,
+      //   fullRow: row
+      // });
+
+      const tagSource = row.tag_source;
+      const tags = data.map(tag => `
+        <div class="tdamm-tag">
+          <span class="tag-text">${tag}</span>
+          <button class="delete-tag"
+            data-url-id="${row.id}"
+            data-tag="${tag}"
+            data-source="${tagSource}">×</button>
+        </div>
+      `).join('');
+
+      return `<div class="tdamm-tags-container">${tags}</div>`;
     }
   };
 }
@@ -2261,3 +2283,43 @@ function handleReindexingStatusSelect() {
     });
   });
 }
+
+function handleTagDeletion() {
+  $("body").on("click", ".delete-tag", function(e) {
+    e.preventDefault();
+    e.stopPropagation();
+
+    const $button = $(this);
+    const urlId = $button.data("url-id");
+    const tagToDelete = $button.data("tag");
+    const source = $button.data("source");
+
+    // console.log('Tag deletion data:', {
+    //   urlId,
+    //   tagToDelete,
+    //   source,
+    //   buttonData: $button.data()
+    // });
+
+    // Confirm deletion
+    if (confirm(`Are you sure you want to remove the tag "${tagToDelete}"?`)) {
+      $.ajax({
+        url: `/api/delta-urls/${urlId}/remove_tag/`,
+        type: "POST",
+        data: {
+          tag: tagToDelete,
+          source: source,
+          csrfmiddlewaretoken: csrftoken
+        },
+        success: function(response) {
+          $("#delta_urls_table").DataTable().ajax.reload(null, false);
+          toastr.success("Tag removed successfully");
+          window.location.reload();
+        },
+        error: function(xhr, status, error) {
+          toastr.error("Error removing tag: " + error);
+        }
+      });
+    }
+  });
+}

From 04793d7bd3738d524dc7815157fe087d0622c8ae Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Tue, 4 Feb 2025 13:14:19 -0600
Subject: [PATCH 07/35] Passing tdamm choice fields to the front end through
 views

---
 sde_collections/views.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/sde_collections/views.py b/sde_collections/views.py
index 250cc898..80b57f18 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -1,3 +1,4 @@
+import json
 import re
 
 from django.contrib import messages
@@ -26,6 +27,7 @@
     Divisions,
     DocumentTypes,
     ReindexingStatusChoices,
+    TDAMMTags,
     WorkflowStatusChoices,
 )
 from .models.delta_patterns import (
@@ -233,6 +235,13 @@ def get_context_data(self, **kwargs):
         context["is_multi_division"] = self.collection.is_multi_division
         context["has_tdamm_tags"] = self.collection.has_tdamm_tags()
 
+        tdamm_choices = [
+            {"code": choice[0], "label": choice[1], "display": f"{choice[0]}: {choice[1]}"}
+            for choice in TDAMMTags.choices
+            # if choice[0] != 'Not TDAMM'
+        ]
+        context["tdamm_choices"] = json.dumps(tdamm_choices)
+
         return context
 
 

From 1b38642743a715121f0b57b4d65e7bfc9ee750a6 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Wed, 5 Feb 2025 15:43:49 -0600
Subject: [PATCH 08/35] Add TDAMM tag functionality functional in Delta URLs

---
 sde_collections/views.py                      |  36 +++++-
 .../static/css/delta_url_list.css             | 112 ++++++++++++++++
 .../static/js/delta_url_list.js               | 120 +++++++++++++++++-
 .../sde_collections/delta_urls_list.html      |  10 ++
 4 files changed, 272 insertions(+), 6 deletions(-)

diff --git a/sde_collections/views.py b/sde_collections/views.py
index 80b57f18..47553aa5 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -1,4 +1,3 @@
-import json
 import re
 
 from django.contrib import messages
@@ -240,7 +239,9 @@ def get_context_data(self, **kwargs):
             for choice in TDAMMTags.choices
             # if choice[0] != 'Not TDAMM'
         ]
-        context["tdamm_choices"] = json.dumps(tdamm_choices)
+        context["tdamm_choices"] = tdamm_choices
+
+        # print("TDAMM choices:", context['tdamm_choices'])
 
         return context
 
@@ -341,6 +342,37 @@ def remove_tag(self, request, pk=None):
             print(f"Error occurred: {str(e)}")
             return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 
+    @action(detail=True, methods=["post"], url_path="add_tag")
+    def add_tag(self, request, pk=None):
+        delta_url = self.get_object()
+        tag_to_add = request.data.get("tag")
+        source = request.data.get("source")
+
+        if not tag_to_add:
+            return Response({"error": "Tag to add not specified"}, status=status.HTTP_400_BAD_REQUEST)
+
+        try:
+            # Get current tags
+            if source == "ml":
+                # If source is ML, copy ML tags to manual and add new tag
+                current_tags = delta_url.tdamm_tag_ml or []
+                new_tags = list(current_tags)  # Create a copy
+                if tag_to_add not in new_tags:
+                    new_tags.append(tag_to_add)
+                delta_url.tdamm_tag_manual = new_tags
+            else:
+                # For manual source, just add to existing manual tags
+                current_tags = delta_url.tdamm_tag_manual or []
+                if tag_to_add not in current_tags:
+                    current_tags.append(tag_to_add)
+                    delta_url.tdamm_tag_manual = current_tags
+
+            delta_url.save()
+            return Response({"status": "success"})
+
+        except Exception as e:
+            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
 
 class CuratedURLViewSet(CollectionFilterMixin, viewsets.ModelViewSet):
     queryset = CuratedUrl.objects.all()
diff --git a/sde_indexing_helper/static/css/delta_url_list.css b/sde_indexing_helper/static/css/delta_url_list.css
index 907475c8..13d28304 100644
--- a/sde_indexing_helper/static/css/delta_url_list.css
+++ b/sde_indexing_helper/static/css/delta_url_list.css
@@ -501,3 +501,115 @@ div.dt-container div.dt-paging ul.pagination {
 .delete-tag:hover {
     color: #ff0000;
 }
+
+.tdamm-dropdown {
+    position: absolute;
+    min-width: 300px;
+    background: #15232E;
+    /* border: 1px solid #A7BACD; */
+    border: 2px solid red !important;
+    border-radius: 4px;
+    box-shadow: 0 2px 10px rgba(0,0,0,0.3);
+    z-index: 9999;
+}
+
+.tdamm-dropdown .dropdown-menu {
+    position: static !important;
+    display: block !important;
+    min-width: 100%;
+    max-height: 400px;
+    overflow-y: auto;
+    padding: 10px;
+    background: none;
+    border: none;
+    margin: 0;
+}
+
+.tdamm-tag-menu {
+    position: absolute;
+    width: 300px;
+}
+
+.tdamm-search {
+    margin: 10px;
+    padding: 5px 10px;
+    width: calc(100% - 20px);
+    background: #3F4A58;
+    border: 1px solid #A7BACD;
+    color: white;
+    border-radius: 4px;
+}
+
+.tdamm-options {
+    /* max-height: 300px; */
+    /* overflow-y: auto; */
+    min-height: 50px;
+    background: rgba(255,255,255,0.1);
+}
+
+/* .tdamm-option {
+    padding: 8px 12px;
+    cursor: pointer;
+    color: white;
+    border-radius: 4px;
+    margin-bottom: 4px;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    background: rgba(255,255,255,0.1);
+} */
+
+.tdamm-option:hover {
+    background: #0066CA;
+}
+
+.add-tdamm-tag {
+    margin-left: 8px;
+    padding: 2px 8px;
+    font-size: 0.9em;
+}
+
+/* .tdamm-dropdown-container {
+    position: absolute;
+    background: #15232E;
+    border: 1px solid #A7BACD;
+    border-radius: 4px;
+    padding: 5px;
+    z-index: 9999;
+} */
+
+.tdamm-dropdown-container {
+    position: absolute;
+    background: #15232E;
+    border: 1px solid #A7BACD;
+    border-radius: 4px;
+    box-shadow: 0 2px 10px rgba(0,0,0,0.3);
+    min-width: 300px;
+}
+
+.tdamm-options-list {
+    max-height: 400px;
+    overflow-y: auto;
+}
+
+.tdamm-option {
+    padding: 8px 12px;
+    cursor: pointer;
+    color: white;
+    transition: background-color 0.2s;
+}
+
+/* .tdamm-select {
+    width: 300px;
+    background: #3F4A58;
+    color: white;
+    border: 1px solid #A7BACD;
+    border-radius: 4px;
+    padding: 5px;
+}
+
+.tdamm-select option {
+    background: #15232E;
+    color: white;
+    padding: 5px;
+} */
diff --git a/sde_indexing_helper/static/js/delta_url_list.js b/sde_indexing_helper/static/js/delta_url_list.js
index 9ad45cb1..ab647dfc 100644
--- a/sde_indexing_helper/static/js/delta_url_list.js
+++ b/sde_indexing_helper/static/js/delta_url_list.js
@@ -1045,6 +1045,7 @@ function setupClickHandlers() {
   handleExcludeIndividualUrlClick();
   handleNewTitleChange();
   handleTagDeletion();
+  handleTagAddition();
 
   handleUrlLinkClick();
   handleTabsClick();
@@ -1320,8 +1321,15 @@ function getTdammTagColumn() {
     visible: (has_tdamm_tags === 'true'),
     className: "text-center",
     render: function(data, type, row) {
-      if (!data || !data.length) return "None";
-
+      if (!data || !data.length) {
+        return `<div class="tdamm-tags-container">
+            <button class="btn btn-sm btn-outline-primary add-tdamm-tag"
+                data-url-id="${row.id}"
+                data-source="manual">
+                Add Tag
+            </button>
+        </div>`;
+      }
       // console.log('Row data for tags:', {
       //   data,
       //   tagSource: row.tag_source,
@@ -1339,7 +1347,14 @@ function getTdammTagColumn() {
         </div>
       `).join('');
 
-      return `<div class="tdamm-tags-container">${tags}</div>`;
+      return `<div class="tdamm-tags-container">
+          ${tags}
+          <button class="btn btn-sm btn-outline-primary add-tdamm-tag"
+              data-url-id="${row.id}"
+              data-source="${tagSource}">
+              Add Tag
+          </button>
+      </div>`;
     }
   };
 }
@@ -2314,7 +2329,7 @@ function handleTagDeletion() {
         success: function(response) {
           $("#delta_urls_table").DataTable().ajax.reload(null, false);
           toastr.success("Tag removed successfully");
-          window.location.reload();
+          // window.location.reload();
         },
         error: function(xhr, status, error) {
           toastr.error("Error removing tag: " + error);
@@ -2323,3 +2338,100 @@ function handleTagDeletion() {
     }
   });
 }
+
+function handleTagAddition() {
+  let activeDropdown = null;
+
+  function createDropdownContent() {
+    return tdamm_choices.map(choice =>
+        `<div class="tdamm-option" data-value="${choice.code}">
+            ${choice.display}
+        </div>`
+    ).join('');
+}
+
+  function hideDropdown(dropdown) {
+      if (dropdown) {
+          dropdown.remove();
+          activeDropdown = null;
+      }
+  }
+
+  $('body').on('click', '.add-tdamm-tag', function(e) {
+      // console.log("Add tag button clicked");
+      e.preventDefault();
+      e.stopPropagation();
+
+      // Hide any existing dropdown
+      if (activeDropdown) {
+          hideDropdown(activeDropdown);
+      }
+
+      const $button = $(this);
+      const urlId = $button.data('url-id');
+      const source = $button.data('source');
+
+      // console.log("Button data:", { urlId, source });
+
+      // Clone dropdown template
+      const dropdown = $('#tdammDropdownTemplate').children().first().clone();
+      // console.log("Cloned template:", dropdown.html());
+
+      const optionsList = dropdown.find('.tdamm-options-list');
+      optionsList.html(createDropdownContent());
+
+      // Position dropdown
+      dropdown.css({
+          position: 'absolute',
+          top: $button.offset().top + $button.outerHeight() + 5,
+          left: $button.offset().left,
+          display: 'block',
+          width: '300px',
+          // zIndex: 1000
+          zIndex: 9999
+          // background: 'red',
+          // border: '2px solid yellow'
+      });
+
+      optionsList.on('click', '.tdamm-option', function() {
+          const selectedTag = $(this).data('value');
+          $.ajax({
+              url: `/api/delta-urls/${urlId}/add_tag/`,
+              type: 'POST',
+              data: {
+                  tag: selectedTag,
+                  source: source,
+                  csrfmiddlewaretoken: csrftoken
+              },
+              success: function(response) {
+                  $("#delta_urls_table").DataTable().ajax.reload(null, false);
+                  toastr.success("Tag added successfully");
+                  hideDropdown(dropdown[0]);
+              },
+              error: function(xhr, status, error) {
+                  toastr.error("Error adding tag: " + error);
+              }
+          });
+      });
+
+      if ($button.offset().left + 300 > $(window).width()) {
+          dropdown.css({
+              left: 'auto',
+              right: $(window).width() - ($button.offset().left + $button.outerWidth())
+          });
+      }
+
+      // Add to document and store reference
+      $('body').append(dropdown);
+      // console.log("Dropdown appended to body:", dropdown);
+      activeDropdown = dropdown[0];
+  });
+
+  // Close dropdown when clicking outside
+  $(document).on('click', function(e) {
+      if (activeDropdown && !$(e.target).closest('.tdamm-dropdown').length) {
+          hideDropdown(activeDropdown);
+      }
+  });
+}
+//
diff --git a/sde_indexing_helper/templates/sde_collections/delta_urls_list.html b/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
index dd057260..8724876a 100644
--- a/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
+++ b/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
@@ -684,6 +684,12 @@ <h5 class="modal-title">Are you sure?</h5>
 </div>
 </div>
 
+<div id="tdammDropdownTemplate" style="display: none;">
+    <div class="tdamm-dropdown-container">
+        <div class="tdamm-options-list"></div>
+    </div>
+</div>
+
 {% endblock content %}
 
 {% block javascripts %}
@@ -691,6 +697,10 @@ <h5 class="modal-title">Are you sure?</h5>
     <script>var collection_id = "{{ collection.id }}";</script>
     <script>var is_multi_division = "{{ is_multi_division|lower }}";</script>
     <script>var has_tdamm_tags = "{{ has_tdamm_tags|lower }}";</script>
+    {{ tdamm_choices|json_script:"tdamm-choices-data" }}
+    <script>
+        var tdamm_choices = JSON.parse(document.getElementById('tdamm-choices-data').textContent);
+    </script>
     <script src="//cdnjs.cloudflare.com/ajax/libs/pdfmake/0.2.7/pdfmake.min.js"></script>
     <script src="//cdnjs.cloudflare.com/ajax/libs/pdfmake/0.2.7/vfs_fonts.js"></script>
     <script src="//cdn.datatables.net/v/bs4/jszip-3.10.1/dt-2.0.5/af-2.7.0/b-3.0.2/b-colvis-3.0.2/b-html5-3.0.2/b-print-3.0.2/cr-2.0.1/fc-5.0.0/fh-4.0.1/kt-2.12.0/r-3.0.2/rg-1.5.0/rr-1.5.0/sc-2.4.1/sp-2.3.1/sl-2.0.1/datatables.min.js"></script>

From fe795a038f8fd17c8909f3fe087323bac7204fde Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Thu, 6 Feb 2025 09:04:54 -0600
Subject: [PATCH 09/35] Removed unused CSS

---
 .../static/css/delta_url_list.css              | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/sde_indexing_helper/static/css/delta_url_list.css b/sde_indexing_helper/static/css/delta_url_list.css
index 13d28304..d537d307 100644
--- a/sde_indexing_helper/static/css/delta_url_list.css
+++ b/sde_indexing_helper/static/css/delta_url_list.css
@@ -456,18 +456,18 @@ div.dt-container div.dt-paging ul.pagination {
     width: 100%;
 }
 
-.tdamm-tags {
+/* .tdamm-tags {
     color: white;
     background-color: #3F4A58;
     padding: 2px 6px;
     border-radius: 4px;
     margin: 2px;
     display: inline-block;
-}
+} */
 
-.tdamm-tag-manual {
-    background-color: #28a745; /* Green background */
-}
+/* .tdamm-tag-manual {
+    background-color: #28a745;
+} */
 
 .tdamm-tags-container {
     display: flex;
@@ -525,12 +525,12 @@ div.dt-container div.dt-paging ul.pagination {
     margin: 0;
 }
 
-.tdamm-tag-menu {
+/* .tdamm-tag-menu {
     position: absolute;
     width: 300px;
-}
+} */
 
-.tdamm-search {
+/* .tdamm-search {
     margin: 10px;
     padding: 5px 10px;
     width: calc(100% - 20px);
@@ -538,7 +538,7 @@ div.dt-container div.dt-paging ul.pagination {
     border: 1px solid #A7BACD;
     color: white;
     border-radius: 4px;
-}
+} */
 
 .tdamm-options {
     /* max-height: 300px; */

From d63db8e5e3580d7936a86e427ee4128a712446f1 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Thu, 6 Feb 2025 09:51:33 -0600
Subject: [PATCH 10/35] Updated source based background CSS

---
 .../static/css/delta_url_list.css             | 81 +++----------------
 1 file changed, 13 insertions(+), 68 deletions(-)

diff --git a/sde_indexing_helper/static/css/delta_url_list.css b/sde_indexing_helper/static/css/delta_url_list.css
index d537d307..e56c161a 100644
--- a/sde_indexing_helper/static/css/delta_url_list.css
+++ b/sde_indexing_helper/static/css/delta_url_list.css
@@ -456,19 +456,6 @@ div.dt-container div.dt-paging ul.pagination {
     width: 100%;
 }
 
-/* .tdamm-tags {
-    color: white;
-    background-color: #3F4A58;
-    padding: 2px 6px;
-    border-radius: 4px;
-    margin: 2px;
-    display: inline-block;
-} */
-
-/* .tdamm-tag-manual {
-    background-color: #28a745;
-} */
-
 .tdamm-tags-container {
     display: flex;
     flex-wrap: wrap;
@@ -479,7 +466,7 @@ div.dt-container div.dt-paging ul.pagination {
 .tdamm-tag {
     display: inline-flex;
     align-items: center;
-    background: #304050;
+    /* background: #304050; */
     border-radius: 16px;
     padding: 2px 8px;
     margin: 2px;
@@ -487,6 +474,18 @@ div.dt-container div.dt-paging ul.pagination {
     font-size: 0.9em;
 }
 
+.tdamm-tags-container[data-source="manual"] .tdamm-tag {
+    background: #28a745;
+}
+
+.tdamm-tags-container[data-source="ml"] .tdamm-tag {
+    background: #0066CA;
+}
+
+.tdamm-tags-container[data-source="Not Set"] .tdamm-tag {
+    background: #304050;
+}
+
 .delete-tag {
     background: none;
     border: none;
@@ -506,7 +505,6 @@ div.dt-container div.dt-paging ul.pagination {
     position: absolute;
     min-width: 300px;
     background: #15232E;
-    /* border: 1px solid #A7BACD; */
     border: 2px solid red !important;
     border-radius: 4px;
     box-shadow: 0 2px 10px rgba(0,0,0,0.3);
@@ -525,40 +523,11 @@ div.dt-container div.dt-paging ul.pagination {
     margin: 0;
 }
 
-/* .tdamm-tag-menu {
-    position: absolute;
-    width: 300px;
-} */
-
-/* .tdamm-search {
-    margin: 10px;
-    padding: 5px 10px;
-    width: calc(100% - 20px);
-    background: #3F4A58;
-    border: 1px solid #A7BACD;
-    color: white;
-    border-radius: 4px;
-} */
-
 .tdamm-options {
-    /* max-height: 300px; */
-    /* overflow-y: auto; */
     min-height: 50px;
     background: rgba(255,255,255,0.1);
 }
 
-/* .tdamm-option {
-    padding: 8px 12px;
-    cursor: pointer;
-    color: white;
-    border-radius: 4px;
-    margin-bottom: 4px;
-    white-space: nowrap;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    background: rgba(255,255,255,0.1);
-} */
-
 .tdamm-option:hover {
     background: #0066CA;
 }
@@ -569,15 +538,6 @@ div.dt-container div.dt-paging ul.pagination {
     font-size: 0.9em;
 }
 
-/* .tdamm-dropdown-container {
-    position: absolute;
-    background: #15232E;
-    border: 1px solid #A7BACD;
-    border-radius: 4px;
-    padding: 5px;
-    z-index: 9999;
-} */
-
 .tdamm-dropdown-container {
     position: absolute;
     background: #15232E;
@@ -598,18 +558,3 @@ div.dt-container div.dt-paging ul.pagination {
     color: white;
     transition: background-color 0.2s;
 }
-
-/* .tdamm-select {
-    width: 300px;
-    background: #3F4A58;
-    color: white;
-    border: 1px solid #A7BACD;
-    border-radius: 4px;
-    padding: 5px;
-}
-
-.tdamm-select option {
-    background: #15232E;
-    color: white;
-    padding: 5px;
-} */

From a92223c5582ac83282b21320a822c7692cd3aadd Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Thu, 6 Feb 2025 09:52:30 -0600
Subject: [PATCH 11/35] Dynamic tag background based on source

---
 sde_indexing_helper/static/css/delta_url_list.css | 6 +++---
 sde_indexing_helper/static/js/delta_url_list.js   | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/sde_indexing_helper/static/css/delta_url_list.css b/sde_indexing_helper/static/css/delta_url_list.css
index e56c161a..d0bed497 100644
--- a/sde_indexing_helper/static/css/delta_url_list.css
+++ b/sde_indexing_helper/static/css/delta_url_list.css
@@ -466,7 +466,7 @@ div.dt-container div.dt-paging ul.pagination {
 .tdamm-tag {
     display: inline-flex;
     align-items: center;
-    /* background: #304050; */
+    background: #304050;
     border-radius: 16px;
     padding: 2px 8px;
     margin: 2px;
@@ -475,11 +475,11 @@ div.dt-container div.dt-paging ul.pagination {
 }
 
 .tdamm-tags-container[data-source="manual"] .tdamm-tag {
-    background: #28a745;
+    background: #31a728;
 }
 
 .tdamm-tags-container[data-source="ml"] .tdamm-tag {
-    background: #0066CA;
+    background: #00a2ca;
 }
 
 .tdamm-tags-container[data-source="Not Set"] .tdamm-tag {
diff --git a/sde_indexing_helper/static/js/delta_url_list.js b/sde_indexing_helper/static/js/delta_url_list.js
index ab647dfc..36f40894 100644
--- a/sde_indexing_helper/static/js/delta_url_list.js
+++ b/sde_indexing_helper/static/js/delta_url_list.js
@@ -1347,7 +1347,7 @@ function getTdammTagColumn() {
         </div>
       `).join('');
 
-      return `<div class="tdamm-tags-container">
+      return `<div class="tdamm-tags-container" data-source="${tagSource}">
           ${tags}
           <button class="btn btn-sm btn-outline-primary add-tdamm-tag"
               data-url-id="${row.id}"

From 4097b178a405e358221c91679072ac389effd7d9 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Thu, 6 Feb 2025 10:03:21 -0600
Subject: [PATCH 12/35] Added hover activated tooltips

---
 .../static/css/delta_url_list.css             | 25 +++++++++++++++
 .../static/js/delta_url_list.js               | 31 +++++++++++++------
 2 files changed, 47 insertions(+), 9 deletions(-)

diff --git a/sde_indexing_helper/static/css/delta_url_list.css b/sde_indexing_helper/static/css/delta_url_list.css
index d0bed497..b681a162 100644
--- a/sde_indexing_helper/static/css/delta_url_list.css
+++ b/sde_indexing_helper/static/css/delta_url_list.css
@@ -472,6 +472,31 @@ div.dt-container div.dt-paging ul.pagination {
     margin: 2px;
     color: white;
     font-size: 0.9em;
+    position: relative;
+    cursor: help;
+}
+
+.tdamm-tag::after {
+    content: attr(data-full-name);
+    position: absolute;
+    bottom: 100%;
+    left: 50%;
+    transform: translateX(-50%);
+    padding: 6px 12px;
+    background: #15232E;
+    border: 1px solid #A7BACD;
+    border-radius: 4px;
+    font-size: 0.85em;
+    white-space: nowrap;
+    opacity: 0;
+    visibility: hidden;
+    transition: opacity 0.2s, visibility 0.2s;
+    z-index: 1000;
+}
+
+.tdamm-tag:hover::after {
+    opacity: 1;
+    visibility: visible;
 }
 
 .tdamm-tags-container[data-source="manual"] .tdamm-tag {
diff --git a/sde_indexing_helper/static/js/delta_url_list.js b/sde_indexing_helper/static/js/delta_url_list.js
index 36f40894..ff3299d4 100644
--- a/sde_indexing_helper/static/js/delta_url_list.js
+++ b/sde_indexing_helper/static/js/delta_url_list.js
@@ -1337,15 +1337,28 @@ function getTdammTagColumn() {
       // });
 
       const tagSource = row.tag_source;
-      const tags = data.map(tag => `
-        <div class="tdamm-tag">
-          <span class="tag-text">${tag}</span>
-          <button class="delete-tag"
-            data-url-id="${row.id}"
-            data-tag="${tag}"
-            data-source="${tagSource}">×</button>
-        </div>
-      `).join('');
+      // const tags = data.map(tag => `
+      //   <div class="tdamm-tag">
+      //     <span class="tag-text">${tag}</span>
+      //     <button class="delete-tag"
+      //       data-url-id="${row.id}"
+      //       data-tag="${tag}"
+      //       data-source="${tagSource}">×</button>
+      //   </div>
+      // `).join('');
+
+      const tags = data.map(tag => {
+        const fullName = tdamm_choices.find(choice => choice.code === tag)?.label || tag;
+        return `
+          <div class="tdamm-tag" data-full-name="${fullName}">
+            <span class="tag-text">${tag}</span>
+            <button class="delete-tag"
+              data-url-id="${row.id}"
+              data-tag="${tag}"
+              data-source="${tagSource}">×</button>
+          </div>
+        `;
+      }).join('');
 
       return `<div class="tdamm-tags-container" data-source="${tagSource}">
           ${tags}

From cd9dbb2f80783b6ae8e7e3561f7b105a665434b7 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Thu, 6 Feb 2025 10:26:27 -0600
Subject: [PATCH 13/35] Standardized the modal to confirm delete tags

---
 .../static/js/delta_url_list.js               | 48 ++++++++++++++++++-
 .../sde_collections/delta_urls_list.html      | 24 ++++++++++
 2 files changed, 70 insertions(+), 2 deletions(-)

diff --git a/sde_indexing_helper/static/js/delta_url_list.js b/sde_indexing_helper/static/js/delta_url_list.js
index ff3299d4..dfcead13 100644
--- a/sde_indexing_helper/static/js/delta_url_list.js
+++ b/sde_indexing_helper/static/js/delta_url_list.js
@@ -2313,6 +2313,8 @@ function handleReindexingStatusSelect() {
 }
 
 function handleTagDeletion() {
+  let currentTagData = null;
+
   $("body").on("click", ".delete-tag", function(e) {
     e.preventDefault();
     e.stopPropagation();
@@ -2322,6 +2324,8 @@ function handleTagDeletion() {
     const tagToDelete = $button.data("tag");
     const source = $button.data("source");
 
+    currentTagData = { urlId, tagToDelete, source };
+
     // console.log('Tag deletion data:', {
     //   urlId,
     //   tagToDelete,
@@ -2330,7 +2334,45 @@ function handleTagDeletion() {
     // });
 
     // Confirm deletion
-    if (confirm(`Are you sure you want to remove the tag "${tagToDelete}"?`)) {
+    $("#deleteTagModal").modal();
+    $(".delete-tag-caption").text(`Are you sure you want to remove the tag "${tagToDelete}"?`);
+  });
+
+  $("#deleteTagModalForm").on("click", "button", function(event) {
+    event.preventDefault();
+    const buttonId = $(this).attr("id");
+
+    if (buttonId === "dontDeleteTag") {
+      $("#deleteTagModal").modal("hide");
+      return;
+    }
+
+    if (buttonId === "deleteTag" && currentTagData) {
+      const { urlId, tagToDelete, source } = currentTagData;
+
+      $.ajax({
+        url: `/api/delta-urls/${urlId}/remove_tag/`,
+        type: "POST",
+        data: {
+          tag: tagToDelete,
+          source: source,
+          csrfmiddlewaretoken: csrftoken
+        },
+        success: function(response) {
+          $("#delta_urls_table").DataTable().ajax.reload(null, false);
+          toastr.success("Tag removed successfully");
+        },
+        error: function(xhr, status, error) {
+          toastr.error("Error removing tag: " + error);
+        }
+      });
+    }
+  });
+
+  $("#deleteTagModal").on("keydown", function(event) {
+    if (event.key === "Enter" && currentTagData) {
+      const { urlId, tagToDelete, source } = currentTagData;
+
       $.ajax({
         url: `/api/delta-urls/${urlId}/remove_tag/`,
         type: "POST",
@@ -2340,14 +2382,16 @@ function handleTagDeletion() {
           csrfmiddlewaretoken: csrftoken
         },
         success: function(response) {
+          $("#deleteTagModal").modal("hide");
           $("#delta_urls_table").DataTable().ajax.reload(null, false);
           toastr.success("Tag removed successfully");
-          // window.location.reload();
         },
         error: function(xhr, status, error) {
           toastr.error("Error removing tag: " + error);
         }
       });
+    } else if (event.key === "Escape") {
+      $("#deleteTagModal").modal("hide");
     }
   });
 }
diff --git a/sde_indexing_helper/templates/sde_collections/delta_urls_list.html b/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
index 8724876a..df8bb0d3 100644
--- a/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
+++ b/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
@@ -684,6 +684,30 @@ <h5 class="modal-title">Are you sure?</h5>
 </div>
 </div>
 
+<div class="modal" id="deleteTagModal" tabindex="-1" aria-labelledby="deleteTagModal" aria-hidden="true">
+    <div class="modal-dialog">
+      <div class="modal-content">
+        <div class="modalHeader">
+          <button type="button" class="close modal-close" data-dismiss="modal" aria-label="Close" id="closeTagModal">
+            <span aria-hidden="true">&times;</span>
+          </button>
+        </div>
+        <div class="modal-body" id="tag-modal-body">
+          <h5 class="modal-title">Are you sure?</h5>
+          <p class="delete-tag-caption" id="tag-caption"></p>
+        </div>
+        <div class="modal-footer">
+          <form id="deleteTagModalForm">
+            <div class="button-wrapper">
+              <button type="submit" class="btn btn-secondary modal-button-1" id="dontDeleteTag">No</button>
+              <button type="submit" class="btn btn-primary modal-button-2" data-dismiss="modal" id="deleteTag">Yes</button>
+            </div>
+          </form>
+        </div>
+      </div>
+    </div>
+</div>
+
 <div id="tdammDropdownTemplate" style="display: none;">
     <div class="tdamm-dropdown-container">
         <div class="tdamm-options-list"></div>

From 6dd39ed4ed672a2ccece31cea997d9a89050cca4 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Thu, 6 Feb 2025 14:53:52 -0600
Subject: [PATCH 14/35] Moved the add_tag and remove_tag to delta_url

---
 sde_collections/models/delta_url.py |  28 ++++++
 sde_collections/views.py            | 130 +++++++++++++++++-----------
 2 files changed, 108 insertions(+), 50 deletions(-)

diff --git a/sde_collections/models/delta_url.py b/sde_collections/models/delta_url.py
index 684f0988..5a002e78 100644
--- a/sde_collections/models/delta_url.py
+++ b/sde_collections/models/delta_url.py
@@ -196,6 +196,34 @@ class Meta:
         verbose_name_plural = "Delta Urls"
         ordering = ["url"]
 
+    def add_tag(self, tag: str, source: str) -> None:
+        if source == "ml":
+            current_tags = self.tdamm_tag_ml or []
+            new_tags = list(current_tags)
+            if tag not in new_tags:
+                new_tags.append(tag)
+            self.tdamm_tag_manual = new_tags
+        else:
+            current_tags = self.tdamm_tag_manual or []
+            if tag not in current_tags:
+                current_tags.append(tag)
+                self.tdamm_tag_manual = current_tags
+        self.save()
+
+    def remove_tag(self, tag: str, source: str) -> None:
+        if source == "ml":
+            ml_tags = self.tdamm_tag_ml
+            if ml_tags:
+                new_manual_tags = [t for t in ml_tags if t != tag]
+                self.tdamm_tag_manual = new_manual_tags
+        else:
+            if self.tdamm_tag_manual:
+                manual_tags = self.tdamm_tag_manual
+                if tag in manual_tags:
+                    manual_tags.remove(tag)
+                    self.tdamm_tag_manual = manual_tags
+        self.save()
+
 
 class CuratedUrl(BaseUrl):
     """Urls that are curated and ready for production"""
diff --git a/sde_collections/views.py b/sde_collections/views.py
index 47553aa5..f05b028a 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -303,75 +303,105 @@ def update_division(self, request, pk=None):
             return Response(status=status.HTTP_200_OK)
         return Response(status=status.HTTP_400_BAD_REQUEST, data={"error": "Division is required."})
 
+    # @action(detail=True, methods=["post"], url_path="remove_tag")
+    # def remove_tag(self, request, pk=None):
+    #     delta_url = self.get_object()
+    #     tag_to_remove = request.data.get("tag")
+    #     source = request.data.get("source")
+
+    #     if not tag_to_remove:
+    #         return Response({"error": "Tag to remove not specified"}, status=status.HTTP_400_BAD_REQUEST)
+
+    #     try:
+    #         # print(f"Current state - ML tags: {delta_url.tdamm_tag_ml}, Manual tags: {delta_url.tdamm_tag_manual}")
+    #         # print(f"Source: {source}, Tag to remove: {tag_to_remove}")
+
+    #         if source == "ml":
+    #             # Get current ML tags
+    #             ml_tags = delta_url.tdamm_tag_ml
+    #             if ml_tags:
+    #                 # Create a new list from ML tags, excluding the one to remove
+    #                 new_manual_tags = [tag for tag in ml_tags if tag != tag_to_remove]
+    #                 # Set the new list to manual tags
+    #                 delta_url.tdamm_tag_manual = new_manual_tags
+    #                 # print(f"New manual tags after copy and remove: {delta_url.tdamm_tag_manual}")
+    #         else:
+    #             if delta_url.tdamm_tag_manual:
+    #                 manual_tags = delta_url.tdamm_tag_manual
+    #                 if tag_to_remove in manual_tags:
+    #                     manual_tags.remove(tag_to_remove)
+    #                     delta_url.tdamm_tag_manual = manual_tags
+    #                     # print(f"New manual tags after remove: {delta_url.tdamm_tag_manual}")
+
+    #         delta_url.save()
+    #         # print(f"Final state - ML tags: {delta_url.tdamm_tag_ml}, Manual tags: {delta_url.tdamm_tag_manual}")
+
+    #         return Response({"status": "success"})
+
+    #     except Exception as e:
+    #         print(f"Error occurred: {str(e)}")
+    #         return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
     @action(detail=True, methods=["post"], url_path="remove_tag")
     def remove_tag(self, request, pk=None):
         delta_url = self.get_object()
-        tag_to_remove = request.data.get("tag")
+        tag = request.data.get("tag")
         source = request.data.get("source")
 
-        if not tag_to_remove:
-            return Response({"error": "Tag to remove not specified"}, status=status.HTTP_400_BAD_REQUEST)
+        if not tag:
+            return Response({"error": "Tag not specified"}, status=400)
 
         try:
-            # print(f"Current state - ML tags: {delta_url.tdamm_tag_ml}, Manual tags: {delta_url.tdamm_tag_manual}")
-            # print(f"Source: {source}, Tag to remove: {tag_to_remove}")
-
-            if source == "ml":
-                # Get current ML tags
-                ml_tags = delta_url.tdamm_tag_ml
-                if ml_tags:
-                    # Create a new list from ML tags, excluding the one to remove
-                    new_manual_tags = [tag for tag in ml_tags if tag != tag_to_remove]
-                    # Set the new list to manual tags
-                    delta_url.tdamm_tag_manual = new_manual_tags
-                    # print(f"New manual tags after copy and remove: {delta_url.tdamm_tag_manual}")
-            else:
-                if delta_url.tdamm_tag_manual:
-                    manual_tags = delta_url.tdamm_tag_manual
-                    if tag_to_remove in manual_tags:
-                        manual_tags.remove(tag_to_remove)
-                        delta_url.tdamm_tag_manual = manual_tags
-                        # print(f"New manual tags after remove: {delta_url.tdamm_tag_manual}")
-
-            delta_url.save()
-            # print(f"Final state - ML tags: {delta_url.tdamm_tag_ml}, Manual tags: {delta_url.tdamm_tag_manual}")
-
+            delta_url.remove_tag(tag, source)
             return Response({"status": "success"})
-
         except Exception as e:
-            print(f"Error occurred: {str(e)}")
-            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+            return Response({"error": str(e)}, status=500)
+
+    # @action(detail=True, methods=["post"], url_path="add_tag")
+    # def add_tag(self, request, pk=None):
+    #     delta_url = self.get_object()
+    #     tag_to_add = request.data.get("tag")
+    #     source = request.data.get("source")
+
+    #     if not tag_to_add:
+    #         return Response({"error": "Tag to add not specified"}, status=status.HTTP_400_BAD_REQUEST)
+
+    #     try:
+    #         # Get current tags
+    #         if source == "ml":
+    #             # If source is ML, copy ML tags to manual and add new tag
+    #             current_tags = delta_url.tdamm_tag_ml or []
+    #             new_tags = list(current_tags)  # Create a copy
+    #             if tag_to_add not in new_tags:
+    #                 new_tags.append(tag_to_add)
+    #             delta_url.tdamm_tag_manual = new_tags
+    #         else:
+    #             # For manual source, just add to existing manual tags
+    #             current_tags = delta_url.tdamm_tag_manual or []
+    #             if tag_to_add not in current_tags:
+    #                 current_tags.append(tag_to_add)
+    #                 delta_url.tdamm_tag_manual = current_tags
+
+    #         delta_url.save()
+    #         return Response({"status": "success"})
+
+    #     except Exception as e:
+    #         return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 
     @action(detail=True, methods=["post"], url_path="add_tag")
     def add_tag(self, request, pk=None):
         delta_url = self.get_object()
-        tag_to_add = request.data.get("tag")
+        tag = request.data.get("tag")
         source = request.data.get("source")
 
-        if not tag_to_add:
-            return Response({"error": "Tag to add not specified"}, status=status.HTTP_400_BAD_REQUEST)
+        if not tag:
+            return Response({"error": "Tag not specified"}, status=400)
 
         try:
-            # Get current tags
-            if source == "ml":
-                # If source is ML, copy ML tags to manual and add new tag
-                current_tags = delta_url.tdamm_tag_ml or []
-                new_tags = list(current_tags)  # Create a copy
-                if tag_to_add not in new_tags:
-                    new_tags.append(tag_to_add)
-                delta_url.tdamm_tag_manual = new_tags
-            else:
-                # For manual source, just add to existing manual tags
-                current_tags = delta_url.tdamm_tag_manual or []
-                if tag_to_add not in current_tags:
-                    current_tags.append(tag_to_add)
-                    delta_url.tdamm_tag_manual = current_tags
-
-            delta_url.save()
+            delta_url.add_tag(tag, source)
             return Response({"status": "success"})
-
         except Exception as e:
-            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+            return Response({"error": str(e)}, status=500)
 
 
 class CuratedURLViewSet(CollectionFilterMixin, viewsets.ModelViewSet):

From 555c97c4c97d1d34bee124dd5fc6d57b937f44cb Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Fri, 7 Feb 2025 10:15:19 -0600
Subject: [PATCH 15/35] Can add or remove tags from Curated URLs tab

---
 sde_collections/models/delta_url.py           | 125 ++++++++++++++----
 sde_collections/views.py                      |  30 +++++
 .../static/js/delta_url_list.js               | 104 ++++++---------
 3 files changed, 170 insertions(+), 89 deletions(-)

diff --git a/sde_collections/models/delta_url.py b/sde_collections/models/delta_url.py
index 5a002e78..034792c1 100644
--- a/sde_collections/models/delta_url.py
+++ b/sde_collections/models/delta_url.py
@@ -160,6 +160,58 @@ def get_tag_source(self):
 
         return "Not Set"
 
+    def _fields_match(self, other):
+        """Compare fields between two URL objects."""
+        fields_to_compare = [
+            "scraped_title",
+            "scraped_text",
+            "generated_title",
+            "visited",
+            "document_type",
+            "division",
+            "tdamm_tag_manual",
+            "tdamm_tag_ml",
+        ]
+        return all(getattr(self, field) == getattr(other, field) for field in fields_to_compare)
+
+    def add_tag(self, tag: str, source: str) -> None:
+        """Add a tag and handle cleanup if needed."""
+        if source == "ml":
+            current_tags = self.tdamm_tag_ml or []
+            new_tags = list(current_tags)
+            if tag not in new_tags:
+                new_tags.append(tag)
+            self.tdamm_tag_manual = new_tags
+        else:
+            current_tags = self.tdamm_tag_manual or []
+            if tag not in current_tags:
+                current_tags.append(tag)
+                self.tdamm_tag_manual = current_tags
+
+        self.save()
+        self._cleanup_if_needed()
+
+    def remove_tag(self, tag: str, source: str) -> None:
+        """Remove a tag and handle cleanup if needed."""
+        if source == "ml":
+            ml_tags = self.tdamm_tag_ml
+            if ml_tags:
+                new_manual_tags = [t for t in ml_tags if t != tag]
+                self.tdamm_tag_manual = new_manual_tags
+        else:
+            if self.tdamm_tag_manual:
+                manual_tags = self.tdamm_tag_manual
+                if tag in manual_tags:
+                    manual_tags.remove(tag)
+                    self.tdamm_tag_manual = manual_tags
+
+        self.save()
+        self._cleanup_if_needed()
+
+    def _cleanup_if_needed(self):
+        """Override in DeltaUrl to implement cleanup logic."""
+        pass
+
     @property
     def path(self) -> str:
         parsed = urlparse(self.url)
@@ -191,47 +243,62 @@ class DeltaUrl(BaseUrl):
     objects = DeltaUrlManager()
     to_delete = models.BooleanField(default=False)
 
+    def _cleanup_if_needed(self):
+        """Delete if identical to curated URL and not marked for deletion."""
+        try:
+            curated_url = CuratedUrl.objects.get(collection=self.collection, url=self.url)
+            if not self.to_delete and self._fields_match(curated_url):
+                self.delete()
+        except CuratedUrl.DoesNotExist:
+            pass
+
     class Meta:
         verbose_name = "Delta Urls"
         verbose_name_plural = "Delta Urls"
         ordering = ["url"]
 
-    def add_tag(self, tag: str, source: str) -> None:
-        if source == "ml":
-            current_tags = self.tdamm_tag_ml or []
-            new_tags = list(current_tags)
-            if tag not in new_tags:
-                new_tags.append(tag)
-            self.tdamm_tag_manual = new_tags
-        else:
-            current_tags = self.tdamm_tag_manual or []
-            if tag not in current_tags:
-                current_tags.append(tag)
-                self.tdamm_tag_manual = current_tags
-        self.save()
-
-    def remove_tag(self, tag: str, source: str) -> None:
-        if source == "ml":
-            ml_tags = self.tdamm_tag_ml
-            if ml_tags:
-                new_manual_tags = [t for t in ml_tags if t != tag]
-                self.tdamm_tag_manual = new_manual_tags
-        else:
-            if self.tdamm_tag_manual:
-                manual_tags = self.tdamm_tag_manual
-                if tag in manual_tags:
-                    manual_tags.remove(tag)
-                    self.tdamm_tag_manual = manual_tags
-        self.save()
-
 
 class CuratedUrl(BaseUrl):
     """Urls that are curated and ready for production"""
 
     collection = models.ForeignKey("Collection", on_delete=models.CASCADE, related_name="curated_urls")
-
     objects = CuratedUrlManager()
 
+    def _is_delta_identical(self, delta_url):
+        """Check if DeltaUrl has identical metadata to CuratedUrl."""
+        fields_to_compare = [
+            "scraped_title",
+            "scraped_text",
+            "generated_title",
+            "visited",
+            "document_type",
+            "division",
+            "tdamm_tag_manual",
+            "tdamm_tag_ml",
+        ]
+        return all(getattr(delta_url, field) == getattr(self, field) for field in fields_to_compare)
+
+    def _create_or_update_delta(self):
+        """Create or update delta URL using collection's delta migration logic."""
+        self.collection.create_or_update_delta_url(self, to_delete=False)
+        return self.collection.delta_urls.get(url=self.url)
+
+    def add_tag(self, tag: str, source: str) -> None:
+        """Create/update DeltaUrl and add tag to it."""
+        delta_url = self._create_or_update_delta()
+        if delta_url:
+            delta_url.add_tag(tag, source)
+            if not delta_url.to_delete and delta_url.tdamm_tag == self.tdamm_tag:
+                delta_url.delete()
+
+    def remove_tag(self, tag: str, source: str) -> None:
+        """Create/update DeltaUrl and remove tag from it."""
+        delta_url = self._create_or_update_delta()
+        if delta_url:
+            delta_url.remove_tag(tag, source)
+            if not delta_url.to_delete and delta_url.tdamm_tag == self.tdamm_tag:
+                delta_url.delete()
+
     class Meta:
         verbose_name = "Curated Urls"
         verbose_name_plural = "Curated Urls"
diff --git a/sde_collections/views.py b/sde_collections/views.py
index f05b028a..6394097b 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -433,6 +433,36 @@ def update_division(self, request, pk=None):
             return Response(status=status.HTTP_200_OK)
         return Response(status=status.HTTP_400_BAD_REQUEST, data={"error": "Division is required."})
 
+    @action(detail=True, methods=["post"], url_path="add_tag")
+    def add_tag(self, request, pk=None):
+        curated_url = self.get_object()
+        tag = request.data.get("tag")
+        source = request.data.get("source")
+
+        if not tag:
+            return Response({"error": "Tag not specified"}, status=400)
+
+        try:
+            curated_url.add_tag(tag, source)
+            return Response({"status": "success"})
+        except Exception as e:
+            return Response({"error": str(e)}, status=500)
+
+    @action(detail=True, methods=["post"], url_path="remove_tag")
+    def remove_tag(self, request, pk=None):
+        curated_url = self.get_object()
+        tag = request.data.get("tag")
+        source = request.data.get("source")
+
+        if not tag:
+            return Response({"error": "Tag not specified"}, status=400)
+
+        try:
+            curated_url.remove_tag(tag, source)
+            return Response({"status": "success"})
+        except Exception as e:
+            return Response({"error": str(e)}, status=500)
+
 
 class DeltaURLBulkCreateView(generics.ListCreateAPIView):
     queryset = DeltaUrl.objects.all()
diff --git a/sde_indexing_helper/static/js/delta_url_list.js b/sde_indexing_helper/static/js/delta_url_list.js
index dfcead13..e840ae93 100644
--- a/sde_indexing_helper/static/js/delta_url_list.js
+++ b/sde_indexing_helper/static/js/delta_url_list.js
@@ -2312,17 +2312,22 @@ function handleReindexingStatusSelect() {
   });
 }
 
+function getApiEndpoint($element) {
+  return $element.closest('#curated_urls_table').length > 0 ? 'curated-urls' : 'delta-urls';
+}
+
 function handleTagDeletion() {
   let currentTagData = null;
+  let $clickedButton = null;
 
   $("body").on("click", ".delete-tag", function(e) {
     e.preventDefault();
     e.stopPropagation();
 
-    const $button = $(this);
-    const urlId = $button.data("url-id");
-    const tagToDelete = $button.data("tag");
-    const source = $button.data("source");
+    $clickedButton = $(this);
+    const urlId = $clickedButton.data("url-id");
+    const tagToDelete = $clickedButton.data("tag");
+    const source = $clickedButton.data("source");
 
     currentTagData = { urlId, tagToDelete, source };
 
@@ -2349,32 +2354,10 @@ function handleTagDeletion() {
 
     if (buttonId === "deleteTag" && currentTagData) {
       const { urlId, tagToDelete, source } = currentTagData;
+      const apiEndpoint = getApiEndpoint($clickedButton);
 
       $.ajax({
-        url: `/api/delta-urls/${urlId}/remove_tag/`,
-        type: "POST",
-        data: {
-          tag: tagToDelete,
-          source: source,
-          csrfmiddlewaretoken: csrftoken
-        },
-        success: function(response) {
-          $("#delta_urls_table").DataTable().ajax.reload(null, false);
-          toastr.success("Tag removed successfully");
-        },
-        error: function(xhr, status, error) {
-          toastr.error("Error removing tag: " + error);
-        }
-      });
-    }
-  });
-
-  $("#deleteTagModal").on("keydown", function(event) {
-    if (event.key === "Enter" && currentTagData) {
-      const { urlId, tagToDelete, source } = currentTagData;
-
-      $.ajax({
-        url: `/api/delta-urls/${urlId}/remove_tag/`,
+        url: `/api/${apiEndpoint}/${urlId}/remove_tag/`,
         type: "POST",
         data: {
           tag: tagToDelete,
@@ -2384,14 +2367,13 @@ function handleTagDeletion() {
         success: function(response) {
           $("#deleteTagModal").modal("hide");
           $("#delta_urls_table").DataTable().ajax.reload(null, false);
+          $("#curated_urls_table").DataTable().ajax.reload(null, false);
           toastr.success("Tag removed successfully");
         },
         error: function(xhr, status, error) {
           toastr.error("Error removing tag: " + error);
         }
       });
-    } else if (event.key === "Escape") {
-      $("#deleteTagModal").modal("hide");
     }
   });
 }
@@ -2401,17 +2383,17 @@ function handleTagAddition() {
 
   function createDropdownContent() {
     return tdamm_choices.map(choice =>
-        `<div class="tdamm-option" data-value="${choice.code}">
-            ${choice.display}
-        </div>`
+      `<div class="tdamm-option" data-value="${choice.code}">
+        ${choice.display}
+      </div>`
     ).join('');
-}
+  }
 
   function hideDropdown(dropdown) {
-      if (dropdown) {
-          dropdown.remove();
-          activeDropdown = null;
-      }
+    if (dropdown) {
+      dropdown.remove();
+      activeDropdown = null;
+    }
   }
 
   $('body').on('click', '.add-tdamm-tag', function(e) {
@@ -2419,9 +2401,8 @@ function handleTagAddition() {
       e.preventDefault();
       e.stopPropagation();
 
-      // Hide any existing dropdown
       if (activeDropdown) {
-          hideDropdown(activeDropdown);
+        hideDropdown(activeDropdown);
       }
 
       const $button = $(this);
@@ -2452,31 +2433,34 @@ function handleTagAddition() {
 
       optionsList.on('click', '.tdamm-option', function() {
           const selectedTag = $(this).data('value');
+          const apiEndpoint = getApiEndpoint($button);
+
           $.ajax({
-              url: `/api/delta-urls/${urlId}/add_tag/`,
-              type: 'POST',
-              data: {
-                  tag: selectedTag,
-                  source: source,
-                  csrfmiddlewaretoken: csrftoken
-              },
-              success: function(response) {
-                  $("#delta_urls_table").DataTable().ajax.reload(null, false);
-                  toastr.success("Tag added successfully");
-                  hideDropdown(dropdown[0]);
-              },
-              error: function(xhr, status, error) {
-                  toastr.error("Error adding tag: " + error);
-              }
+            url: `/api/${apiEndpoint}/${urlId}/add_tag/`,
+            type: 'POST',
+            data: {
+              tag: selectedTag,
+              source: source,
+              csrfmiddlewaretoken: csrftoken
+            },
+            success: function(response) {
+              $("#delta_urls_table").DataTable().ajax.reload(null, false);
+              $("#curated_urls_table").DataTable().ajax.reload(null, false);
+              toastr.success("Tag added successfully");
+              hideDropdown(dropdown[0]);
+            },
+            error: function(xhr, status, error) {
+              toastr.error("Error adding tag: " + error);
+            }
           });
-      });
+        });
 
-      if ($button.offset().left + 300 > $(window).width()) {
+        if ($button.offset().left + 300 > $(window).width()) {
           dropdown.css({
-              left: 'auto',
-              right: $(window).width() - ($button.offset().left + $button.outerWidth())
+            left: 'auto',
+            right: $(window).width() - ($button.offset().left + $button.outerWidth())
           });
-      }
+        }
 
       // Add to document and store reference
       $('body').append(dropdown);

From c2de692432cc480e1dd7d7543714e646c28726f8 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Fri, 7 Feb 2025 11:09:00 -0600
Subject: [PATCH 16/35] Added tests

---
 sde_collections/tests/test_tdamm_tags.py | 84 ++++++++++++++++++++++++
 1 file changed, 84 insertions(+)

diff --git a/sde_collections/tests/test_tdamm_tags.py b/sde_collections/tests/test_tdamm_tags.py
index f520b63b..f91460c4 100644
--- a/sde_collections/tests/test_tdamm_tags.py
+++ b/sde_collections/tests/test_tdamm_tags.py
@@ -195,3 +195,87 @@ def test_tdamm_tags_updated_in_promotion(self, collection):
         curated_url = CuratedUrl.objects.get(url="https://example.com")
         assert curated_url.tdamm_tag == ["MMA_M_G"]
         assert curated_url.tdamm_tag_manual == ["MMA_M_G"]
+
+
+@pytest.mark.django_db
+class TestTDAMMTagUtilityMethods:
+    """Test additional TDAMM tag utility methods"""
+
+    def test_get_tag_source_method(self):
+        """Test the get_tag_source method for different tag scenarios"""
+        url = DeltaUrlFactory()
+
+        # Scenario 1: No tags
+        assert url.get_tag_source() == "Not Set"
+
+        # Scenario 2: Only ML tags
+        url.tdamm_tag_ml = ["MMA_M_EM"]
+        assert url.get_tag_source() == "ml"
+
+        # Scenario 3: Only manual tags
+        url.tdamm_tag_ml = None
+        url.tdamm_tag = ["MMA_M_G"]
+        assert url.get_tag_source() == "manual"
+
+        # Scenario 4: Both ML and manual tags (manual should take precedence)
+        url.tdamm_tag_ml = ["MMA_M_EM"]
+        assert url.get_tag_source() == "manual"
+
+    def test_add_tag_method(self):
+        """Test the add_tag method for different sources"""
+        url = DeltaUrlFactory()
+
+        # Prepare initial ml tags
+        url.tdamm_tag_ml = ["MMA_O_BH"]
+
+        # Add manual tag since the source was ml
+        url.add_tag("MMA_M_G", "ml")
+        assert url.tdamm_tag_manual == ["MMA_O_BH", "MMA_M_G"]
+
+        # Add manual tag
+        url.add_tag("MMA_M_EM", "manual")
+        assert url.tdamm_tag_manual == ["MMA_O_BH", "MMA_M_G", "MMA_M_EM"]
+        assert url.tdamm_tag_ml == ["MMA_O_BH"]
+
+        # # Prevent duplicate tags
+        url.add_tag("MMA_M_EM", "manual")
+        assert url.tdamm_tag_manual == ["MMA_O_BH", "MMA_M_G", "MMA_M_EM"]
+
+    def test_remove_tag_method(self):
+        """Test the remove_tag method for different sources"""
+        url = DeltaUrlFactory()
+
+        # Prepare initial tags
+        url.tdamm_tag_ml = ["MMA_M_EM", "MMA_O_N"]
+
+        # Confirm no manual tags
+        assert True if url.tdamm_tag_manual is None else False
+
+        # Remove tag if source was ml
+        url.remove_tag("MMA_M_EM", "ml")
+        assert url.tdamm_tag_ml == ["MMA_M_EM", "MMA_O_N"]
+        assert url.tdamm_tag_manual == ["MMA_O_N"]
+
+        # Remove tag if source was manual
+        url.remove_tag("MMA_O_N", "manual")
+        assert url.tdamm_tag_manual == []
+
+        # Default to ML tags if manual tags are empty
+        assert url.tdamm_tag == ["MMA_M_EM", "MMA_O_N"]
+        assert url.tdamm_tag_ml == ["MMA_M_EM", "MMA_O_N"]
+
+    def test_tdamm_tag_collection_method(self):
+        """Test the collection method for checking TDAMM tags"""
+        collection = CollectionFactory()
+
+        # Create URLs with different tag scenarios
+        DeltaUrlFactory(collection=collection, tdamm_tag_manual=["MMA_M_EM"])
+        DeltaUrlFactory(collection=collection, tdamm_tag_ml=["MMA_O_BH"])
+        DeltaUrlFactory(collection=collection)  # No tags
+
+        # Verify has_tdamm_tags method
+        assert collection.has_tdamm_tags() is True
+
+        # Create a new collection with no tagged URLs
+        empty_collection = CollectionFactory()
+        assert empty_collection.has_tdamm_tags() is False

From d2b9685d435ff497a8df1102dde4af31a224f021 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Fri, 7 Feb 2025 11:26:53 -0600
Subject: [PATCH 17/35] Added HTML for tdamm tag filter

---
 .../sde_collections/delta_urls_list.html       | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/sde_indexing_helper/templates/sde_collections/delta_urls_list.html b/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
index df8bb0d3..4672047f 100644
--- a/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
+++ b/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
@@ -146,7 +146,14 @@ <h3 class="whiteText deltaTitle">
                         <option value="4">Software and Tools</option>
                         <option value="5">Missions and Instruments</option>
                         </select></td>
-                        <td><input type="text" class="table_filter_row_input textBoxStyling" id="deltaTdammTagFilter" placeholder="TDAMM Tags" /></td>
+                        <td>
+                            <select class="dropdown-6 select-dropdown selectStyling" id="deltaTdammTagFilter">
+                                <option value="">SELECT</option>
+                                <option value="ml">ML Tags</option>
+                                <option value="manual">Manual Tags</option>
+                                <option value="Not Set">No Tags</option>
+                            </select>
+                        </td>
                         <td><select class="dropdown-5 select-dropdown selectStyling"><option value="">SELECT</option>
                         <option value="0">None</option>
                         <option value="1">Astrophysics</option>
@@ -206,7 +213,14 @@ <h3 class="whiteText deltaTitle">
                         <option value="4">Software and Tools</option>
                         <option value="5">Missions and Instruments</option>
                         </select></td>
-                        <td><input type="text" class="table_filter_row_input textBoxStyling" id="deltaTdammTagFilter" placeholder="TDAMM Tags" /></td>
+                        <td>
+                            <select class="dropdown-6 select-dropdown selectStyling" id="deltaTdammTagFilter">
+                                <option value="">SELECT</option>
+                                <option value="ml">ML Tags</option>
+                                <option value="manual">Manual Tags</option>
+                                <option value="Not Set">No Tags</option>
+                            </select>
+                        </td>
                         <td><select class="dropdown-5 select-dropdown selectStyling"><option value="">SELECT</option>
                         <option value="0">None</option>
                         <option value="1">Astrophysics</option>

From 26f6308871c0d7411f425ff5fb37cca7de292c1b Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanurjsharma@gmail.com>
Date: Fri, 7 Feb 2025 12:51:02 -0500
Subject: [PATCH 18/35] Potential fix for code scanning alert no. 51:
 Information exposure through an exception

Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com>
---
 sde_collections/views.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/sde_collections/views.py b/sde_collections/views.py
index 6394097b..53a89742 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -1,4 +1,5 @@
 import re
+import logging
 
 from django.contrib import messages
 from django.contrib.auth import get_user_model
@@ -57,6 +58,7 @@
 from .utils.health_check import generate_db_github_metadata_differences
 
 User = get_user_model()
+logger = logging.getLogger(__name__)
 
 
 class CollectionListView(LoginRequiredMixin, ListView):
@@ -355,7 +357,8 @@ def remove_tag(self, request, pk=None):
             delta_url.remove_tag(tag, source)
             return Response({"status": "success"})
         except Exception as e:
-            return Response({"error": str(e)}, status=500)
+            logger.error(f"Error occurred: {str(e)}")
+            return Response({"error": "An internal error has occurred."}, status=500)
 
     # @action(detail=True, methods=["post"], url_path="add_tag")
     # def add_tag(self, request, pk=None):

From b8f18653a5dbadf16ea2d09fdb36c71ba3adcba8 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanurjsharma@gmail.com>
Date: Fri, 7 Feb 2025 12:53:11 -0500
Subject: [PATCH 19/35] Potential fix for code scanning alert no. 52:
 Information exposure through an exception

Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com>
---
 sde_collections/views.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/sde_collections/views.py b/sde_collections/views.py
index 53a89742..37e3830b 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -404,7 +404,8 @@ def add_tag(self, request, pk=None):
             delta_url.add_tag(tag, source)
             return Response({"status": "success"})
         except Exception as e:
-            return Response({"error": str(e)}, status=500)
+            logger.error("An error occurred while adding a tag to DeltaURL: %s", str(e))
+            return Response({"error": "An internal error has occurred."}, status=500)
 
 
 class CuratedURLViewSet(CollectionFilterMixin, viewsets.ModelViewSet):
@@ -449,7 +450,8 @@ def add_tag(self, request, pk=None):
             curated_url.add_tag(tag, source)
             return Response({"status": "success"})
         except Exception as e:
-            return Response({"error": str(e)}, status=500)
+            logger.error("An error occurred while adding a tag to CuratedURL: %s", str(e))
+            return Response({"error": "An internal error has occurred."}, status=500)
 
     @action(detail=True, methods=["post"], url_path="remove_tag")
     def remove_tag(self, request, pk=None):
@@ -464,7 +466,8 @@ def remove_tag(self, request, pk=None):
             curated_url.remove_tag(tag, source)
             return Response({"status": "success"})
         except Exception as e:
-            return Response({"error": str(e)}, status=500)
+            logger.error("An error occurred while removing a tag from CuratedURL: %s", str(e))
+            return Response({"error": "An internal error has occurred."}, status=500)
 
 
 class DeltaURLBulkCreateView(generics.ListCreateAPIView):

From fb7d964a8d310eb516df50812df7fb9b773a7e3b Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Fri, 7 Feb 2025 12:35:32 -0600
Subject: [PATCH 20/35] Cleanup views

---
 sde_collections/views.py | 70 ----------------------------------------
 1 file changed, 70 deletions(-)

diff --git a/sde_collections/views.py b/sde_collections/views.py
index 5a8cfbc9..9c2a71a4 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -328,45 +328,6 @@ def update_division(self, request, pk=None):
             return Response(status=status.HTTP_200_OK)
         return Response(status=status.HTTP_400_BAD_REQUEST, data={"error": "Division is required."})
 
-    # @action(detail=True, methods=["post"], url_path="remove_tag")
-    # def remove_tag(self, request, pk=None):
-    #     delta_url = self.get_object()
-    #     tag_to_remove = request.data.get("tag")
-    #     source = request.data.get("source")
-
-    #     if not tag_to_remove:
-    #         return Response({"error": "Tag to remove not specified"}, status=status.HTTP_400_BAD_REQUEST)
-
-    #     try:
-    #         # print(f"Current state - ML tags: {delta_url.tdamm_tag_ml}, Manual tags: {delta_url.tdamm_tag_manual}")
-    #         # print(f"Source: {source}, Tag to remove: {tag_to_remove}")
-
-    #         if source == "ml":
-    #             # Get current ML tags
-    #             ml_tags = delta_url.tdamm_tag_ml
-    #             if ml_tags:
-    #                 # Create a new list from ML tags, excluding the one to remove
-    #                 new_manual_tags = [tag for tag in ml_tags if tag != tag_to_remove]
-    #                 # Set the new list to manual tags
-    #                 delta_url.tdamm_tag_manual = new_manual_tags
-    #                 # print(f"New manual tags after copy and remove: {delta_url.tdamm_tag_manual}")
-    #         else:
-    #             if delta_url.tdamm_tag_manual:
-    #                 manual_tags = delta_url.tdamm_tag_manual
-    #                 if tag_to_remove in manual_tags:
-    #                     manual_tags.remove(tag_to_remove)
-    #                     delta_url.tdamm_tag_manual = manual_tags
-    #                     # print(f"New manual tags after remove: {delta_url.tdamm_tag_manual}")
-
-    #         delta_url.save()
-    #         # print(f"Final state - ML tags: {delta_url.tdamm_tag_ml}, Manual tags: {delta_url.tdamm_tag_manual}")
-
-    #         return Response({"status": "success"})
-
-    #     except Exception as e:
-    #         print(f"Error occurred: {str(e)}")
-    #         return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
     @action(detail=True, methods=["post"], url_path="remove_tag")
     def remove_tag(self, request, pk=None):
         delta_url = self.get_object()
@@ -383,37 +344,6 @@ def remove_tag(self, request, pk=None):
             logger.error(f"Error occurred: {str(e)}")
             return Response({"error": "An internal error has occurred."}, status=500)
 
-    # @action(detail=True, methods=["post"], url_path="add_tag")
-    # def add_tag(self, request, pk=None):
-    #     delta_url = self.get_object()
-    #     tag_to_add = request.data.get("tag")
-    #     source = request.data.get("source")
-
-    #     if not tag_to_add:
-    #         return Response({"error": "Tag to add not specified"}, status=status.HTTP_400_BAD_REQUEST)
-
-    #     try:
-    #         # Get current tags
-    #         if source == "ml":
-    #             # If source is ML, copy ML tags to manual and add new tag
-    #             current_tags = delta_url.tdamm_tag_ml or []
-    #             new_tags = list(current_tags)  # Create a copy
-    #             if tag_to_add not in new_tags:
-    #                 new_tags.append(tag_to_add)
-    #             delta_url.tdamm_tag_manual = new_tags
-    #         else:
-    #             # For manual source, just add to existing manual tags
-    #             current_tags = delta_url.tdamm_tag_manual or []
-    #             if tag_to_add not in current_tags:
-    #                 current_tags.append(tag_to_add)
-    #                 delta_url.tdamm_tag_manual = current_tags
-
-    #         delta_url.save()
-    #         return Response({"status": "success"})
-
-    #     except Exception as e:
-    #         return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
     @action(detail=True, methods=["post"], url_path="add_tag")
     def add_tag(self, request, pk=None):
         delta_url = self.get_object()

From d3b1d1739b8d478f4477ae0bd752981298ae5ee3 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Fri, 7 Feb 2025 12:36:55 -0600
Subject: [PATCH 21/35] Cleanup delta_url model

---
 sde_collections/models/delta_url.py | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/sde_collections/models/delta_url.py b/sde_collections/models/delta_url.py
index 034792c1..9583fb26 100644
--- a/sde_collections/models/delta_url.py
+++ b/sde_collections/models/delta_url.py
@@ -136,19 +136,6 @@ def splits(self) -> list[tuple[str, str]]:
 
     def get_tag_source(self):
         """Returns the source of the TDAMM tags: 'manual', 'ml', or 'Not Set'"""
-        # print("Checking tag sources for URL:", self.url)
-        # print("Manual tags:", self.tdamm_tag_manual)
-        # print("ML tags:", self.tdamm_tag_ml)
-
-        # if self.tdamm_tag_manual and self.tdamm_tag_manual != []:
-        #     print("Using manual tags")
-        #     return "manual"
-        # elif self.tdamm_tag_ml and self.tdamm_tag_ml != []:
-        #     print("Using ML tags")
-        #     return "ml"
-
-        # print("No tags found, using 'Not Set'")
-        # return "Not Set"
         # Convert None to empty list for comparison
         manual_tags = self.tdamm_tag_manual or []
         ml_tags = self.tdamm_tag_ml or []

From 30942146734d9cc8a6c6b82ad5e7492c49de1162 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Fri, 7 Feb 2025 12:39:04 -0600
Subject: [PATCH 22/35] Cleanup JS

---
 sde_indexing_helper/static/js/delta_url_list.js | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/sde_indexing_helper/static/js/delta_url_list.js b/sde_indexing_helper/static/js/delta_url_list.js
index 7a266bf3..f4661713 100644
--- a/sde_indexing_helper/static/js/delta_url_list.js
+++ b/sde_indexing_helper/static/js/delta_url_list.js
@@ -1366,15 +1366,6 @@ function getTdammTagColumn() {
       // });
 
       const tagSource = row.tag_source;
-      // const tags = data.map(tag => `
-      //   <div class="tdamm-tag">
-      //     <span class="tag-text">${tag}</span>
-      //     <button class="delete-tag"
-      //       data-url-id="${row.id}"
-      //       data-tag="${tag}"
-      //       data-source="${tagSource}">×</button>
-      //   </div>
-      // `).join('');
 
       const tags = data.map(tag => {
         const fullName = tdamm_choices.find(choice => choice.code === tag)?.label || tag;
@@ -2553,4 +2544,3 @@ function handleTagAddition() {
       }
   });
 }
-//

From aec3bfd60e67929536c714977daa729b462f7ec3 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Fri, 7 Feb 2025 14:51:17 -0600
Subject: [PATCH 23/35] Added additional tests

---
 sde_collections/tests/test_tdamm_tags.py | 120 +++++++++++++++++++++++
 1 file changed, 120 insertions(+)

diff --git a/sde_collections/tests/test_tdamm_tags.py b/sde_collections/tests/test_tdamm_tags.py
index f91460c4..e82b60fa 100644
--- a/sde_collections/tests/test_tdamm_tags.py
+++ b/sde_collections/tests/test_tdamm_tags.py
@@ -279,3 +279,123 @@ def test_tdamm_tag_collection_method(self):
         # Create a new collection with no tagged URLs
         empty_collection = CollectionFactory()
         assert empty_collection.has_tdamm_tags() is False
+
+    def test_ml_source_tag_behavior(self):
+        """Test that ML source copies existing list to manual tags"""
+        url = DeltaUrlFactory()
+
+        # Set initial ML tags
+        url.tdamm_tag_ml = ["MMA_M_EM", "MMA_M_G"]
+
+        # Add tag with ML source - should copy ML tags and add new one
+        url.add_tag("MMA_M_N", "ml")
+        assert url.tdamm_tag_manual == ["MMA_M_EM", "MMA_M_G", "MMA_M_N"]
+        assert url.tdamm_tag_ml == ["MMA_M_EM", "MMA_M_G"]
+
+    def test_manual_source_tag_behavior(self):
+        """Test that manual source only affects manual tags"""
+        url = DeltaUrlFactory()
+        url.tdamm_tag_ml = ["MMA_M_EM"]
+        url.tdamm_tag_manual = ["MMA_M_G"]
+
+        url.add_tag("MMA_M_N", "manual")
+        assert url.tdamm_tag_manual == ["MMA_M_G", "MMA_M_N"]
+        assert url.tdamm_tag_ml == ["MMA_M_EM"]
+
+    def test_tag_operations_with_none_values(self):
+        """Test tag operations when fields are None"""
+        url = DeltaUrlFactory()
+
+        # Add tag when both fields are None
+        url.add_tag("MMA_M_EM", "manual")
+        assert url.tdamm_tag_manual == ["MMA_M_EM"]
+
+        # Remove tag when field is None
+        url = DeltaUrlFactory()
+        url.remove_tag("MMA_M_EM", "manual")
+        assert True if url.tdamm_tag_manual is None else False
+
+    def test_invalid_tag_operations(self):
+        """Test operations with invalid tags"""
+        url = DeltaUrlFactory()
+        url.tdamm_tag_manual = ["MMA_M_EM"]
+
+        # Remove non-existent tag
+        url.remove_tag("INVALID_TAG", "manual")
+        assert url.tdamm_tag_manual == ["MMA_M_EM"]
+
+    def test_delta_cleanup_after_tag_changes(self):
+        """Test DeltaUrl cleanup when tags match CuratedUrl"""
+        collection = CollectionFactory()
+
+        # Create matching URLs
+        CuratedUrl.objects.create(collection=collection, url="https://example.com", tdamm_tag_manual=["MMA_M_EM"])
+
+        delta = DeltaUrl.objects.create(collection=collection, url="https://example.com")
+
+        # Add same tag - should trigger cleanup
+        delta.add_tag("MMA_M_EM", "manual")
+        assert not DeltaUrl.objects.filter(id=delta.id).exists()
+
+    def test_curated_url_tag_operations(self):
+        """Test that CuratedUrl tag changes create/update DeltaUrl"""
+        collection = CollectionFactory()
+        curated = CuratedUrl.objects.create(collection=collection, url="https://example.com", tdamm_tag_manual=[])
+
+        # Initial state
+        curated.tdamm_tag_manual = []
+        curated.save()
+
+        # Adding tag should create DeltaUrl with different tags
+        curated.add_tag("MMA_M_EM", "manual")
+        delta = DeltaUrl.objects.get(url=curated.url)
+        assert delta.tdamm_tag_manual == ["MMA_M_EM"]
+
+        # Adding another tag should update existing DeltaUrl
+        curated.add_tag("MMA_M_G", "manual")
+        delta.refresh_from_db()
+        assert len(DeltaUrl.objects.filter(url=curated.url)) == 1
+        assert delta.tdamm_tag_manual == ["MMA_M_G"]
+
+    def test_curated_url_ml_tag_operations(self):
+        """Test CuratedUrl operations with ML source"""
+        collection = CollectionFactory()
+        curated = CuratedUrl.objects.create(
+            collection=collection, url="https://example.com", tdamm_tag_ml=["MMA_M_EM", "MMA_M_G"]
+        )
+
+        # Adding tag with ML source should copy ML tags to manual
+        curated.add_tag("MMA_M_N", "ml")
+        delta = DeltaUrl.objects.get(url=curated.url)
+        assert delta.tdamm_tag_manual == ["MMA_M_EM", "MMA_M_G", "MMA_M_N"]
+        assert delta.tdamm_tag_ml == ["MMA_M_EM", "MMA_M_G"]
+
+    def test_ml_source_cleanup_behavior(self):
+        """Test cleanup when using ML source"""
+        url = DeltaUrlFactory()
+        url.tdamm_tag_ml = ["MMA_M_EM", "MMA_M_G"]
+
+        # Using ML source should copy to manual
+        url.add_tag("MMA_M_N", "ml")
+        assert url.tdamm_tag_manual == ["MMA_M_EM", "MMA_M_G", "MMA_M_N"]
+        assert url.tdamm_tag_ml == ["MMA_M_EM", "MMA_M_G"]
+
+        # Removing via ML source should update manual
+        url.remove_tag("MMA_M_N", "ml")
+        assert url.tdamm_tag_manual == ["MMA_M_EM", "MMA_M_G"]
+
+    def test_tag_source_transitions(self):
+        """Test transitioning between tag sources"""
+        url = DeltaUrlFactory()
+
+        # Start with ML tags
+        url.tdamm_tag_ml = ["MMA_M_EM"]
+        assert url.get_tag_source() == "ml"
+
+        # Add manual tag should change source
+        url.add_tag("MMA_M_G", "manual")
+        assert url.get_tag_source() == "manual"
+
+        # Clear manual tags should revert to ML
+        url.tdamm_tag_manual = []
+        assert url.get_tag_source() == "ml"

From 1b24c0dd9c56c5744987e54218ada3b57249de1c Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Fri, 14 Feb 2025 19:02:28 -0600
Subject: [PATCH 24/35] Added TDAMM patterns and update views

---
 .../migrations/0076_deltatdammtagpattern.py   | 105 ++++++++++++++
 sde_collections/models/delta_patterns.py      | 137 +++++++++++++++++-
 sde_collections/views.py                      |  18 ++-
 3 files changed, 257 insertions(+), 3 deletions(-)
 create mode 100644 sde_collections/migrations/0076_deltatdammtagpattern.py

diff --git a/sde_collections/migrations/0076_deltatdammtagpattern.py b/sde_collections/migrations/0076_deltatdammtagpattern.py
new file mode 100644
index 00000000..fd913d40
--- /dev/null
+++ b/sde_collections/migrations/0076_deltatdammtagpattern.py
@@ -0,0 +1,105 @@
+# Generated by Django 4.2.9 on 2025-02-14 23:33
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("sde_collections", "0075_alter_collection_reindexing_status_and_more"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="DeltaTdammTagPattern",
+            fields=[
+                ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                (
+                    "match_pattern",
+                    models.CharField(
+                        help_text="This pattern is compared against the URL of all documents in the collection",
+                        verbose_name="Pattern",
+                    ),
+                ),
+                (
+                    "match_pattern_type",
+                    models.IntegerField(choices=[(1, "Individual URL Pattern"), (2, "Multi-URL Pattern")], default=1),
+                ),
+                (
+                    "tag",
+                    models.CharField(
+                        choices=[
+                            ("Not TDAMM", "Not TDAMM"),
+                            ("MMA_M_EM", "Messenger - EM Radiation"),
+                            ("MMA_M_EM_G", "Messenger - EM Radiation - Gamma rays"),
+                            ("MMA_M_EM_X", "Messenger - EM Radiation - X-rays"),
+                            ("MMA_M_EM_U", "Messenger - EM Radiation - Ultraviolet"),
+                            ("MMA_M_EM_O", "Messenger - EM Radiation - Optical"),
+                            ("MMA_M_EM_I", "Messenger - EM Radiation - Infrared"),
+                            ("MMA_M_EM_M", "Messenger - EM Radiation - Microwave"),
+                            ("MMA_M_EM_R", "Messenger - EM Radiation - Radio"),
+                            ("MMA_M_G", "Messenger - Gravitational Waves"),
+                            ("MMA_M_G_CBI", "Messenger - Gravitational Waves - Compact Binary Inspiral"),
+                            ("MMA_M_G_S", "Messenger - Gravitational Waves - Stochastic"),
+                            ("MMA_M_G_CON", "Messenger - Gravitational Waves - Continuous"),
+                            ("MMA_M_G_B", "Messenger - Gravitational Waves - Burst"),
+                            ("MMA_M_C", "Messenger - Cosmic Rays"),
+                            ("MMA_M_N", "Messenger - Neutrinos"),
+                            ("MMA_O_BI", "Objects - Binaries"),
+                            ("MMA_O_BI_BBH", "Objects - Binaries - Binary Black Holes"),
+                            ("MMA_O_BI_BNS", "Objects - Binaries - Binary Neutron Stars"),
+                            ("MMA_O_BI_C", "Objects - Binaries - Cataclysmic Variables"),
+                            ("MMA_O_BI_N", "Objects - Binaries - Neutron Star-Black Hole"),
+                            ("MMA_O_BI_B", "Objects - Binaries - Binary Pulsars"),
+                            ("MMA_O_BI_W", "Objects - Binaries - White Dwarf Binaries"),
+                            ("MMA_O_BH", "Objects - Black Holes"),
+                            ("MMA_O_BH_AGN", "Objects - Black Holes - Active Galactic Nuclei"),
+                            ("MMA_O_BH_IM", "Objects - Black Holes - Intermediate mass"),
+                            ("MMA_O_BH_STM", "Objects - Black Holes - Stellar mass"),
+                            ("MMA_O_BH_SUM", "Objects - Black Holes - Supermassive"),
+                            ("MMA_O_E", "Objects - Exoplanets"),
+                            ("MMA_O_N", "Objects - Neutron Stars"),
+                            ("MMA_O_N_M", "Objects - Neutron Stars - Magnetars"),
+                            ("MMA_O_N_P", "Objects - Neutron Stars - Pulsars"),
+                            ("MMA_O_N_PWN", "Objects - Neutron Stars - Pulsar Wind Nebula"),
+                            ("MMA_O_S", "Objects - Supernova Remnants"),
+                            ("MMA_S_F", "Signals - Fast Radio Bursts"),
+                            ("MMA_S_G", "Signals - Gamma-ray Bursts"),
+                            ("MMA_S_K", "Signals - Kilonovae"),
+                            ("MMA_S_N", "Signals - Novae"),
+                            ("MMA_S_P", "Signals - Pevatrons"),
+                            ("MMA_S_ST", "Signals - Stellar flares"),
+                            ("MMA_S_SU", "Signals - Supernovae"),
+                        ],
+                        help_text="TDAMM tag to apply",
+                        max_length=255,
+                    ),
+                ),
+                (
+                    "source",
+                    models.CharField(
+                        choices=[("manual", "Manual"), ("ml", "Machine Learning")], default="manual", max_length=10
+                    ),
+                ),
+                (
+                    "collection",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="%(class)ss",
+                        related_query_name="%(class)ss",
+                        to="sde_collections.collection",
+                    ),
+                ),
+                ("curated_urls", models.ManyToManyField(related_name="%(class)ss", to="sde_collections.curatedurl")),
+                ("delta_urls", models.ManyToManyField(related_name="%(class)ss", to="sde_collections.deltaurl")),
+            ],
+            options={
+                "verbose_name": "Delta TDAMM Tag Pattern",
+                "verbose_name_plural": "Delta TDAMM Tag Patterns",
+                "ordering": ["match_pattern"],
+                "abstract": False,
+                "unique_together": {("collection", "match_pattern")},
+            },
+        ),
+    ]
diff --git a/sde_collections/models/delta_patterns.py b/sde_collections/models/delta_patterns.py
index 61c8e9ea..46594f63 100644
--- a/sde_collections/models/delta_patterns.py
+++ b/sde_collections/models/delta_patterns.py
@@ -11,7 +11,7 @@
     resolve_title,
     validate_fstring,
 )
-from .collection_choice_fields import Divisions, DocumentTypes
+from .collection_choice_fields import Divisions, DocumentTypes, TDAMMTags
 
 
 class BaseMatchPattern(models.Model):
@@ -691,3 +691,138 @@ def save(self, *args, **kwargs):
 class DeltaResolvedTitleError(DeltaResolvedTitleBase):
     error_string = models.TextField(null=False, blank=False)
     http_status_code = models.IntegerField(null=True, blank=True)
+
+
+class DeltaTdammTagPattern(FieldModifyingPattern):
+    """Pattern for managing TDAMM tags."""
+
+    tag = models.CharField(max_length=255, choices=TDAMMTags.choices, help_text="TDAMM tag to apply")
+
+    source = models.CharField(
+        max_length=10, choices=[("manual", "Manual"), ("ml", "Machine Learning")], default="manual"
+    )
+
+    def get_field_to_modify(self) -> str:
+        return f"tdamm_tag_{self.source}"
+
+    def get_new_value(self) -> list:
+        """Return list of tags including the new tag."""
+        return [self.tag]
+
+    def apply(self) -> None:
+        """
+        Apply TDAMM tag modification to matching URLs:
+        1. Find URLs that match but weren't previously affected
+        2. Create Delta URLs only where tags would change
+        3. Update the pattern's list of affected URLs
+        4. Add tag to matching Delta URLs
+        """
+        DeltaUrl = apps.get_model("sde_collections", "DeltaUrl")
+
+        field = self.get_field_to_modify()
+        new_tag = self.tag
+
+        # Get newly matching Curated URLs
+        matching_curated_urls = self.get_matching_curated_urls()
+        previously_unaffected_curated = matching_curated_urls.exclude(
+            id__in=self.curated_urls.values_list("id", flat=True)
+        )
+
+        # Create DeltaUrls only where tags would change
+        for curated_url in previously_unaffected_curated:
+            if not self.is_most_distinctive_pattern(curated_url):
+                continue
+
+            current_tags = getattr(curated_url, field) or []
+            if new_tag in current_tags:
+                continue
+
+            if DeltaUrl.objects.filter(url=curated_url.url, collection=self.collection).exists():
+                continue
+
+            fields = {
+                f.name: getattr(curated_url, f.name)
+                for f in curated_url._meta.fields
+                if f.name not in ["id", "collection"]
+            }
+
+            # Update tags field
+            new_tags = list(current_tags)
+            if new_tag not in new_tags:
+                new_tags.append(new_tag)
+            fields[field] = new_tags
+
+            fields["to_delete"] = False
+            fields["collection"] = self.collection
+
+            DeltaUrl.objects.create(**fields)
+
+        # Update tags for all matching DeltaUrls
+        for delta_url in self.get_matching_delta_urls():
+            if not self.is_most_distinctive_pattern(delta_url):
+                continue
+
+            current_tags = getattr(delta_url, field) or []
+            if new_tag not in current_tags:
+                new_tags = list(current_tags)
+                new_tags.append(new_tag)
+                setattr(delta_url, field, new_tags)
+                delta_url.save()
+
+        # Update pattern relationships
+        self.update_affected_delta_urls_list()
+
+    def unapply(self) -> None:
+        """
+        Remove tag modifications:
+        1. Remove tag from affected URLs
+        2. Clean up Delta URLs that become identical to their Curated URL
+        3. Handle Curated URLs that need new Delta URLs created
+        """
+        DeltaUrl = apps.get_model("sde_collections", "DeltaUrl")
+        CuratedUrl = apps.get_model("sde_collections", "CuratedUrl")
+
+        field = self.get_field_to_modify()
+        tag_to_remove = self.tag
+
+        # Get all affected URLs
+        affected_deltas = self.delta_urls.all()
+        affected_curated = self.curated_urls.all()
+
+        # Process each affected delta URL
+        for delta in affected_deltas:
+            current_tags = getattr(delta, field) or []
+
+            if tag_to_remove in current_tags:
+                new_tags = [tag for tag in current_tags if tag != tag_to_remove]
+                setattr(delta, field, new_tags or None)
+                delta.save()
+
+            # Check if delta is now redundant
+            curated = CuratedUrl.objects.filter(collection=self.collection, url=delta.url).first()
+            if curated and delta._fields_match(curated):
+                delta.delete()
+
+        # Process affected curated URLs that don't have deltas
+        for curated in affected_curated:
+            if not DeltaUrl.objects.filter(url=curated.url).exists():
+                current_tags = getattr(curated, field) or []
+                if tag_to_remove in current_tags:
+                    # Create delta with tag removed
+                    fields = {
+                        f.name: getattr(curated, f.name)
+                        for f in curated._meta.fields
+                        if f.name not in ["id", "collection"]
+                    }
+                    new_tags = [tag for tag in current_tags if tag != tag_to_remove]
+                    fields[field] = new_tags or None
+                    fields["to_delete"] = False
+                    DeltaUrl.objects.create(collection=self.collection, **fields)
+
+        # Clear pattern relationships
+        self.delta_urls.clear()
+        self.curated_urls.clear()
+
+    class Meta(FieldModifyingPattern.Meta):
+        verbose_name = "Delta TDAMM Tag Pattern"
+        verbose_name_plural = "Delta TDAMM Tag Patterns"
diff --git a/sde_collections/views.py b/sde_collections/views.py
index 9c2a71a4..7263c36b 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -37,6 +37,7 @@
     DeltaIncludePattern,
     DeltaResolvedTitle,
     DeltaResolvedTitleError,
+    DeltaTdammTagPattern,
     DeltaTitlePattern,
 )
 from .models.delta_url import CuratedUrl, DeltaUrl
@@ -338,7 +339,13 @@ def remove_tag(self, request, pk=None):
             return Response({"error": "Tag not specified"}, status=400)
 
         try:
-            delta_url.remove_tag(tag, source)
+            # delta_url.remove_tag(tag, source)
+            pattern = DeltaTdammTagPattern.objects.filter(
+                collection=delta_url.collection, match_pattern=delta_url.url, tag=tag, source=source
+            ).first()
+
+            if pattern:
+                pattern.delete()
             return Response({"status": "success"})
         except Exception as e:
             logger.error(f"Error occurred: {str(e)}")
@@ -354,7 +361,14 @@ def add_tag(self, request, pk=None):
             return Response({"error": "Tag not specified"}, status=400)
 
         try:
-            delta_url.add_tag(tag, source)
+            # delta_url.add_tag(tag, source)
+            DeltaTdammTagPattern.objects.create(
+                collection=delta_url.collection,
+                match_pattern=delta_url.url,
+                match_pattern_type=1,
+                tag=tag,
+                source=source,
+            )
             return Response({"status": "success"})
         except Exception as e:
             logger.error("An error occurred while adding a tag to DeltaURL: %s", str(e))

From d1e18b116e92e39ebcf01e3229498bb26d6cda8f Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Mon, 24 Feb 2025 17:56:55 -0600
Subject: [PATCH 25/35] Updated patterns, views, serializers, urls

---
 sde_collections/models/delta_patterns.py | 244 +++++++++++++++--------
 sde_collections/serializers.py           |  15 ++
 sde_collections/urls.py                  |   1 +
 sde_collections/views.py                 |   9 +
 4 files changed, 184 insertions(+), 85 deletions(-)

diff --git a/sde_collections/models/delta_patterns.py b/sde_collections/models/delta_patterns.py
index 46594f63..afb2828e 100644
--- a/sde_collections/models/delta_patterns.py
+++ b/sde_collections/models/delta_patterns.py
@@ -693,136 +693,210 @@ class DeltaResolvedTitleError(DeltaResolvedTitleBase):
     http_status_code = models.IntegerField(null=True, blank=True)
 
 
-class DeltaTdammTagPattern(FieldModifyingPattern):
-    """Pattern for managing TDAMM tags."""
+class DeltaTdammTagPattern(BaseMatchPattern):
+    """Pattern for adding or removing TDAMM tags."""
 
-    tag = models.CharField(max_length=255, choices=TDAMMTags.choices, help_text="TDAMM tag to apply")
+    class OperationChoices(models.IntegerChoices):
+        ADD = 1, "Add Tag"
+        REMOVE = 2, "Remove Tag"
 
-    source = models.CharField(
-        max_length=10, choices=[("manual", "Manual"), ("ml", "Machine Learning")], default="manual"
-    )
-
-    def get_field_to_modify(self) -> str:
-        return f"tdamm_tag_{self.source}"
-
-    def get_new_value(self) -> list:
-        """Return list of tags including the new tag."""
-        return [self.tag]
+    tag = models.CharField(max_length=255, choices=TDAMMTags.choices)
+    operation = models.IntegerField(choices=OperationChoices.choices, default=OperationChoices.ADD)
 
-    def apply(self) -> None:
+    def apply(self):
         """
-        Apply TDAMM tag modification to matching URLs:
-        1. Find URLs that match but weren't previously affected
-        2. Create Delta URLs only where tags would change
-        3. Update the pattern's list of affected URLs
-        4. Add tag to matching Delta URLs
+        Apply tag operation to matching URLs.
+        Similar to FieldModifyingPattern.apply() but with custom tag handling.
         """
         DeltaUrl = apps.get_model("sde_collections", "DeltaUrl")
 
-        field = self.get_field_to_modify()
-        new_tag = self.tag
-
         # Get newly matching Curated URLs
         matching_curated_urls = self.get_matching_curated_urls()
         previously_unaffected_curated = matching_curated_urls.exclude(
             id__in=self.curated_urls.values_list("id", flat=True)
         )
 
-        # Create DeltaUrls only where tags would change
+        # Process each unaffected Curated URL
         for curated_url in previously_unaffected_curated:
             if not self.is_most_distinctive_pattern(curated_url):
                 continue
 
-            current_tags = getattr(curated_url, field) or []
-            if new_tag in current_tags:
-                continue
-
-            if DeltaUrl.objects.filter(url=curated_url.url, collection=self.collection).exists():
-                continue
+            # Check if operation would change tags
+            if self._would_operation_change_tags(curated_url):
+                # Check if Delta already exists
+                delta_exists = DeltaUrl.objects.filter(url=curated_url.url, collection=self.collection).exists()
 
-            fields = {
-                f.name: getattr(curated_url, f.name)
-                for f in curated_url._meta.fields
-                if f.name not in ["id", "collection"]
-            }
-
-            # Update tags field
-            new_tags = list(current_tags)
-            if new_tag not in new_tags:
-                new_tags.append(new_tag)
-            fields[field] = new_tags
+                if not delta_exists:
+                    # Create new Delta URL with copied fields
+                    fields = {
+                        field.name: getattr(curated_url, field.name)
+                        for field in curated_url._meta.fields
+                        if field.name not in ["id", "collection"]
+                    }
+                    fields["to_delete"] = False
+                    fields["collection"] = self.collection
 
-            fields["to_delete"] = False
-            fields["collection"] = self.collection
+                    delta = DeltaUrl.objects.create(**fields)
 
-            DeltaUrl.objects.create(**fields)
+                    # Apply tag operation
+                    self._apply_tag_operation(delta)
 
-        # Update tags for all matching DeltaUrls
+        # Update tags for all matching Delta URLs
         for delta_url in self.get_matching_delta_urls():
-            if not self.is_most_distinctive_pattern(delta_url):
-                continue
-
-            current_tags = getattr(delta_url, field) or []
-            if new_tag not in current_tags:
-                new_tags = list(current_tags)
-                new_tags.append(new_tag)
-                setattr(delta_url, field, new_tags)
-                delta_url.save()
+            if self.is_most_distinctive_pattern(delta_url):
+                self._apply_tag_operation(delta_url)
 
         # Update pattern relationships
         self.update_affected_delta_urls_list()
+        self.update_affected_curated_urls_list()
 
-    def unapply(self) -> None:
+    def unapply(self):
         """
-        Remove tag modifications:
-        1. Remove tag from affected URLs
-        2. Clean up Delta URLs that become identical to their Curated URL
-        3. Handle Curated URLs that need new Delta URLs created
+        Remove tag operation effects.
+        Similar to FieldModifyingPattern.unapply() but with custom tag handling.
         """
         DeltaUrl = apps.get_model("sde_collections", "DeltaUrl")
         CuratedUrl = apps.get_model("sde_collections", "CuratedUrl")
 
-        field = self.get_field_to_modify()
-        tag_to_remove = self.tag
+        # Get affected URLs
+        affected_deltas = list(self.delta_urls.all())
+        affected_curated = list(self.curated_urls.all())
 
-        # Get all affected URLs
-        affected_deltas = self.delta_urls.all()
-        affected_curated = self.curated_urls.all()
+        # Get other matching patterns
+        other_patterns = DeltaTdammTagPattern.objects.filter(
+            collection=self.collection, tag=self.tag, operation=self.operation
+        ).exclude(id=self.id)
 
         # Process each affected delta URL
         for delta in affected_deltas:
-            current_tags = getattr(delta, field) or []
+            curated = CuratedUrl.objects.filter(collection=self.collection, url=delta.url).first()
 
-            if tag_to_remove in current_tags:
-                new_tags = [tag for tag in current_tags if tag != tag_to_remove]
-                setattr(delta, field, new_tags or None)
-                delta.save()
+            # Find next most specific pattern
+            matching_patterns = [p for p in other_patterns if re.search(p.get_regex_pattern(), delta.url)]
 
-            # Check if delta is now redundant
-            curated = CuratedUrl.objects.filter(collection=self.collection, url=delta.url).first()
-            if curated and delta._fields_match(curated):
-                delta.delete()
+            next_pattern = None
+            if matching_patterns:
+                next_pattern = min(matching_patterns, key=lambda p: p.get_url_match_count())
+
+            if next_pattern:
+                # Another pattern applies, no change needed
+                pass
+            else:
+                # Revert our changes
+                self._revert_tag_operation(delta)
+
+                # Check if delta is now redundant
+                if curated and delta._fields_match(curated):
+                    delta.delete()
 
-        # Process affected curated URLs that don't have deltas
+        # Process curated URLs without deltas
         for curated in affected_curated:
-            if not DeltaUrl.objects.filter(url=curated.url).exists():
-                current_tags = getattr(curated, field) or []
-                if tag_to_remove in current_tags:
-                    # Create delta with tag removed
+            if not DeltaUrl.objects.filter(url=curated.url, collection=self.collection).exists():
+                # Find next most specific pattern
+                matching_patterns = [p for p in other_patterns if re.search(p.get_regex_pattern(), curated.url)]
+
+                next_pattern = None
+                if matching_patterns:
+                    next_pattern = min(matching_patterns, key=lambda p: p.get_url_match_count())
+
+                if not next_pattern and self._would_operation_change_tags(curated):
+                    # Create delta with reverted tags
                     fields = {
-                        f.name: getattr(curated, f.name)
-                        for f in curated._meta.fields
-                        if f.name not in ["id", "collection"]
+                        field.name: getattr(curated, field.name)
+                        for field in curated._meta.fields
+                        if field.name not in ["id", "collection"]
                     }
-                    new_tags = [tag for tag in current_tags if tag != tag_to_remove]
-                    fields[field] = new_tags or None
                     fields["to_delete"] = False
-                    DeltaUrl.objects.create(collection=self.collection, **fields)
+                    fields["collection"] = self.collection
 
-        # Clear pattern relationships
+                    delta = DeltaUrl.objects.create(**fields)
+                    self._revert_tag_operation(delta)
+
+        # Clear relationships
         self.delta_urls.clear()
         self.curated_urls.clear()
 
-    class Meta(FieldModifyingPattern.Meta):
+    def _would_operation_change_tags(self, url_obj):
+        """Determine if applying the operation would change the tags."""
+        ml_tags = url_obj.tdamm_tag_ml or []
+        manual_tags = url_obj.tdamm_tag_manual or []
+
+        if self.operation == self.OperationChoices.ADD:
+            # Would only change if tag not in manual tags
+            return self.tag not in (manual_tags or [])
+
+        elif self.operation == self.OperationChoices.REMOVE:
+            # Would only change if 1) tag in manual OR 2) no manual tags and tag in ML
+            return (manual_tags and self.tag in manual_tags) or (not manual_tags and ml_tags and self.tag in ml_tags)
+
+    def _apply_tag_operation(self, url_obj):
+        """Apply the tag operation with proper ML copying logic."""
+        ml_tags = url_obj.tdamm_tag_ml or []
+        manual_tags = url_obj.tdamm_tag_manual or []
+        changed = False
+
+        if self.operation == self.OperationChoices.ADD:
+            # If manual tags don't exist but ML tags do, copy ML tags to manual
+            if not manual_tags and ml_tags:
+                manual_tags = list(ml_tags)
+                changed = True
+            elif manual_tags is None:
+                manual_tags = []
+                changed = True
+
+            # Add the tag if not already present
+            if self.tag not in manual_tags:
+                manual_tags.append(self.tag)
+                changed = True
+
+            if changed:
+                url_obj.tdamm_tag_manual = manual_tags
+                url_obj.save()
+
+        elif self.operation == self.OperationChoices.REMOVE:
+            # If manual tags exist and contain the tag, remove it
+            if manual_tags and self.tag in manual_tags:
+                manual_tags.remove(self.tag)
+                changed = True
+            # If no manual tags but ML tags contain the tag, copy ML tags (except the one to remove) to manual
+            elif not manual_tags and ml_tags and self.tag in ml_tags:
+                manual_tags = [tag for tag in ml_tags if tag != self.tag]
+                changed = True
+
+            if changed:
+                url_obj.tdamm_tag_manual = manual_tags
+                url_obj.save()
+
+    def _revert_tag_operation(self, url_obj):
+        """Revert the effects of the tag operation."""
+        ml_tags = url_obj.tdamm_tag_ml or []
+        manual_tags = url_obj.tdamm_tag_manual or []
+        changed = False
+
+        if self.operation == self.OperationChoices.ADD:
+            # If we added the tag, remove it
+            if manual_tags and self.tag in manual_tags:
+                manual_tags.remove(self.tag)
+                changed = True
+
+            if changed:
+                url_obj.tdamm_tag_manual = manual_tags
+                url_obj.save()
+
+        elif self.operation == self.OperationChoices.REMOVE:
+            # If we removed a tag, add it back if it was in ML tags
+            if ml_tags and self.tag in ml_tags:
+                if not manual_tags:
+                    manual_tags = list(ml_tags)
+                    changed = True
+                elif self.tag not in manual_tags:
+                    manual_tags.append(self.tag)
+                    changed = True
+
+            if changed:
+                url_obj.tdamm_tag_manual = manual_tags
+                url_obj.save()
+
+    class Meta(BaseMatchPattern.Meta):
         verbose_name = "Delta TDAMM Tag Pattern"
         verbose_name_plural = "Delta TDAMM Tag Patterns"
diff --git a/sde_collections/serializers.py b/sde_collections/serializers.py
index 95735a68..5157c962 100644
--- a/sde_collections/serializers.py
+++ b/sde_collections/serializers.py
@@ -7,6 +7,7 @@
     DeltaDocumentTypePattern,
     DeltaExcludePattern,
     DeltaIncludePattern,
+    DeltaTdammTagPattern,
     DeltaTitlePattern,
 )
 from .models.delta_url import CuratedUrl, DeltaUrl
@@ -379,3 +380,17 @@ def validate_match_pattern(self, value):
         except DeltaDivisionPattern.DoesNotExist:
             pass
         return value
+
+
+class TdammTagPatternSerializer(BasePatternSerializer, serializers.ModelSerializer):
+    tag_display = serializers.CharField(source="get_tag_display", read_only=True)
+    operation_display = serializers.CharField(source="get_operation_display", read_only=True)
+
+    class Meta:
+        model = DeltaTdammTagPattern
+        fields = BasePatternSerializer.Meta.fields + (
+            "tag",
+            "tag_display",
+            "operation",
+            "operation_display",
+        )
diff --git a/sde_collections/urls.py b/sde_collections/urls.py
index 9ee77759..944de2dd 100644
--- a/sde_collections/urls.py
+++ b/sde_collections/urls.py
@@ -16,6 +16,7 @@
 router.register(r"document-type-patterns", views.DocumentTypePatternViewSet)
 router.register(r"division-patterns", views.DivisionPatternViewSet)
 router.register(r"environmental-justice", EnvironmentalJusticeRowViewSet)
+router.register(r"tdamm-tag-patterns", views.TdammTagPatternViewSet)
 
 app_name = "sde_collections"
 
diff --git a/sde_collections/views.py b/sde_collections/views.py
index 7263c36b..cc147b6e 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -53,6 +53,7 @@
     DocumentTypePatternSerializer,
     ExcludePatternSerializer,
     IncludePatternSerializer,
+    TdammTagPatternSerializer,
     TitlePatternSerializer,
 )
 from .tasks import push_to_github_task
@@ -582,6 +583,14 @@ def create(self, request, *args, **kwargs):
             return Response(status=status.HTTP_400_BAD_REQUEST, data={"error": "Division is required."})
 
 
+class TdammTagPatternViewSet(CollectionFilterMixin, viewsets.ModelViewSet):
+    queryset = DeltaTdammTagPattern.objects.all()
+    serializer_class = TdammTagPatternSerializer
+
+    def get_queryset(self):
+        return super().get_queryset().order_by("match_pattern")
+
+
 class CollectionViewSet(viewsets.ModelViewSet):
     queryset = Collection.objects.all()
     serializer_class = CollectionSerializer

From 853c13b89c28966c2f00dbded9a1661f2d3ee766 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Mon, 24 Feb 2025 18:05:23 -0600
Subject: [PATCH 26/35] Added migration file

---
 ...ve_deltatdammtagpattern_source_and_more.py | 72 +++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 sde_collections/migrations/0077_remove_deltatdammtagpattern_source_and_more.py

diff --git a/sde_collections/migrations/0077_remove_deltatdammtagpattern_source_and_more.py b/sde_collections/migrations/0077_remove_deltatdammtagpattern_source_and_more.py
new file mode 100644
index 00000000..9854de2e
--- /dev/null
+++ b/sde_collections/migrations/0077_remove_deltatdammtagpattern_source_and_more.py
@@ -0,0 +1,72 @@
+# Generated by Django 4.2.9 on 2025-02-25 00:04
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("sde_collections", "0076_deltatdammtagpattern"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="deltatdammtagpattern",
+            name="source",
+        ),
+        migrations.AddField(
+            model_name="deltatdammtagpattern",
+            name="operation",
+            field=models.IntegerField(choices=[(1, "Add Tag"), (2, "Remove Tag")], default=1),
+        ),
+        migrations.AlterField(
+            model_name="deltatdammtagpattern",
+            name="tag",
+            field=models.CharField(
+                choices=[
+                    ("Not TDAMM", "Not TDAMM"),
+                    ("MMA_M_EM", "Messenger - EM Radiation"),
+                    ("MMA_M_EM_G", "Messenger - EM Radiation - Gamma rays"),
+                    ("MMA_M_EM_X", "Messenger - EM Radiation - X-rays"),
+                    ("MMA_M_EM_U", "Messenger - EM Radiation - Ultraviolet"),
+                    ("MMA_M_EM_O", "Messenger - EM Radiation - Optical"),
+                    ("MMA_M_EM_I", "Messenger - EM Radiation - Infrared"),
+                    ("MMA_M_EM_M", "Messenger - EM Radiation - Microwave"),
+                    ("MMA_M_EM_R", "Messenger - EM Radiation - Radio"),
+                    ("MMA_M_G", "Messenger - Gravitational Waves"),
+                    ("MMA_M_G_CBI", "Messenger - Gravitational Waves - Compact Binary Inspiral"),
+                    ("MMA_M_G_S", "Messenger - Gravitational Waves - Stochastic"),
+                    ("MMA_M_G_CON", "Messenger - Gravitational Waves - Continuous"),
+                    ("MMA_M_G_B", "Messenger - Gravitational Waves - Burst"),
+                    ("MMA_M_C", "Messenger - Cosmic Rays"),
+                    ("MMA_M_N", "Messenger - Neutrinos"),
+                    ("MMA_O_BI", "Objects - Binaries"),
+                    ("MMA_O_BI_BBH", "Objects - Binaries - Binary Black Holes"),
+                    ("MMA_O_BI_BNS", "Objects - Binaries - Binary Neutron Stars"),
+                    ("MMA_O_BI_C", "Objects - Binaries - Cataclysmic Variables"),
+                    ("MMA_O_BI_N", "Objects - Binaries - Neutron Star-Black Hole"),
+                    ("MMA_O_BI_B", "Objects - Binaries - Binary Pulsars"),
+                    ("MMA_O_BI_W", "Objects - Binaries - White Dwarf Binaries"),
+                    ("MMA_O_BH", "Objects - Black Holes"),
+                    ("MMA_O_BH_AGN", "Objects - Black Holes - Active Galactic Nuclei"),
+                    ("MMA_O_BH_IM", "Objects - Black Holes - Intermediate mass"),
+                    ("MMA_O_BH_STM", "Objects - Black Holes - Stellar mass"),
+                    ("MMA_O_BH_SUM", "Objects - Black Holes - Supermassive"),
+                    ("MMA_O_E", "Objects - Exoplanets"),
+                    ("MMA_O_N", "Objects - Neutron Stars"),
+                    ("MMA_O_N_M", "Objects - Neutron Stars - Magnetars"),
+                    ("MMA_O_N_P", "Objects - Neutron Stars - Pulsars"),
+                    ("MMA_O_N_PWN", "Objects - Neutron Stars - Pulsar Wind Nebula"),
+                    ("MMA_O_S", "Objects - Supernova Remnants"),
+                    ("MMA_S_F", "Signals - Fast Radio Bursts"),
+                    ("MMA_S_G", "Signals - Gamma-ray Bursts"),
+                    ("MMA_S_K", "Signals - Kilonovae"),
+                    ("MMA_S_N", "Signals - Novae"),
+                    ("MMA_S_P", "Signals - Pevatrons"),
+                    ("MMA_S_ST", "Signals - Stellar flares"),
+                    ("MMA_S_SU", "Signals - Supernovae"),
+                ],
+                max_length=255,
+            ),
+        ),
+    ]

From 4cb16b0b1236a478b4f6b923169043e2ef282dfc Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Mon, 24 Feb 2025 20:48:29 -0600
Subject: [PATCH 27/35] Patterns work with delta URL page

---
 .../0078_deltatdammtagpattern_source.py       | 18 ++++++
 sde_collections/models/delta_patterns.py      | 63 ++++++++++---------
 2 files changed, 51 insertions(+), 30 deletions(-)
 create mode 100644 sde_collections/migrations/0078_deltatdammtagpattern_source.py

diff --git a/sde_collections/migrations/0078_deltatdammtagpattern_source.py b/sde_collections/migrations/0078_deltatdammtagpattern_source.py
new file mode 100644
index 00000000..28b00b87
--- /dev/null
+++ b/sde_collections/migrations/0078_deltatdammtagpattern_source.py
@@ -0,0 +1,18 @@
+# Generated by Django 4.2.9 on 2025-02-25 02:39
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("sde_collections", "0077_remove_deltatdammtagpattern_source_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="deltatdammtagpattern",
+            name="source",
+            field=models.CharField(default="manual", max_length=10),
+        ),
+    ]
diff --git a/sde_collections/models/delta_patterns.py b/sde_collections/models/delta_patterns.py
index afb2828e..fbe61051 100644
--- a/sde_collections/models/delta_patterns.py
+++ b/sde_collections/models/delta_patterns.py
@@ -702,6 +702,7 @@ class OperationChoices(models.IntegerChoices):
 
     tag = models.CharField(max_length=255, choices=TDAMMTags.choices)
     operation = models.IntegerField(choices=OperationChoices.choices, default=OperationChoices.ADD)
+    source = models.CharField(max_length=10, default="manual")
 
     def apply(self):
         """
@@ -835,37 +836,39 @@ def _apply_tag_operation(self, url_obj):
         manual_tags = url_obj.tdamm_tag_manual or []
         changed = False
 
-        if self.operation == self.OperationChoices.ADD:
-            # If manual tags don't exist but ML tags do, copy ML tags to manual
-            if not manual_tags and ml_tags:
-                manual_tags = list(ml_tags)
-                changed = True
-            elif manual_tags is None:
-                manual_tags = []
-                changed = True
-
-            # Add the tag if not already present
-            if self.tag not in manual_tags:
-                manual_tags.append(self.tag)
-                changed = True
-
-            if changed:
-                url_obj.tdamm_tag_manual = manual_tags
-                url_obj.save()
-
-        elif self.operation == self.OperationChoices.REMOVE:
-            # If manual tags exist and contain the tag, remove it
-            if manual_tags and self.tag in manual_tags:
-                manual_tags.remove(self.tag)
-                changed = True
-            # If no manual tags but ML tags contain the tag, copy ML tags (except the one to remove) to manual
-            elif not manual_tags and ml_tags and self.tag in ml_tags:
-                manual_tags = [tag for tag in ml_tags if tag != self.tag]
-                changed = True
+        if self.operation == self.OperationChoices.ADD:  # for the add operation
+            if self.source == "ml":
+                # Copy ML tags to manual and add new tag
+                current_tags = ml_tags or []
+                new_tags = list(current_tags)
+                if self.tag not in new_tags:
+                    new_tags.append(self.tag)
+                    url_obj.tdamm_tag_manual = new_tags
+                    changed = True
+            else:  # 'manual'
+                # Add directly to manual tags
+                current_tags = manual_tags or []
+                if self.tag not in current_tags:
+                    current_tags.append(self.tag)
+                    url_obj.tdamm_tag_manual = current_tags
+                    changed = True
+        else:  # for the remove operation
+            if self.source == "ml":
+                # Copy ML tags minus the removed tag
+                if ml_tags:
+                    new_manual_tags = [t for t in ml_tags if t != self.tag]
+                    if not manual_tags or set(manual_tags) != set(new_manual_tags):
+                        url_obj.tdamm_tag_manual = new_manual_tags
+                        changed = True
+            else:  # 'manual'
+                # Remove directly from manual tags
+                if manual_tags and self.tag in manual_tags:
+                    manual_tags.remove(self.tag)
+                    url_obj.tdamm_tag_manual = manual_tags
+                    changed = True
 
-            if changed:
-                url_obj.tdamm_tag_manual = manual_tags
-                url_obj.save()
+        if changed:
+            url_obj.save()
 
     def _revert_tag_operation(self, url_obj):
         """Revert the effects of the tag operation."""

From 3fb29401a50e056110ec56c5a34c28f318a78168 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Wed, 26 Feb 2025 20:43:59 -0600
Subject: [PATCH 28/35] Tag addition and removal functional through patterns

---
 ...er_deltatdammtagpattern_unique_together.py |  17 ++
 sde_collections/models/delta_patterns.py      |   3 +
 sde_collections/serializers.py                |   1 +
 sde_collections/views.py                      | 160 +++++++++++++++---
 4 files changed, 162 insertions(+), 19 deletions(-)
 create mode 100644 sde_collections/migrations/0079_alter_deltatdammtagpattern_unique_together.py

diff --git a/sde_collections/migrations/0079_alter_deltatdammtagpattern_unique_together.py b/sde_collections/migrations/0079_alter_deltatdammtagpattern_unique_together.py
new file mode 100644
index 00000000..731b3da8
--- /dev/null
+++ b/sde_collections/migrations/0079_alter_deltatdammtagpattern_unique_together.py
@@ -0,0 +1,17 @@
+# Generated by Django 4.2.9 on 2025-02-27 02:38
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("sde_collections", "0078_deltatdammtagpattern_source"),
+    ]
+
+    operations = [
+        migrations.AlterUniqueTogether(
+            name="deltatdammtagpattern",
+            unique_together={("collection", "match_pattern", "tag", "operation", "source")},
+        ),
+    ]
diff --git a/sde_collections/models/delta_patterns.py b/sde_collections/models/delta_patterns.py
index fbe61051..7f83f0f5 100644
--- a/sde_collections/models/delta_patterns.py
+++ b/sde_collections/models/delta_patterns.py
@@ -869,6 +869,8 @@ def _apply_tag_operation(self, url_obj):
 
         if changed:
             url_obj.save()
+            if hasattr(url_obj, "_cleanup_if_needed"):
+                url_obj._cleanup_if_needed()
 
     def _revert_tag_operation(self, url_obj):
         """Revert the effects of the tag operation."""
@@ -903,3 +905,4 @@ def _revert_tag_operation(self, url_obj):
     class Meta(BaseMatchPattern.Meta):
         verbose_name = "Delta TDAMM Tag Pattern"
         verbose_name_plural = "Delta TDAMM Tag Patterns"
+        unique_together = ("collection", "match_pattern", "tag", "operation", "source")
diff --git a/sde_collections/serializers.py b/sde_collections/serializers.py
index 8fc8c222..9baed8c8 100644
--- a/sde_collections/serializers.py
+++ b/sde_collections/serializers.py
@@ -412,4 +412,5 @@ class Meta:
             "tag_display",
             "operation",
             "operation_display",
+            "source",
         )
diff --git a/sde_collections/views.py b/sde_collections/views.py
index cc147b6e..ecc2c0fb 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -330,49 +330,105 @@ def update_division(self, request, pk=None):
             return Response(status=status.HTTP_200_OK)
         return Response(status=status.HTTP_400_BAD_REQUEST, data={"error": "Division is required."})
 
+    # @action(detail=True, methods=["post"], url_path="remove_tag")
+    # def remove_tag(self, request, pk=None):
+    #     delta_url = self.get_object()
+    #     tag = request.data.get("tag")
+    #     source = request.data.get("source")
+
+    #     if not tag:
+    #         return Response({"error": "Tag not specified"}, status=400)
+
+    #     try:
+    #         # delta_url.remove_tag(tag, source)
+    #         pattern = DeltaTdammTagPattern.objects.filter(
+    #             collection=delta_url.collection, match_pattern=delta_url.url, tag=tag, source=source
+    #         ).first()
+
+    #         if pattern:
+    #             pattern.delete()
+    #         return Response({"status": "success"})
+    #     except Exception as e:
+    #         logger.error(f"Error occurred: {str(e)}")
+    #         return Response({"error": "An internal error has occurred."}, status=500)
+
     @action(detail=True, methods=["post"], url_path="remove_tag")
     def remove_tag(self, request, pk=None):
         delta_url = self.get_object()
         tag = request.data.get("tag")
-        source = request.data.get("source")
+        source = request.data.get("source", "manual")
 
         if not tag:
             return Response({"error": "Tag not specified"}, status=400)
 
         try:
-            # delta_url.remove_tag(tag, source)
-            pattern = DeltaTdammTagPattern.objects.filter(
-                collection=delta_url.collection, match_pattern=delta_url.url, tag=tag, source=source
-            ).first()
+            # Create or get a pattern for this specific URL
+            pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+                collection=delta_url.collection,
+                match_pattern=delta_url.url,
+                match_pattern_type=1,  # Individual URL
+                tag=tag,
+                operation=DeltaTdammTagPattern.OperationChoices.REMOVE,
+                source=source,
+            )
+
+            # Apply the pattern
+            pattern._apply_tag_operation(delta_url)
 
-            if pattern:
-                pattern.delete()
             return Response({"status": "success"})
         except Exception as e:
-            logger.error(f"Error occurred: {str(e)}")
+            logger.error(f"An error occurred while adding a tag to DeltaURL: {str(e)}")
             return Response({"error": "An internal error has occurred."}, status=500)
 
+    # @action(detail=True, methods=["post"], url_path="add_tag")
+    # def add_tag(self, request, pk=None):
+    #     delta_url = self.get_object()
+    #     tag = request.data.get("tag")
+    #     source = request.data.get("source")
+
+    #     if not tag:
+    #         return Response({"error": "Tag not specified"}, status=400)
+
+    #     try:
+    #         # delta_url.add_tag(tag, source)
+    #         DeltaTdammTagPattern.objects.create(
+    #             collection=delta_url.collection,
+    #             match_pattern=delta_url.url,
+    #             match_pattern_type=1,
+    #             tag=tag,
+    #             source=source,
+    #         )
+    #         return Response({"status": "success"})
+    #     except Exception as e:
+    #         logger.error("An error occurred while adding a tag to DeltaURL: %s", str(e))
+    #         return Response({"error": "An internal error has occurred."}, status=500)
+
     @action(detail=True, methods=["post"], url_path="add_tag")
     def add_tag(self, request, pk=None):
         delta_url = self.get_object()
         tag = request.data.get("tag")
-        source = request.data.get("source")
+        source = request.data.get("source", "manual")
 
         if not tag:
             return Response({"error": "Tag not specified"}, status=400)
 
         try:
-            # delta_url.add_tag(tag, source)
-            DeltaTdammTagPattern.objects.create(
+            # Create or get a pattern for this specific URL
+            pattern, created = DeltaTdammTagPattern.objects.get_or_create(
                 collection=delta_url.collection,
                 match_pattern=delta_url.url,
-                match_pattern_type=1,
+                match_pattern_type=1,  # Individual URL
                 tag=tag,
+                operation=DeltaTdammTagPattern.OperationChoices.ADD,
                 source=source,
             )
+
+            # Apply the pattern
+            pattern._apply_tag_operation(delta_url)
+
             return Response({"status": "success"})
         except Exception as e:
-            logger.error("An error occurred while adding a tag to DeltaURL: %s", str(e))
+            logger.error(f"An error occurred while adding a tag to DeltaURL: {str(e)}")
             return Response({"error": "An internal error has occurred."}, status=500)
 
 
@@ -405,36 +461,102 @@ def update_division(self, request, pk=None):
             return Response(status=status.HTTP_200_OK)
         return Response(status=status.HTTP_400_BAD_REQUEST, data={"error": "Division is required."})
 
+    # @action(detail=True, methods=["post"], url_path="add_tag")
+    # def add_tag(self, request, pk=None):
+    #     curated_url = self.get_object()
+    #     tag = request.data.get("tag")
+    #     source = request.data.get("source")
+
+    #     if not tag:
+    #         return Response({"error": "Tag not specified"}, status=400)
+
+    #     try:
+    #         curated_url.add_tag(tag, source)
+    #         return Response({"status": "success"})
+    #     except Exception as e:
+    #         logger.error("An error occurred while adding a tag to CuratedURL: %s", str(e))
+    #         return Response({"error": "An internal error has occurred."}, status=500)
+
     @action(detail=True, methods=["post"], url_path="add_tag")
     def add_tag(self, request, pk=None):
         curated_url = self.get_object()
         tag = request.data.get("tag")
-        source = request.data.get("source")
+        source = request.data.get("source", "manual")
 
         if not tag:
             return Response({"error": "Tag not specified"}, status=400)
 
         try:
-            curated_url.add_tag(tag, source)
+            # Create delta URL first
+            delta_url = curated_url._create_or_update_delta()
+
+            # Then apply operation to the delta
+            pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+                collection=curated_url.collection,
+                match_pattern=curated_url.url,
+                match_pattern_type=1,
+                tag=tag,
+                operation=DeltaTdammTagPattern.OperationChoices.ADD,
+                source=source,
+            )
+            pattern._apply_tag_operation(delta_url)
+
+            # Clean up if delta becomes identical to curated
+            if not delta_url.to_delete and delta_url._fields_match(curated_url):
+                delta_url.delete()
+
             return Response({"status": "success"})
         except Exception as e:
-            logger.error("An error occurred while adding a tag to CuratedURL: %s", str(e))
+            logger.error(f"Error occurred: {str(e)}")
             return Response({"error": "An internal error has occurred."}, status=500)
 
+    # @action(detail=True, methods=["post"], url_path="remove_tag")
+    # def remove_tag(self, request, pk=None):
+    #     curated_url = self.get_object()
+    #     tag = request.data.get("tag")
+    #     source = request.data.get("source")
+
+    #     if not tag:
+    #         return Response({"error": "Tag not specified"}, status=400)
+
+    #     try:
+    #         curated_url.remove_tag(tag, source)
+    #         return Response({"status": "success"})
+    #     except Exception as e:
+    #         logger.error("An error occurred while removing a tag from CuratedURL: %s", str(e))
+    #         return Response({"error": "An internal error has occurred."}, status=500)
+
     @action(detail=True, methods=["post"], url_path="remove_tag")
     def remove_tag(self, request, pk=None):
         curated_url = self.get_object()
         tag = request.data.get("tag")
-        source = request.data.get("source")
+        source = request.data.get("source", "manual")
 
         if not tag:
             return Response({"error": "Tag not specified"}, status=400)
 
         try:
-            curated_url.remove_tag(tag, source)
+            # Create delta URL first
+            delta_url = curated_url._create_or_update_delta()
+
+            # Then apply operation to the delta
+            pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+                collection=curated_url.collection,
+                match_pattern=curated_url.url,
+                match_pattern_type=1,
+                tag=tag,
+                operation=DeltaTdammTagPattern.OperationChoices.REMOVE,
+                source=source,
+            )
+            pattern._apply_tag_operation(delta_url)
+
+            # Clean up if delta becomes identical to curated
+            if not delta_url.to_delete and delta_url._fields_match(curated_url):
+                delta_url.delete()
+
             return Response({"status": "success"})
         except Exception as e:
-            logger.error("An error occurred while removing a tag from CuratedURL: %s", str(e))
+            logger.error(f"Error occurred: {str(e)}")
             return Response({"error": "An internal error has occurred."}, status=500)
 
 

From 1d2848bb955ea798eec34ac69924873ce0fb8343 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Thu, 6 Mar 2025 13:28:14 -0600
Subject: [PATCH 29/35] TDAMM tag patterns functional

---
 sde_collections/models/collection.py          |   6 +
 sde_collections/models/delta_patterns.py      | 200 ++++++++++----
 sde_collections/models/delta_url.py           |  19 +-
 .../static/js/delta_url_list.js               | 253 ++++++++++++++++++
 .../sde_collections/delta_urls_list.html      | 133 ++++++++-
 5 files changed, 554 insertions(+), 57 deletions(-)

diff --git a/sde_collections/models/collection.py b/sde_collections/models/collection.py
index 82811309..5b63247f 100644
--- a/sde_collections/models/collection.py
+++ b/sde_collections/models/collection.py
@@ -652,6 +652,12 @@ def apply_all_patterns(self):
         for pattern in self.deltadivisionpatterns.all():
             pattern.apply()
 
+        for pattern in self.deltatdammtagpatterns.filter(operation=1).order_by("id"):
+            pattern.apply()
+
+        for pattern in self.deltatdammtagpatterns.filter(operation=2).order_by("id"):
+            pattern.apply()
+
     def save(self, *args, **kwargs):
         # Call the function to generate the value for the generated_field based on the original_field
         if not self.config_folder:
diff --git a/sde_collections/models/delta_patterns.py b/sde_collections/models/delta_patterns.py
index 7f83f0f5..ba20e358 100644
--- a/sde_collections/models/delta_patterns.py
+++ b/sde_collections/models/delta_patterns.py
@@ -747,75 +747,163 @@ def apply(self):
             if self.is_most_distinctive_pattern(delta_url):
                 self._apply_tag_operation(delta_url)
 
+        # affected_urls = list(self.get_matching_delta_urls().values_list('url', flat=True))
+
         # Update pattern relationships
         self.update_affected_delta_urls_list()
         self.update_affected_curated_urls_list()
 
+        # for pattern_model in ['DeltaExcludePattern',
+        #                       'DeltaIncludePattern',
+        #                       'DeltaTitlePattern',
+        #                       'DeltaDocumentTypePattern',
+        #                       'DeltaDivisionPattern']:
+        #     model = ContentType.objects.get(app_label="sde_collections", model=pattern_model.lower()).model_class()
+        #     for pattern in model.objects.filter(collection=self.collection):
+        #         # Only check patterns that might apply to our URLs
+        #         for url in affected_urls:
+        #             if re.search(pattern.get_regex_pattern(), url):
+        #                 pattern.apply_to_url(url)
+
+    # def unapply(self):
+    #     """
+    #     Remove tag operation effects.
+    #     Similar to FieldModifyingPattern.unapply() but with custom tag handling.
+    #     """
+    #     DeltaUrl = apps.get_model("sde_collections", "DeltaUrl")
+    #     CuratedUrl = apps.get_model("sde_collections", "CuratedUrl")
+
+    #     # Get affected URLs
+    #     affected_deltas = list(self.delta_urls.all())
+    #     affected_curated = list(self.curated_urls.all())
+
+    #     # Get other matching patterns
+    #     other_patterns = DeltaTdammTagPattern.objects.filter(
+    #         collection=self.collection, tag=self.tag, operation=self.operation
+    #     ).exclude(id=self.id)
+
+    #     # Process each affected delta URL
+    #     for delta in affected_deltas:
+    #         curated = CuratedUrl.objects.filter(collection=self.collection, url=delta.url).first()
+
+    #         # Find next most specific pattern
+    #         matching_patterns = [p for p in other_patterns if re.search(p.get_regex_pattern(), delta.url)]
+
+    #         next_pattern = None
+    #         if matching_patterns:
+    #             next_pattern = min(matching_patterns, key=lambda p: p.get_url_match_count())
+
+    #         if next_pattern:
+    #             # Another pattern applies, no change needed
+    #             pass
+    #         else:
+    #             # Revert our changes
+    #             self._revert_tag_operation(delta)
+
+    #             delta.refresh_from_db()
+
+    #             if curated:
+    #                 print(f"Comparing - Delta: {delta.tdamm_tag_manual} vs Curated: {curated.tdamm_tag_manual}")
+    #                 print(f"Fields match: {delta._fields_match(curated)}")
+    #                 print(curated)
+    #             # Check if delta is now redundant
+    #             if curated and delta._fields_match(curated):
+    #                 print(f"DELETING delta {delta.id}")
+    #                 DeltaUrl.objects.filter(pk=delta.id).delete()
+    #                 # delta.save()
+    #             # if curated and delta._fields_match(curated):
+    #             #     print(f"ATTEMPTING TO DELETE: {delta.url}")
+    #             #     try:
+    #             #         # Check for other patterns affecting this URL
+    #             #         other_affecting_patterns = DeltaTdammTagPattern.objects.filter(
+    #             #             delta_urls__url=delta.url
+    #             #         ).exclude(id=self.id).count()
+
+    #             #         print(f"Other patterns affecting this URL: {other_affecting_patterns}")
+
+    #             #         if other_affecting_patterns == 0:
+    #             #             delta.delete()
+    #             #             print(f"DELETED: {delta.url}")
+    #             #         else:
+    #             #             print(f"NOT DELETING: URL affected by {other_affecting_patterns} other patterns")
+    #             #     except Exception as e:
+    #             #         print(f"ERROR: {str(e)}")
+
+    #     # Process curated URLs without deltas
+    #     for curated in affected_curated:
+    #         if not DeltaUrl.objects.filter(url=curated.url, collection=self.collection).exists():
+    #             # Find next most specific pattern
+    #             matching_patterns = [p for p in other_patterns if re.search(p.get_regex_pattern(), curated.url)]
+
+    #             next_pattern = None
+    #             if matching_patterns:
+    #                 next_pattern = min(matching_patterns, key=lambda p: p.get_url_match_count())
+
+    #             if not next_pattern and self._would_operation_change_tags(curated):
+    #                 # Create delta with reverted tags
+    #                 fields = {
+    #                     field.name: getattr(curated, field.name)
+    #                     for field in curated._meta.fields
+    #                     if field.name not in ["id", "collection"]
+    #                 }
+    #                 fields["to_delete"] = False
+    #                 fields["collection"] = self.collection
+
+    #                 delta = DeltaUrl.objects.create(**fields)
+    #                 self._revert_tag_operation(delta)
+
+    #     # Clear relationships
+    #     self.delta_urls.clear()
+    #     self.curated_urls.clear()
+
     def unapply(self):
-        """
-        Remove tag operation effects.
-        Similar to FieldModifyingPattern.unapply() but with custom tag handling.
-        """
+        """Remove tag operation effects with comprehensive checks."""
         DeltaUrl = apps.get_model("sde_collections", "DeltaUrl")
         CuratedUrl = apps.get_model("sde_collections", "CuratedUrl")
 
-        # Get affected URLs
-        affected_deltas = list(self.delta_urls.all())
-        affected_curated = list(self.curated_urls.all())
-
-        # Get other matching patterns
-        other_patterns = DeltaTdammTagPattern.objects.filter(
-            collection=self.collection, tag=self.tag, operation=self.operation
-        ).exclude(id=self.id)
-
-        # Process each affected delta URL
-        for delta in affected_deltas:
-            curated = CuratedUrl.objects.filter(collection=self.collection, url=delta.url).first()
-
-            # Find next most specific pattern
-            matching_patterns = [p for p in other_patterns if re.search(p.get_regex_pattern(), delta.url)]
+        # Store affected URLs
+        affected_urls = [(delta.id, delta.url) for delta in self.delta_urls.all()]
 
-            next_pattern = None
-            if matching_patterns:
-                next_pattern = min(matching_patterns, key=lambda p: p.get_url_match_count())
+        # Clear relationships
+        self.delta_urls.clear()
+        self.curated_urls.clear()
 
-            if next_pattern:
-                # Another pattern applies, no change needed
-                pass
-            else:
-                # Revert our changes
-                self._revert_tag_operation(delta)
+        # Process each affected URL
+        for delta_id, url in affected_urls:
+            try:
+                delta = DeltaUrl.objects.get(id=delta_id)
+                curated = CuratedUrl.objects.get(collection=delta.collection, url=url)
 
-                # Check if delta is now redundant
-                if curated and delta._fields_match(curated):
-                    delta.delete()
+                # Revert tags
+                if delta.tdamm_tag_manual:
+                    if self.operation == 1:  # ADD
+                        if self.tag in delta.tdamm_tag_manual:
+                            delta.tdamm_tag_manual.remove(self.tag)
+                    elif self.operation == 2:  # REMOVE
+                        if self.tag not in delta.tdamm_tag_manual and self.tag in (delta.tdamm_tag_ml or []):
+                            delta.tdamm_tag_manual = [t for t in (delta.tdamm_tag_ml or []) if t != self.tag]
 
-        # Process curated URLs without deltas
-        for curated in affected_curated:
-            if not DeltaUrl.objects.filter(url=curated.url, collection=self.collection).exists():
-                # Find next most specific pattern
-                matching_patterns = [p for p in other_patterns if re.search(p.get_regex_pattern(), curated.url)]
+                    if not delta.tdamm_tag_manual:
+                        delta.tdamm_tag_manual = None
 
-                next_pattern = None
-                if matching_patterns:
-                    next_pattern = min(matching_patterns, key=lambda p: p.get_url_match_count())
+                    delta.save()
 
-                if not next_pattern and self._would_operation_change_tags(curated):
-                    # Create delta with reverted tags
-                    fields = {
-                        field.name: getattr(curated, field.name)
-                        for field in curated._meta.fields
-                        if field.name not in ["id", "collection"]
-                    }
-                    fields["to_delete"] = False
-                    fields["collection"] = self.collection
+                # Check ALL pattern types that might affect this URL
+                other_patterns_exist = (
+                    DeltaExcludePattern.objects.filter(delta_urls=delta).exists()
+                    or DeltaIncludePattern.objects.filter(delta_urls=delta).exists()
+                    or DeltaTitlePattern.objects.filter(delta_urls=delta).exists()
+                    or DeltaDocumentTypePattern.objects.filter(delta_urls=delta).exists()
+                    or DeltaDivisionPattern.objects.filter(delta_urls=delta).exists()
+                    or DeltaTdammTagPattern.objects.filter(delta_urls=delta).exists()
+                )
 
-                    delta = DeltaUrl.objects.create(**fields)
-                    self._revert_tag_operation(delta)
+                # Only delete if no other patterns affect it AND it matches curated
+                if not other_patterns_exist and delta._fields_match(curated) and not delta.to_delete:
+                    DeltaUrl.objects.filter(id=delta_id).delete()
 
-        # Clear relationships
-        self.delta_urls.clear()
-        self.curated_urls.clear()
+            except (DeltaUrl.DoesNotExist, CuratedUrl.DoesNotExist):
+                continue
 
     def _would_operation_change_tags(self, url_obj):
         """Determine if applying the operation would change the tags."""
@@ -899,9 +987,15 @@ def _revert_tag_operation(self, url_obj):
                     changed = True
 
             if changed:
+                if not manual_tags:
+                    manual_tags = None
                 url_obj.tdamm_tag_manual = manual_tags
                 url_obj.save()
 
+                if hasattr(url_obj, "_cleanup_if_needed"):
+                    url_obj._cleanup_if_needed()
+        print(f"Delta URL {url_obj.url} - ML tags: {url_obj.tdamm_tag_ml}, Manual tags: {url_obj.tdamm_tag_manual}")
+
     class Meta(BaseMatchPattern.Meta):
         verbose_name = "Delta TDAMM Tag Pattern"
         verbose_name_plural = "Delta TDAMM Tag Patterns"
diff --git a/sde_collections/models/delta_url.py b/sde_collections/models/delta_url.py
index 9583fb26..b58e9927 100644
--- a/sde_collections/models/delta_url.py
+++ b/sde_collections/models/delta_url.py
@@ -156,10 +156,23 @@ def _fields_match(self, other):
             "visited",
             "document_type",
             "division",
-            "tdamm_tag_manual",
-            "tdamm_tag_ml",
         ]
-        return all(getattr(self, field) == getattr(other, field) for field in fields_to_compare)
+
+        # Regular field comparison
+        basic_match = all(getattr(self, field) == getattr(other, field) for field in fields_to_compare)
+
+        # Special handling for tag fields - treat [] and None as equivalent
+        def tags_equivalent(a, b):
+            if not a and not b:  # Both are empty (None or [])
+                return True
+            return a == b
+
+        # Compare tag fields with special handling
+        tags_match = tags_equivalent(self.tdamm_tag_manual, other.tdamm_tag_manual) and tags_equivalent(
+            self.tdamm_tag_ml, other.tdamm_tag_ml
+        )
+
+        return basic_match and tags_match
 
     def add_tag(self, tag: str, source: str) -> None:
         """Add a tag and handle cleanup if needed."""
diff --git a/sde_indexing_helper/static/js/delta_url_list.js b/sde_indexing_helper/static/js/delta_url_list.js
index 7e8ed08a..46c562c0 100644
--- a/sde_indexing_helper/static/js/delta_url_list.js
+++ b/sde_indexing_helper/static/js/delta_url_list.js
@@ -9,6 +9,7 @@ var newExcludePatternsCount = 0;
 var newTitlePatternsCount = 0;
 var newDocumentTypePatternsCount = 0;
 var newDivisionPatternsCount = 0;
+var newTdammTagPatternsCount = 0;
 var currentTab = ""; //blank for the first tab
 var matchPatternTypeMap = {
   "Individual URL Pattern": 1,
@@ -967,6 +968,244 @@ $("#deltaDivisionMatchPatternFilter").on("beforeinput", function (val) {
   division_patterns_table.columns(0).search(this.value).draw();
 });
 
+var tdamm_tag_patterns_table = $("#tdamm_tag_patterns_table").DataTable({
+  dom: "lBrtip",
+  buttons: [
+      {
+          text: "Add Pattern",
+          className: "addPattern",
+          action: function () {
+              $modal = $("#tdammTagPatternModal").modal();
+          }
+      },
+      {
+          text: "Customize Columns",
+          className: "customizeColumns",
+          action: function () {
+              modalContents("#tdamm_tag_patterns_table");
+          }
+      },
+  ],
+  lengthMenu: [
+      [25, 50, 100, 500],
+      ["Show 25", "Show 50", "Show 100", "Show 500"],
+  ],
+  orderCellsTop: true,
+  pageLength: 100,
+  ajax: `/api/tdamm-tag-patterns/?format=datatables&collection_id=${collection_id}`,
+  initComplete: function (data) {
+      this.api()
+          .columns()
+          .every(function (index) {
+              var table = $("#tdamm_tag_patterns_table").DataTable();
+
+              let addDropdownSelect = {
+                  1: {
+                      columnToSearch: 9,
+                      matchPattern: {
+                          "Individual URL Pattern": 1,
+                          "Multi-URL Pattern": 2,
+                      }
+                  },
+                  2: {
+                      columnToSearch: 10,
+                      matchPattern: {}
+                  },
+                  3: {
+                      columnToSearch: 11,
+                      matchPattern: {
+                          "Add Tag": 1,
+                          "Remove Tag": 2
+                      }
+                  },
+                  // 4: {
+                  //     columnToSearch: 12,
+                  //     matchPattern: {
+                  //         "manual": "manual",
+                  //         "ml": "ml"
+                  //     }
+                  // }
+              };
+
+              // Populate TDAMM tag mappings
+              tdamm_choices.forEach(choice => {
+                  addDropdownSelect[2].matchPattern[choice.display] = choice.code;
+              });
+
+              let column = this;
+              if (column.data().length === 0) {
+                  $(`#tdamm-patterns-dropdown-${index}`).prop("disabled", true);
+              } else if (index in addDropdownSelect) {
+                  $("#tdamm-patterns-dropdown-" + index).on("change", function () {
+                      let col = addDropdownSelect[index].columnToSearch;
+                      let searchInput = addDropdownSelect[index].matchPattern[$(this).val()];
+                      if ($(this).val() === "" || $(this).val() === undefined)
+                          table.columns(col).search("").draw();
+                      else {
+                          table.columns(col).search(searchInput).draw();
+                      }
+                  });
+              }
+          });
+  },
+
+  columns: [
+      { data: "match_pattern", class: "whiteText" },
+      {
+          data: "match_pattern_type_display",
+          class: "text-center whiteText",
+          sortable: false,
+      },
+      {
+          data: "tag_display",
+          class: "whiteText"
+      },
+      {
+          data: "operation_display",
+          class: "whiteText"
+      },
+      // {
+      //     data: "source",
+      //     class: "whiteText"
+      // },
+      {
+          data: "delta_urls_count",
+          class: "text-center whiteText",
+          sortable: true,
+      },
+      {
+          data: "curated_urls_count",
+          class: "text-center whiteText",
+          sortable: true,
+      },
+      {
+          data: null,
+          sortable: false,
+          class: "text-center",
+          render: function (data, type, row) {
+              return `<button class="btn btn-danger btn-sm delete-tdamm-tag-pattern-button" data-row-id="${row["id"]}"><i class="material-icons">delete</i></button >`;
+          },
+      },
+      { data: "id", visible: false, searchable: false },
+      { data: "match_pattern_type", visible: false },
+      { data: "tag", visible: false },
+      { data: "operation", visible: false },
+      // { data: "source", visible: false },
+  ],
+});
+
+$("#tdammTagMatchPatternFilter").on("beforeinput", function (val) {
+  tdamm_tag_patterns_table.columns(0).search(this.value).draw();
+});
+
+// Handle form submission for TDAMM tag pattern
+$("#tdamm_tag_pattern_form").on("submit", function (e) {
+  e.preventDefault();
+  inputs = {};
+  input_serialized = $(this).serializeArray();
+  input_serialized.forEach((field) => {
+      inputs[field.name] = field.value;
+  });
+
+  postTdammTagPattern(
+      inputs.match_pattern,
+      inputs.match_pattern_type,
+      inputs.tdamm_tag,
+      inputs.tdamm_operation,
+      // inputs.tdamm_source
+      "manual"
+  );
+
+  // Close the modal
+  $("#tdammTagPatternModal").modal("hide");
+});
+
+// Handle TDAMM tag form dropdown selections
+$(".tdamm_tag_form_select").on("click", function (e) {
+  e.preventDefault();
+  $('input[name="tdamm_tag"]').val($(this).attr("value"));
+  $(".tdamm-tag-dropdown").text($(this).text());
+});
+
+$(".tdamm_operation_form_select").on("click", function (e) {
+  e.preventDefault();
+  $('input[name="tdamm_operation"]').val($(this).attr("value"));
+  $(".operation-dropdown").text($(this).text());
+});
+
+// $(".tdamm_source_form_select").on("click", function (e) {
+//   e.preventDefault();
+//   $('input[name="tdamm_source"]').val($(this).attr("value"));
+//   $(".source-dropdown").text($(this).text());
+// });
+
+// Handle delete button click for TDAMM tag patterns
+function handleDeleteTdammTagPatternButtonClick() {
+  $("body").on("click", ".delete-tdamm-tag-pattern-button", function () {
+      var patternRowId = $(this).data("row-id");
+      currentURLtoDelete = `/api/tdamm-tag-patterns/${patternRowId}/`;
+      deletePattern(
+          `/api/tdamm-tag-patterns/${patternRowId}/`,
+          "TDAMM Tag Pattern"
+      );
+  });
+}
+
+function postTdammTagPattern(match_pattern, match_pattern_type, tag, operation, source="manual") {
+  if (!match_pattern) {
+      toastr.error("Please provide a match pattern.");
+      return;
+  }
+
+  if (!tag) {
+      toastr.error("Please select a TDAMM tag.");
+      return;
+  }
+
+  if (!operation) {
+      toastr.error("Please select an operation (Add or Remove).");
+      return;
+  }
+
+  if (!source) {
+      toastr.error("Please select a source (Manual or ML).");
+      return;
+  }
+
+  $.ajax({
+      url: "/api/tdamm-tag-patterns/",
+      type: "POST",
+      data: {
+          collection: collection_id,
+          match_pattern: match_pattern,
+          match_pattern_type: match_pattern_type,
+          tag: tag,
+          operation: operation,
+          source: source,
+          csrfmiddlewaretoken: csrftoken,
+      },
+      success: function (data) {
+          $("#delta_urls_table").DataTable().ajax.reload(null, false);
+          $("#tdamm_tag_patterns_table").DataTable().ajax.reload(null, false);
+          if (currentTab === "") { // Only add a notification if we are on the first tab
+              newTdammTagPatternsCount = newTdammTagPatternsCount + 1;
+              $("#tdammTagPatternsTab").html(
+                  `TDAMM Tag Patterns <span class="pill notifyBadge badge badge-pill badge-primary">` +
+                  newTdammTagPatternsCount + " new" +
+                  `</span>`
+              );
+          }
+      },
+      error: function (xhr, status, error) {
+          var errorMessage = xhr.responseText;
+          if (errorMessage.includes("unique")) {
+              toastr.success("Pattern already exists");
+              return;
+          }
+          toastr.error(errorMessage);
+      },
+  });
+}
 
 function handleTabsClick() {
   $("#includePatternsTab").on("click", function () {
@@ -989,6 +1228,10 @@ function handleTabsClick() {
     newDivisionPatternsCount = 0;
     $("#divisionPatternsTab").html(`Division Patterns`);
   });
+  $("#tdammTagPatternsTab").on("click", function () {
+    newTdammTagPatternsCount = 0;
+    $("#tdammTagPatternsTab").html(`TDAMM Tag Patterns`);
+  });
 }
 
 function setupClickHandlers() {
@@ -1001,6 +1244,7 @@ function setupClickHandlers() {
   handleDeleteIncludePatternButtonClick();
   handleDeleteTitlePatternButtonClick();
   handleDeleteDivisionButtonClick();
+  handleDeleteTdammTagPatternButtonClick();
 
   handleDocumentTypeSelect();
   handleDivisionSelect();
@@ -1440,6 +1684,7 @@ function handleHideorShowKeypress() {
   addEnterEscapeKeypress("#titlePatternModal", "#title_pattern_form");
   addEnterEscapeKeypress("#documentTypePatternModal", "#document_type_pattern_form");
   addEnterEscapeKeypress("#divisionPatternModal", "#division_pattern_form");
+  addEnterEscapeKeypress("#tdammTagPatternModal", "#tdamm_tag_pattern_form");
 
 }
 
@@ -2016,6 +2261,11 @@ function division_pattern_form(selected_text) {
   $modal.find("#division_match_pattern_input").val(selected_text); // Updated to match the HTML ID
 }
 
+function tdamm_tag_pattern_form(selected_text) {
+  $modal = $("#tdammTagPatternModal").modal();
+  $modal.find("#tdamm_match_pattern_input").val(selected_text);
+}
+
 // If the menu element is clicked
 $(".custom-menu li").click(function () {
   // This is the triggered action name
@@ -2035,6 +2285,9 @@ $(".custom-menu li").click(function () {
     case "division-pattern":
       division_pattern_form(selected_text.trim());
       break;
+    case "tdamm-tag-pattern":
+      tdamm_tag_pattern_form(selected_text.trim());
+      break;
   }
 
   // Hide it AFTER the action was triggered
diff --git a/sde_indexing_helper/templates/sde_collections/delta_urls_list.html b/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
index adfbacb0..49a396c0 100644
--- a/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
+++ b/sde_indexing_helper/templates/sde_collections/delta_urls_list.html
@@ -98,6 +98,9 @@ <h3 class="whiteText deltaTitle">
             <a class="tab-nav tabStyle" id="divisionPatternsTab" data-toggle="tab" href="#Division-Patterns">Division Patterns</a>
         </li>
         {% endif %}
+        <li class="nav-item">
+            <a class="tab-nav tabStyle" id="tdammTagPatternsTab" data-toggle="tab" href="#TDAMM-Tag-Patterns">TDAMM Tag Patterns</a>
+        </li>
     </ul>
 
     <!-- Tab panes -->
@@ -426,6 +429,50 @@ <h3 class="whiteText deltaTitle">
                 </thead>
             </table>
         </div>
+        <div class="tab-pane fade" id="TDAMM-Tag-Patterns">
+            <table class="table" id="tdamm_tag_patterns_table" style="width:100%">
+                <thead class="tableHeader">
+                    <tr>
+                        <th scope="col" class="text-center col-1"><strong>Match Pattern</strong></th>
+                        <th scope="col" class="text-center col-1"><strong>Match Pattern Type</strong></th>
+                        <th scope="col" class="text-center col-1"><strong>Tag</strong></th>
+                        <th scope="col" class="text-center col-1"><strong>Operation</strong></th>
+                        <!-- <th scope="col" class="text-center col-1"><strong>Source</strong></th> -->
+                        <th scope="col" class="text-center col-1"><strong>Affected Delta URLs</strong></th>
+                        <th scope="col" class="text-center col-1"><strong>Affected Curated URLs</strong></th>
+                        <th scope="col" class="text-center col-1"><strong>Actions</strong></th>
+                        <th scope="col" class="text-center col-1"><strong>ID</strong></th>
+                    </tr>
+                    <tr>
+                        <td><input type="text" class="table_filter_row_input textBoxStyling" id="tdammTagMatchPatternFilter" placeholder="Match Pattern" /></td>
+                        <td><select id="tdamm-patterns-dropdown-1" class="select-dropdown selectStyling">
+                            <option value="">SELECT</option>
+                            <option value="Individual URL Pattern">Individual URL Pattern</option>
+                            <option value="Multi-URL Pattern">Multi-URL Pattern</option>
+                        </select></td>
+                        <td><select id="tdamm-patterns-dropdown-2" class="select-dropdown selectStyling">
+                            <option value="">SELECT</option>
+                            {% for choice in tdamm_choices %}
+                            <option value="{{ choice.code }}">{{ choice.display }}</option>
+                            {% endfor %}
+                        </select></td>
+                        <td><select id="tdamm-patterns-dropdown-3" class="select-dropdown selectStyling">
+                            <option value="">SELECT</option>
+                            <option value="Add Tag">Add Tag</option>
+                            <option value="Remove Tag">Remove Tag</option>
+                        </select></td>
+                        <!-- <td><select id="tdamm-patterns-dropdown-4" class="select-dropdown selectStyling">
+                            <option value="">SELECT</option>
+                            <option value="manual">Manual</option>
+                            <option value="ml">ML</option>
+                        </select></td> -->
+                        <td></td>
+                        <td></td>
+                        <td></td>
+                    </tr>
+                </thead>
+            </table>
+        </div>
 
     </div>
 </div>
@@ -440,6 +487,7 @@ <h3 class="whiteText deltaTitle">
     <li data-action="title-pattern" class="list-group-item">Create Title Pattern</li>
     <li data-action="document-type-pattern" class="list-group-item">Create Document Type Pattern</li>
     <li data-action="division-pattern" class="list-group-item">Create Division Pattern</li>
+    <li data-action="tdamm-tag-pattern" class="list-group-item">Create TDAMM Tag Pattern</li>
 </ul>
 <div class="modal fade" id="excludePatternModal" data-backdrop="static" data-keyboard="false" tabindex="-1"
     aria-labelledby="excludePatternModalLabel" aria-hidden="true">
@@ -684,7 +732,90 @@ <h5 class="modal-title" id="divisionPatternModalLabel">Division Pattern Form</h5
         </div>
     </div>
 </div>
-
+<div class="modal fade" id="tdammTagPatternModal" data-backdrop="static" data-keyboard="false" tabindex="-1"
+    aria-labelledby="tdammTagPatternModalLabel" aria-hidden="true">
+    <div class="modal-dialog">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h5 class="modal-title" id="tdammTagPatternModalLabel">TDAMM Tag Pattern Form</h5>
+                <button type="button" class="close modal-close" data-dismiss="modal" aria-label="Close">
+                    <span aria-hidden="true">&times;</span>
+                </button>
+            </div>
+            <form id="tdamm_tag_pattern_form">
+                <div class="modal-body">
+                    <div class="form-group">
+                        <label for="tdamm_match_pattern_input" class="form-label">Match Pattern <div class="asterik">*</div></label>
+                        <input type="text" class="form-control" id="tdamm_match_pattern_input" required name="match_pattern">
+                    </div>
+                    <div class="form-group">
+                        <label for="tdamm_tag_select" class="form-label">TDAMM Tag <div class="asterik">*</div></label>
+                        <div class="input-group">
+                            <input type="hidden" name="tdamm_tag" class="form-control" id="tdamm_tag_input_field" required>
+                            <div class="input-group-append tdamm-tag-dropdown-input">
+                                <button class="btn btn-secondary btn-block dropdown-toggle tdamm-tag-dropdown" type="button"
+                                    data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">Select TDAMM Tag</button>
+                                <div class="tdamm-tag-form dropdown-menu">
+                                    {% for choice in tdamm_choices %}
+                                    <a class="dropdown-item tdamm_tag_form_select" value="{{ choice.code }}">{{ choice.display }}</a>
+                                    {% endfor %}
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="form-group">
+                        <label for="tdamm_operation_select" class="form-label">Operation <div class="asterik">*</div></label>
+                        <div class="input-group">
+                            <input type="hidden" name="tdamm_operation" class="form-control" id="tdamm_operation_input_field" required>
+                            <div class="input-group-append tdamm-operation-dropdown-input">
+                                <button class="btn btn-secondary btn-block dropdown-toggle operation-dropdown" type="button"
+                                    data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">Select Operation</button>
+                                <div class="tdamm-operation-form dropdown-menu">
+                                    <a class="dropdown-item tdamm_operation_form_select" value="1">Add Tag</a>
+                                    <a class="dropdown-item tdamm_operation_form_select" value="2">Remove Tag</a>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                    <!-- <div class="form-group">
+                        <label for="tdamm_source_select" class="form-label">Source <div class="asterik">*</div></label>
+                        <div class="input-group">
+                            <input type="hidden" name="tdamm_source" class="form-control" id="tdamm_source_input_field" required>
+                            <div class="input-group-append tdamm-source-dropdown-input">
+                                <button class="btn btn-secondary btn-block dropdown-toggle source-dropdown" type="button"
+                                    data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">Select Source</button>
+                                <div class="tdamm-source-form dropdown-menu">
+                                    <a class="dropdown-item tdamm_source_form_select" value="manual">Manual</a>
+                                    <a class="dropdown-item tdamm_source_form_select" value="ml">ML</a>
+                                </div>
+                            </div>
+                        </div>
+                    </div> -->
+                    <div class="form-group pattern-form-group">
+                        <label for="pattern_type_input" class="form-label">Pattern Type<div class="asterik">*</div></label>
+                        <div class="input-group">
+                            <input type="hidden" name="match_pattern_type" class="form-control" id="pattern_type_input" required>
+                            <div class="input-group-append pattern-dropdown-input">
+                                <button class="btn btn-secondary btn-block dropdown-toggle pattern-dropdown" type="button"
+                                    data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">Select Pattern Type</button>
+                                <div class="pattern-type-form dropdown-menu">
+                                    <a class="dropdown-item pattern_type_form_select" value="1">Individual URL Pattern</a>
+                                    <a class="dropdown-item pattern_type_form_select" value="2">Multi-URL Pattern</a>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                <div class="modal-footer">
+                    <div class="button-wrapper">
+                        <button type="button" class="btn btn-secondary modal-button-1" data-dismiss="modal">Close</button>
+                        <button type="submit" class="btn btn-primary modal-button-2">Submit</button>
+                    </div>
+                </div>
+            </form>
+        </div>
+    </div>
+</div>
 
 <div id="hideShowColumnsModal" class="modal pr-4 pl-4 pt-4 customizeColumnContainer">
     <div class="modalDialog">

From c6b982cdf227960673ef07aeb1a16d5ab2c75e37 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Mon, 10 Mar 2025 15:20:06 -0500
Subject: [PATCH 30/35] Updated pattern model for multiple tags

---
 .../models/collection_choice_fields.py        |  7 ++++++
 sde_collections/models/delta_patterns.py      | 22 +++++++++++++------
 2 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/sde_collections/models/collection_choice_fields.py b/sde_collections/models/collection_choice_fields.py
index c907d08b..5358a608 100644
--- a/sde_collections/models/collection_choice_fields.py
+++ b/sde_collections/models/collection_choice_fields.py
@@ -169,3 +169,10 @@ def lookup_by_text(cls, text: str) -> str | None:
             if choice[1].lower() == text.lower():
                 return choice[0]
         return None
+
+
+class OperationChoices(models.IntegerChoices):
+    """Operation choices for the TDAMM tag pattern model."""
+
+    ADD = 1, "Add Tag"
+    REMOVE = 2, "Remove Tag"
diff --git a/sde_collections/models/delta_patterns.py b/sde_collections/models/delta_patterns.py
index ba20e358..d2cedbe1 100644
--- a/sde_collections/models/delta_patterns.py
+++ b/sde_collections/models/delta_patterns.py
@@ -2,6 +2,7 @@
 from typing import Any
 
 from django.apps import apps
+from django.contrib.postgres.fields import ArrayField
 from django.core.exceptions import ValidationError
 from django.db import models
 
@@ -11,7 +12,12 @@
     resolve_title,
     validate_fstring,
 )
-from .collection_choice_fields import Divisions, DocumentTypes, TDAMMTags
+from .collection_choice_fields import (
+    Divisions,
+    DocumentTypes,
+    OperationChoices,
+    TDAMMTags,
+)
 
 
 class BaseMatchPattern(models.Model):
@@ -696,11 +702,13 @@ class DeltaResolvedTitleError(DeltaResolvedTitleBase):
 class DeltaTdammTagPattern(BaseMatchPattern):
     """Pattern for adding or removing TDAMM tags."""
 
-    class OperationChoices(models.IntegerChoices):
-        ADD = 1, "Add Tag"
-        REMOVE = 2, "Remove Tag"
-
-    tag = models.CharField(max_length=255, choices=TDAMMTags.choices)
+    # tag = models.CharField(max_length=255, choices=TDAMMTags.choices)
+    tags = ArrayField(
+        models.CharField(max_length=255, choices=TDAMMTags.choices),
+        blank=True,
+        null=True,
+        help_text="List of tags to add or remove",
+    )
     operation = models.IntegerField(choices=OperationChoices.choices, default=OperationChoices.ADD)
     source = models.CharField(max_length=10, default="manual")
 
@@ -999,4 +1007,4 @@ def _revert_tag_operation(self, url_obj):
     class Meta(BaseMatchPattern.Meta):
         verbose_name = "Delta TDAMM Tag Pattern"
         verbose_name_plural = "Delta TDAMM Tag Patterns"
-        unique_together = ("collection", "match_pattern", "tag", "operation", "source")
+        unique_together = ("collection", "match_pattern", "operation", "source")

From 6274acbc4c1cb314da2c4f4f56d20f2c96bea0bb Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanur.sharma@leftrightmind.com>
Date: Tue, 11 Mar 2025 10:51:05 -0500
Subject: [PATCH 31/35] Updating logic for tags list - wip

---
 ...dammtagpattern_unique_together_and_more.py |  78 ++++++
 .../0081_alter_deltatdammtagpattern_tags.py   |  71 +++++
 sde_collections/models/delta_patterns.py      | 265 +++++++++---------
 sde_collections/serializers.py                |  18 +-
 sde_collections/views.py                      | 222 +++++++++++++--
 .../static/js/delta_url_list.js               | 143 ++++++----
 6 files changed, 598 insertions(+), 199 deletions(-)
 create mode 100644 sde_collections/migrations/0080_alter_deltatdammtagpattern_unique_together_and_more.py
 create mode 100644 sde_collections/migrations/0081_alter_deltatdammtagpattern_tags.py

diff --git a/sde_collections/migrations/0080_alter_deltatdammtagpattern_unique_together_and_more.py b/sde_collections/migrations/0080_alter_deltatdammtagpattern_unique_together_and_more.py
new file mode 100644
index 00000000..2f9040ca
--- /dev/null
+++ b/sde_collections/migrations/0080_alter_deltatdammtagpattern_unique_together_and_more.py
@@ -0,0 +1,78 @@
+# Generated by Django 4.2.9 on 2025-03-10 21:59
+
+import django.contrib.postgres.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("sde_collections", "0079_alter_deltatdammtagpattern_unique_together"),
+    ]
+
+    operations = [
+        migrations.AlterUniqueTogether(
+            name="deltatdammtagpattern",
+            unique_together={("collection", "match_pattern", "operation", "source")},
+        ),
+        migrations.AddField(
+            model_name="deltatdammtagpattern",
+            name="tags",
+            field=django.contrib.postgres.fields.ArrayField(
+                base_field=models.CharField(
+                    choices=[
+                        ("Not TDAMM", "Not TDAMM"),
+                        ("MMA_M_EM", "Messenger - EM Radiation"),
+                        ("MMA_M_EM_G", "Messenger - EM Radiation - Gamma rays"),
+                        ("MMA_M_EM_X", "Messenger - EM Radiation - X-rays"),
+                        ("MMA_M_EM_U", "Messenger - EM Radiation - Ultraviolet"),
+                        ("MMA_M_EM_O", "Messenger - EM Radiation - Optical"),
+                        ("MMA_M_EM_I", "Messenger - EM Radiation - Infrared"),
+                        ("MMA_M_EM_M", "Messenger - EM Radiation - Microwave"),
+                        ("MMA_M_EM_R", "Messenger - EM Radiation - Radio"),
+                        ("MMA_M_G", "Messenger - Gravitational Waves"),
+                        ("MMA_M_G_CBI", "Messenger - Gravitational Waves - Compact Binary Inspiral"),
+                        ("MMA_M_G_S", "Messenger - Gravitational Waves - Stochastic"),
+                        ("MMA_M_G_CON", "Messenger - Gravitational Waves - Continuous"),
+                        ("MMA_M_G_B", "Messenger - Gravitational Waves - Burst"),
+                        ("MMA_M_C", "Messenger - Cosmic Rays"),
+                        ("MMA_M_N", "Messenger - Neutrinos"),
+                        ("MMA_O_BI", "Objects - Binaries"),
+                        ("MMA_O_BI_BBH", "Objects - Binaries - Binary Black Holes"),
+                        ("MMA_O_BI_BNS", "Objects - Binaries - Binary Neutron Stars"),
+                        ("MMA_O_BI_C", "Objects - Binaries - Cataclysmic Variables"),
+                        ("MMA_O_BI_N", "Objects - Binaries - Neutron Star-Black Hole"),
+                        ("MMA_O_BI_B", "Objects - Binaries - Binary Pulsars"),
+                        ("MMA_O_BI_W", "Objects - Binaries - White Dwarf Binaries"),
+                        ("MMA_O_BH", "Objects - Black Holes"),
+                        ("MMA_O_BH_AGN", "Objects - Black Holes - Active Galactic Nuclei"),
+                        ("MMA_O_BH_IM", "Objects - Black Holes - Intermediate mass"),
+                        ("MMA_O_BH_STM", "Objects - Black Holes - Stellar mass"),
+                        ("MMA_O_BH_SUM", "Objects - Black Holes - Supermassive"),
+                        ("MMA_O_E", "Objects - Exoplanets"),
+                        ("MMA_O_N", "Objects - Neutron Stars"),
+                        ("MMA_O_N_M", "Objects - Neutron Stars - Magnetars"),
+                        ("MMA_O_N_P", "Objects - Neutron Stars - Pulsars"),
+                        ("MMA_O_N_PWN", "Objects - Neutron Stars - Pulsar Wind Nebula"),
+                        ("MMA_O_S", "Objects - Supernova Remnants"),
+                        ("MMA_S_F", "Signals - Fast Radio Bursts"),
+                        ("MMA_S_G", "Signals - Gamma-ray Bursts"),
+                        ("MMA_S_K", "Signals - Kilonovae"),
+                        ("MMA_S_N", "Signals - Novae"),
+                        ("MMA_S_P", "Signals - Pevatrons"),
+                        ("MMA_S_ST", "Signals - Stellar flares"),
+                        ("MMA_S_SU", "Signals - Supernovae"),
+                    ],
+                    max_length=255,
+                ),
+                blank=True,
+                help_text="List of tags to add or remove",
+                null=True,
+                size=None,
+            ),
+        ),
+        migrations.RemoveField(
+            model_name="deltatdammtagpattern",
+            name="tag",
+        ),
+    ]
diff --git a/sde_collections/migrations/0081_alter_deltatdammtagpattern_tags.py b/sde_collections/migrations/0081_alter_deltatdammtagpattern_tags.py
new file mode 100644
index 00000000..5ea14e62
--- /dev/null
+++ b/sde_collections/migrations/0081_alter_deltatdammtagpattern_tags.py
@@ -0,0 +1,71 @@
+# Generated by Django 4.2.9 on 2025-03-10 23:56
+
+import django.contrib.postgres.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("sde_collections", "0080_alter_deltatdammtagpattern_unique_together_and_more"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="deltatdammtagpattern",
+            name="tags",
+            field=django.contrib.postgres.fields.ArrayField(
+                base_field=models.CharField(
+                    choices=[
+                        ("Not TDAMM", "Not TDAMM"),
+                        ("MMA_M_EM", "Messenger - EM Radiation"),
+                        ("MMA_M_EM_G", "Messenger - EM Radiation - Gamma rays"),
+                        ("MMA_M_EM_X", "Messenger - EM Radiation - X-rays"),
+                        ("MMA_M_EM_U", "Messenger - EM Radiation - Ultraviolet"),
+                        ("MMA_M_EM_O", "Messenger - EM Radiation - Optical"),
+                        ("MMA_M_EM_I", "Messenger - EM Radiation - Infrared"),
+                        ("MMA_M_EM_M", "Messenger - EM Radiation - Microwave"),
+                        ("MMA_M_EM_R", "Messenger - EM Radiation - Radio"),
+                        ("MMA_M_G", "Messenger - Gravitational Waves"),
+                        ("MMA_M_G_CBI", "Messenger - Gravitational Waves - Compact Binary Inspiral"),
+                        ("MMA_M_G_S", "Messenger - Gravitational Waves - Stochastic"),
+                        ("MMA_M_G_CON", "Messenger - Gravitational Waves - Continuous"),
+                        ("MMA_M_G_B", "Messenger - Gravitational Waves - Burst"),
+                        ("MMA_M_C", "Messenger - Cosmic Rays"),
+                        ("MMA_M_N", "Messenger - Neutrinos"),
+                        ("MMA_O_BI", "Objects - Binaries"),
+                        ("MMA_O_BI_BBH", "Objects - Binaries - Binary Black Holes"),
+                        ("MMA_O_BI_BNS", "Objects - Binaries - Binary Neutron Stars"),
+                        ("MMA_O_BI_C", "Objects - Binaries - Cataclysmic Variables"),
+                        ("MMA_O_BI_N", "Objects - Binaries - Neutron Star-Black Hole"),
+                        ("MMA_O_BI_B", "Objects - Binaries - Binary Pulsars"),
+                        ("MMA_O_BI_W", "Objects - Binaries - White Dwarf Binaries"),
+                        ("MMA_O_BH", "Objects - Black Holes"),
+                        ("MMA_O_BH_AGN", "Objects - Black Holes - Active Galactic Nuclei"),
+                        ("MMA_O_BH_IM", "Objects - Black Holes - Intermediate mass"),
+                        ("MMA_O_BH_STM", "Objects - Black Holes - Stellar mass"),
+                        ("MMA_O_BH_SUM", "Objects - Black Holes - Supermassive"),
+                        ("MMA_O_E", "Objects - Exoplanets"),
+                        ("MMA_O_N", "Objects - Neutron Stars"),
+                        ("MMA_O_N_M", "Objects - Neutron Stars - Magnetars"),
+                        ("MMA_O_N_P", "Objects - Neutron Stars - Pulsars"),
+                        ("MMA_O_N_PWN", "Objects - Neutron Stars - Pulsar Wind Nebula"),
+                        ("MMA_O_S", "Objects - Supernova Remnants"),
+                        ("MMA_S_F", "Signals - Fast Radio Bursts"),
+                        ("MMA_S_G", "Signals - Gamma-ray Bursts"),
+                        ("MMA_S_K", "Signals - Kilonovae"),
+                        ("MMA_S_N", "Signals - Novae"),
+                        ("MMA_S_P", "Signals - Pevatrons"),
+                        ("MMA_S_ST", "Signals - Stellar flares"),
+                        ("MMA_S_SU", "Signals - Supernovae"),
+                    ],
+                    max_length=255,
+                ),
+                blank=True,
+                default=list,
+                help_text="List of tags to add or remove",
+                null=True,
+                size=None,
+            ),
+        ),
+    ]
diff --git a/sde_collections/models/delta_patterns.py b/sde_collections/models/delta_patterns.py
index d2cedbe1..86b42338 100644
--- a/sde_collections/models/delta_patterns.py
+++ b/sde_collections/models/delta_patterns.py
@@ -707,11 +707,18 @@ class DeltaTdammTagPattern(BaseMatchPattern):
         models.CharField(max_length=255, choices=TDAMMTags.choices),
         blank=True,
         null=True,
+        default=list,
         help_text="List of tags to add or remove",
     )
     operation = models.IntegerField(choices=OperationChoices.choices, default=OperationChoices.ADD)
     source = models.CharField(max_length=10, default="manual")
 
+    def save(self, *args, **kwargs):
+        # Ensure tags are never None
+        if self.tags is None:
+            self.tags = []
+        super().save(*args, **kwargs)
+
     def apply(self):
         """
         Apply tag operation to matching URLs.
@@ -774,98 +781,56 @@ def apply(self):
         #                 pattern.apply_to_url(url)
 
     # def unapply(self):
-    #     """
-    #     Remove tag operation effects.
-    #     Similar to FieldModifyingPattern.unapply() but with custom tag handling.
-    #     """
+    #     """Remove tag operation effects with comprehensive checks."""
     #     DeltaUrl = apps.get_model("sde_collections", "DeltaUrl")
     #     CuratedUrl = apps.get_model("sde_collections", "CuratedUrl")
 
-    #     # Get affected URLs
-    #     affected_deltas = list(self.delta_urls.all())
-    #     affected_curated = list(self.curated_urls.all())
-
-    #     # Get other matching patterns
-    #     other_patterns = DeltaTdammTagPattern.objects.filter(
-    #         collection=self.collection, tag=self.tag, operation=self.operation
-    #     ).exclude(id=self.id)
-
-    #     # Process each affected delta URL
-    #     for delta in affected_deltas:
-    #         curated = CuratedUrl.objects.filter(collection=self.collection, url=delta.url).first()
-
-    #         # Find next most specific pattern
-    #         matching_patterns = [p for p in other_patterns if re.search(p.get_regex_pattern(), delta.url)]
-
-    #         next_pattern = None
-    #         if matching_patterns:
-    #             next_pattern = min(matching_patterns, key=lambda p: p.get_url_match_count())
-
-    #         if next_pattern:
-    #             # Another pattern applies, no change needed
-    #             pass
-    #         else:
-    #             # Revert our changes
-    #             self._revert_tag_operation(delta)
-
-    #             delta.refresh_from_db()
-
-    #             if curated:
-    #                 print(f"Comparing - Delta: {delta.tdamm_tag_manual} vs Curated: {curated.tdamm_tag_manual}")
-    #                 print(f"Fields match: {delta._fields_match(curated)}")
-    #                 print(curated)
-    #             # Check if delta is now redundant
-    #             if curated and delta._fields_match(curated):
-    #                 print(f"DELETING delta {delta.id}")
-    #                 DeltaUrl.objects.filter(pk=delta.id).delete()
-    #                 # delta.save()
-    #             # if curated and delta._fields_match(curated):
-    #             #     print(f"ATTEMPTING TO DELETE: {delta.url}")
-    #             #     try:
-    #             #         # Check for other patterns affecting this URL
-    #             #         other_affecting_patterns = DeltaTdammTagPattern.objects.filter(
-    #             #             delta_urls__url=delta.url
-    #             #         ).exclude(id=self.id).count()
-
-    #             #         print(f"Other patterns affecting this URL: {other_affecting_patterns}")
-
-    #             #         if other_affecting_patterns == 0:
-    #             #             delta.delete()
-    #             #             print(f"DELETED: {delta.url}")
-    #             #         else:
-    #             #             print(f"NOT DELETING: URL affected by {other_affecting_patterns} other patterns")
-    #             #     except Exception as e:
-    #             #         print(f"ERROR: {str(e)}")
-
-    #     # Process curated URLs without deltas
-    #     for curated in affected_curated:
-    #         if not DeltaUrl.objects.filter(url=curated.url, collection=self.collection).exists():
-    #             # Find next most specific pattern
-    #             matching_patterns = [p for p in other_patterns if re.search(p.get_regex_pattern(), curated.url)]
-
-    #             next_pattern = None
-    #             if matching_patterns:
-    #                 next_pattern = min(matching_patterns, key=lambda p: p.get_url_match_count())
-
-    #             if not next_pattern and self._would_operation_change_tags(curated):
-    #                 # Create delta with reverted tags
-    #                 fields = {
-    #                     field.name: getattr(curated, field.name)
-    #                     for field in curated._meta.fields
-    #                     if field.name not in ["id", "collection"]
-    #                 }
-    #                 fields["to_delete"] = False
-    #                 fields["collection"] = self.collection
-
-    #                 delta = DeltaUrl.objects.create(**fields)
-    #                 self._revert_tag_operation(delta)
+    #     # Store affected URLs
+    #     affected_urls = [(delta.id, delta.url) for delta in self.delta_urls.all()]
 
     #     # Clear relationships
     #     self.delta_urls.clear()
     #     self.curated_urls.clear()
 
+    #     # Process each affected URL
+    #     for delta_id, url in affected_urls:
+    #         try:
+    #             delta = DeltaUrl.objects.get(id=delta_id)
+    #             curated = CuratedUrl.objects.get(collection=delta.collection, url=url)
+
+    #             # Revert tags
+    #             if delta.tdamm_tag_manual:
+    #                 if self.operation == 1:  # ADD
+    #                     if self.tag in delta.tdamm_tag_manual:
+    #                         delta.tdamm_tag_manual.remove(self.tag)
+    #                 elif self.operation == 2:  # REMOVE
+    #                     if self.tag not in delta.tdamm_tag_manual and self.tag in (delta.tdamm_tag_ml or []):
+    #                         delta.tdamm_tag_manual = [t for t in (delta.tdamm_tag_ml or []) if t != self.tag]
+
+    #                 if not delta.tdamm_tag_manual:
+    #                     delta.tdamm_tag_manual = None
+
+    #                 delta.save()
+
+    #             # Check ALL pattern types that might affect this URL
+    #             other_patterns_exist = (
+    #                 DeltaExcludePattern.objects.filter(delta_urls=delta).exists()
+    #                 or DeltaIncludePattern.objects.filter(delta_urls=delta).exists()
+    #                 or DeltaTitlePattern.objects.filter(delta_urls=delta).exists()
+    #                 or DeltaDocumentTypePattern.objects.filter(delta_urls=delta).exists()
+    #                 or DeltaDivisionPattern.objects.filter(delta_urls=delta).exists()
+    #                 or DeltaTdammTagPattern.objects.filter(delta_urls=delta).exists()
+    #             )
+
+    #             # Only delete if no other patterns affect it AND it matches curated
+    #             if not other_patterns_exist and delta._fields_match(curated) and not delta.to_delete:
+    #                 DeltaUrl.objects.filter(id=delta_id).delete()
+
+    #         except (DeltaUrl.DoesNotExist, CuratedUrl.DoesNotExist):
+    #             continue
+
     def unapply(self):
-        """Remove tag operation effects with comprehensive checks."""
+        """Remove tag operation effects with comprehensive handling for multiple tags."""
         DeltaUrl = apps.get_model("sde_collections", "DeltaUrl")
         CuratedUrl = apps.get_model("sde_collections", "CuratedUrl")
 
@@ -882,14 +847,19 @@ def unapply(self):
                 delta = DeltaUrl.objects.get(id=delta_id)
                 curated = CuratedUrl.objects.get(collection=delta.collection, url=url)
 
-                # Revert tags
+                # Revert tags based on operation
                 if delta.tdamm_tag_manual:
-                    if self.operation == 1:  # ADD
-                        if self.tag in delta.tdamm_tag_manual:
-                            delta.tdamm_tag_manual.remove(self.tag)
-                    elif self.operation == 2:  # REMOVE
-                        if self.tag not in delta.tdamm_tag_manual and self.tag in (delta.tdamm_tag_ml or []):
-                            delta.tdamm_tag_manual = [t for t in (delta.tdamm_tag_ml or []) if t != self.tag]
+                    if self.operation == self.OperationChoices.ADD:
+                        # Remove the tags we added
+                        delta.tdamm_tag_manual = [t for t in delta.tdamm_tag_manual if t not in self.tags]
+                    elif self.operation == self.OperationChoices.REMOVE:
+                        # Add back tags that were in ML but we removed
+                        ml_tags = delta.tdamm_tag_ml or []
+                        for tag in self.tags:
+                            if tag in ml_tags and tag not in (delta.tdamm_tag_manual or []):
+                                if not delta.tdamm_tag_manual:
+                                    delta.tdamm_tag_manual = []
+                                delta.tdamm_tag_manual.append(tag)
 
                     if not delta.tdamm_tag_manual:
                         delta.tdamm_tag_manual = None
@@ -918,55 +888,96 @@ def _would_operation_change_tags(self, url_obj):
         ml_tags = url_obj.tdamm_tag_ml or []
         manual_tags = url_obj.tdamm_tag_manual or []
 
-        if self.operation == self.OperationChoices.ADD:
-            # Would only change if tag not in manual tags
-            return self.tag not in (manual_tags or [])
+        if self.tags is None:
+            return False
+
+        if self.operation == OperationChoices.ADD:
+            # Would only change if at least one tag is not in manual tags
+            # return self.tag not in (manual_tags or [])
+            return any(tag not in manual_tags for tag in self.tags)
 
-        elif self.operation == self.OperationChoices.REMOVE:
+        elif self.operation == OperationChoices.REMOVE:
             # Would only change if 1) tag in manual OR 2) no manual tags and tag in ML
-            return (manual_tags and self.tag in manual_tags) or (not manual_tags and ml_tags and self.tag in ml_tags)
+            # return (manual_tags and self.tag in manual_tags) or (not manual_tags and ml_tags and self.tag in ml_tags)
+            # Would only change if any tag is present in manual OR no manual tags and any tag is in ML
+            return (manual_tags and any(tag in manual_tags for tag in self.tags)) or (
+                not manual_tags and ml_tags and any(tag in ml_tags for tag in self.tags)
+            )
+
+    # def _apply_tag_operation(self, url_obj):
+    #     """Apply the tag operation with proper ML copying logic."""
+    #     ml_tags = url_obj.tdamm_tag_ml or []
+    #     manual_tags = url_obj.tdamm_tag_manual or []
+    #     changed = False
+
+    #     if self.operation == self.OperationChoices.ADD:  # for the add operation
+    #         if self.source == "ml":
+    #             # Copy ML tags to manual and add new tag
+    #             current_tags = ml_tags or []
+    #             new_tags = list(current_tags)
+    #             if self.tag not in new_tags:
+    #                 new_tags.append(self.tag)
+    #                 url_obj.tdamm_tag_manual = new_tags
+    #                 changed = True
+    #         else:  # 'manual'
+    #             # Add directly to manual tags
+    #             current_tags = manual_tags or []
+    #             if self.tag not in current_tags:
+    #                 current_tags.append(self.tag)
+    #                 url_obj.tdamm_tag_manual = current_tags
+    #                 changed = True
+    #     else:  # for the remove operation
+    #         if self.source == "ml":
+    #             # Copy ML tags minus the removed tag
+    #             if ml_tags:
+    #                 new_manual_tags = [t for t in ml_tags if t != self.tag]
+    #                 if not manual_tags or set(manual_tags) != set(new_manual_tags):
+    #                     url_obj.tdamm_tag_manual = new_manual_tags
+    #                     changed = True
+    #         else:  # 'manual'
+    #             # Remove directly from manual tags
+    #             if manual_tags and self.tag in manual_tags:
+    #                 manual_tags.remove(self.tag)
+    #                 url_obj.tdamm_tag_manual = manual_tags
+    #                 changed = True
+
+    #     if changed:
+    #         url_obj.save()
+    #         if hasattr(url_obj, "_cleanup_if_needed"):
+    #             url_obj._cleanup_if_needed()
 
     def _apply_tag_operation(self, url_obj):
-        """Apply the tag operation with proper ML copying logic."""
-        ml_tags = url_obj.tdamm_tag_ml or []
         manual_tags = url_obj.tdamm_tag_manual or []
         changed = False
 
-        if self.operation == self.OperationChoices.ADD:  # for the add operation
-            if self.source == "ml":
-                # Copy ML tags to manual and add new tag
-                current_tags = ml_tags or []
-                new_tags = list(current_tags)
-                if self.tag not in new_tags:
-                    new_tags.append(self.tag)
-                    url_obj.tdamm_tag_manual = new_tags
-                    changed = True
-            else:  # 'manual'
-                # Add directly to manual tags
-                current_tags = manual_tags or []
-                if self.tag not in current_tags:
-                    current_tags.append(self.tag)
-                    url_obj.tdamm_tag_manual = current_tags
+        print(f"Applying operation {self.operation} to URL: {url_obj.url}")
+        print(f"Pattern tags: {self.tags}")
+        print(f"Current manual tags: {manual_tags}")
+
+        if self.operation == OperationChoices.ADD:
+            # Add all tags in the list
+            current_tags = manual_tags or []
+            for tag in self.tags:
+                if tag not in current_tags:
+                    current_tags.append(tag)
                     changed = True
-        else:  # for the remove operation
-            if self.source == "ml":
-                # Copy ML tags minus the removed tag
-                if ml_tags:
-                    new_manual_tags = [t for t in ml_tags if t != self.tag]
-                    if not manual_tags or set(manual_tags) != set(new_manual_tags):
-                        url_obj.tdamm_tag_manual = new_manual_tags
-                        changed = True
-            else:  # 'manual'
-                # Remove directly from manual tags
-                if manual_tags and self.tag in manual_tags:
-                    manual_tags.remove(self.tag)
-                    url_obj.tdamm_tag_manual = manual_tags
+            if changed:
+                print(f"New tags after ADD: {current_tags}")
+                url_obj.tdamm_tag_manual = current_tags
+        else:  # REMOVE
+            # Remove all tags in the list
+            if manual_tags:
+                new_tags = [t for t in manual_tags if t not in self.tags]
+                if new_tags != manual_tags:
+                    print(f"New tags after REMOVE: {new_tags}")
+                    url_obj.tdamm_tag_manual = new_tags
                     changed = True
 
         if changed:
             url_obj.save()
             if hasattr(url_obj, "_cleanup_if_needed"):
                 url_obj._cleanup_if_needed()
+            print(f"URL saved with new tags: {url_obj.tdamm_tag_manual}")
 
     def _revert_tag_operation(self, url_obj):
         """Revert the effects of the tag operation."""
@@ -974,7 +985,7 @@ def _revert_tag_operation(self, url_obj):
         manual_tags = url_obj.tdamm_tag_manual or []
         changed = False
 
-        if self.operation == self.OperationChoices.ADD:
+        if self.operation == OperationChoices.ADD:
             # If we added the tag, remove it
             if manual_tags and self.tag in manual_tags:
                 manual_tags.remove(self.tag)
@@ -984,7 +995,7 @@ def _revert_tag_operation(self, url_obj):
                 url_obj.tdamm_tag_manual = manual_tags
                 url_obj.save()
 
-        elif self.operation == self.OperationChoices.REMOVE:
+        elif self.operation == OperationChoices.REMOVE:
             # If we removed a tag, add it back if it was in ML tags
             if ml_tags and self.tag in ml_tags:
                 if not manual_tags:
diff --git a/sde_collections/serializers.py b/sde_collections/serializers.py
index 9baed8c8..ba08229d 100644
--- a/sde_collections/serializers.py
+++ b/sde_collections/serializers.py
@@ -402,15 +402,27 @@ def validate_match_pattern(self, value):
 
 
 class TdammTagPatternSerializer(BasePatternSerializer, serializers.ModelSerializer):
-    tag_display = serializers.CharField(source="get_tag_display", read_only=True)
+    tags_display = serializers.SerializerMethodField(read_only=True)
     operation_display = serializers.CharField(source="get_operation_display", read_only=True)
 
     class Meta:
         model = DeltaTdammTagPattern
         fields = BasePatternSerializer.Meta.fields + (
-            "tag",
-            "tag_display",
+            "tags",
+            "tags_display",
             "operation",
             "operation_display",
             "source",
         )
+
+    def create(self, validated_data):
+        # Ensure tags field exists and is not None
+        if "tags" not in validated_data or validated_data["tags"] is None:
+            validated_data["tags"] = []
+        return super().create(validated_data)
+
+    def get_tags_display(self, obj):
+        """Return display names for all tags"""
+        if not obj.tags:
+            return []
+        return [dict(TDAMMTags.choices).get(tag, tag) for tag in obj.tags]
diff --git a/sde_collections/views.py b/sde_collections/views.py
index ecc2c0fb..a3aa963f 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -26,6 +26,7 @@
     CurationStatusChoices,
     Divisions,
     DocumentTypes,
+    OperationChoices,
     ReindexingStatusChoices,
     TDAMMTags,
     WorkflowStatusChoices,
@@ -366,18 +367,42 @@ def remove_tag(self, request, pk=None):
             pattern, created = DeltaTdammTagPattern.objects.get_or_create(
                 collection=delta_url.collection,
                 match_pattern=delta_url.url,
-                match_pattern_type=1,  # Individual URL
-                tag=tag,
-                operation=DeltaTdammTagPattern.OperationChoices.REMOVE,
+                match_pattern_type=1,
+                # tag=tag,
+                operation=OperationChoices.REMOVE,
                 source=source,
+                defaults={"tags": [tag]},
             )
 
+            if not created:
+                # Add tag to remove list if not already present
+                current_tags = pattern.tags or []
+                if tag not in current_tags:
+                    pattern.tags = current_tags + [tag]
+                    pattern.save()
+
+            # Remove from ADD pattern if it exists
+            add_pattern = DeltaTdammTagPattern.objects.filter(
+                collection=delta_url.collection,
+                match_pattern=delta_url.url,
+                operation=OperationChoices.ADD,
+                source=source,
+            ).first()
+
+            if add_pattern and add_pattern.tags and tag in add_pattern.tags:
+                # Remove this tag from the add pattern
+                add_pattern.tags = [t for t in add_pattern.tags if t != tag]
+                if not add_pattern.tags:
+                    add_pattern.delete()
+                else:
+                    add_pattern.save()
+
             # Apply the pattern
             pattern._apply_tag_operation(delta_url)
 
             return Response({"status": "success"})
         except Exception as e:
-            logger.error(f"An error occurred while adding a tag to DeltaURL: {str(e)}")
+            logger.error(f"Error occurred: {str(e)}")
             return Response({"error": "An internal error has occurred."}, status=500)
 
     # @action(detail=True, methods=["post"], url_path="add_tag")
@@ -417,18 +442,42 @@ def add_tag(self, request, pk=None):
             pattern, created = DeltaTdammTagPattern.objects.get_or_create(
                 collection=delta_url.collection,
                 match_pattern=delta_url.url,
-                match_pattern_type=1,  # Individual URL
-                tag=tag,
-                operation=DeltaTdammTagPattern.OperationChoices.ADD,
+                match_pattern_type=1,
+                # tag=tag,
+                operation=OperationChoices.ADD,
                 source=source,
+                defaults={"tags": [tag]},
             )
 
+            if not created:
+                # Add tag if not already present
+                current_tags = pattern.tags or []
+                if tag not in current_tags:
+                    pattern.tags = current_tags + [tag]
+                    pattern.save()
+
+            # Remove from REMOVE pattern if it exists
+            remove_pattern = DeltaTdammTagPattern.objects.filter(
+                collection=delta_url.collection,
+                match_pattern=delta_url.url,
+                operation=OperationChoices.REMOVE,
+                source=source,
+            ).first()
+
+            if remove_pattern and remove_pattern.tags and tag in remove_pattern.tags:
+                # Remove this tag from the remove pattern
+                remove_pattern.tags = [t for t in remove_pattern.tags if t != tag]
+                if not remove_pattern.tags:
+                    remove_pattern.delete()
+                else:
+                    remove_pattern.save()
+
             # Apply the pattern
             pattern._apply_tag_operation(delta_url)
 
             return Response({"status": "success"})
         except Exception as e:
-            logger.error(f"An error occurred while adding a tag to DeltaURL: {str(e)}")
+            logger.error(f"Error occurred: {str(e)}")
             return Response({"error": "An internal error has occurred."}, status=500)
 
 
@@ -465,16 +514,33 @@ def update_division(self, request, pk=None):
     # def add_tag(self, request, pk=None):
     #     curated_url = self.get_object()
     #     tag = request.data.get("tag")
-    #     source = request.data.get("source")
+    #     source = request.data.get("source", "manual")
 
     #     if not tag:
     #         return Response({"error": "Tag not specified"}, status=400)
 
     #     try:
-    #         curated_url.add_tag(tag, source)
+    #         # Create delta URL first
+    #         delta_url = curated_url._create_or_update_delta()
+
+    #         # Then apply operation to the delta
+    #         pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+    #             collection=curated_url.collection,
+    #             match_pattern=curated_url.url,
+    #             match_pattern_type=1,
+    #             tag=tag,
+    #             operation=OperationChoices.ADD,
+    #             source=source,
+    #         )
+    #         pattern._apply_tag_operation(delta_url)
+
+    #         # Clean up if delta becomes identical to curated
+    #         if not delta_url.to_delete and delta_url._fields_match(curated_url):
+    #             delta_url.delete()
+
     #         return Response({"status": "success"})
     #     except Exception as e:
-    #         logger.error("An error occurred while adding a tag to CuratedURL: %s", str(e))
+    #         logger.error(f"Error occurred: {str(e)}")
     #         return Response({"error": "An internal error has occurred."}, status=500)
 
     @action(detail=True, methods=["post"], url_path="add_tag")
@@ -490,15 +556,46 @@ def add_tag(self, request, pk=None):
             # Create delta URL first
             delta_url = curated_url._create_or_update_delta()
 
-            # Then apply operation to the delta
+            # Then apply tag operations to the delta
             pattern, created = DeltaTdammTagPattern.objects.get_or_create(
                 collection=curated_url.collection,
                 match_pattern=curated_url.url,
                 match_pattern_type=1,
-                tag=tag,
-                operation=DeltaTdammTagPattern.OperationChoices.ADD,
+                operation=OperationChoices.ADD,
                 source=source,
+                defaults={"tags": [tag]},
             )
+
+            if not created:
+                # Add tag if not already present
+                current_tags = pattern.tags or []
+                if tag not in current_tags:
+                    pattern.tags = current_tags + [tag]
+                    pattern.save()
+
+            if not created:
+                # Add tag if not already present
+                current_tags = pattern.tags or []
+                if tag not in current_tags:
+                    pattern.tags = current_tags + [tag]
+                    pattern.save()
+
+            # Remove from REMOVE pattern if it exists
+            remove_pattern = DeltaTdammTagPattern.objects.filter(
+                collection=delta_url.collection,
+                match_pattern=delta_url.url,
+                operation=OperationChoices.REMOVE,
+                source=source,
+            ).first()
+
+            if remove_pattern and remove_pattern.tags and tag in remove_pattern.tags:
+                # Remove this tag from the remove pattern
+                remove_pattern.tags = [t for t in remove_pattern.tags if t != tag]
+                if not remove_pattern.tags:
+                    remove_pattern.delete()
+                else:
+                    remove_pattern.save()
+
             pattern._apply_tag_operation(delta_url)
 
             # Clean up if delta becomes identical to curated
@@ -514,16 +611,33 @@ def add_tag(self, request, pk=None):
     # def remove_tag(self, request, pk=None):
     #     curated_url = self.get_object()
     #     tag = request.data.get("tag")
-    #     source = request.data.get("source")
+    #     source = request.data.get("source", "manual")
 
     #     if not tag:
     #         return Response({"error": "Tag not specified"}, status=400)
 
     #     try:
-    #         curated_url.remove_tag(tag, source)
+    #         # Create delta URL first
+    #         delta_url = curated_url._create_or_update_delta()
+
+    #         # Then apply operation to the delta
+    #         pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+    #             collection=curated_url.collection,
+    #             match_pattern=curated_url.url,
+    #             match_pattern_type=1,
+    #             tag=tag,
+    #             operation=OperationChoices.REMOVE,
+    #             source=source,
+    #         )
+    #         pattern._apply_tag_operation(delta_url)
+
+    #         # Clean up if delta becomes identical to curated
+    #         if not delta_url.to_delete and delta_url._fields_match(curated_url):
+    #             delta_url.delete()
+
     #         return Response({"status": "success"})
     #     except Exception as e:
-    #         logger.error("An error occurred while removing a tag from CuratedURL: %s", str(e))
+    #         logger.error(f"Error occurred: {str(e)}")
     #         return Response({"error": "An internal error has occurred."}, status=500)
 
     @action(detail=True, methods=["post"], url_path="remove_tag")
@@ -539,15 +653,40 @@ def remove_tag(self, request, pk=None):
             # Create delta URL first
             delta_url = curated_url._create_or_update_delta()
 
-            # Then apply operation to the delta
+            # Create or get a pattern for tag removal
             pattern, created = DeltaTdammTagPattern.objects.get_or_create(
                 collection=curated_url.collection,
                 match_pattern=curated_url.url,
                 match_pattern_type=1,
-                tag=tag,
                 operation=DeltaTdammTagPattern.OperationChoices.REMOVE,
                 source=source,
+                defaults={"tags": [tag]},
             )
+
+            if not created:
+                # Add tag to removal list if not already present
+                current_tags = pattern.tags or []
+                if tag not in current_tags:
+                    pattern.tags = current_tags + [tag]
+                    pattern.save()
+
+            # Check for and update ADD pattern if it exists
+            add_pattern = DeltaTdammTagPattern.objects.filter(
+                collection=curated_url.collection,
+                match_pattern=curated_url.url,
+                operation=DeltaTdammTagPattern.OperationChoices.ADD,
+                source=source,
+            ).first()
+
+            if add_pattern and add_pattern.tags and tag in add_pattern.tags:
+                # Remove tag from add pattern
+                add_pattern.tags = [t for t in add_pattern.tags if t != tag]
+                if not add_pattern.tags:
+                    add_pattern.delete()
+                else:
+                    add_pattern.save()
+
+            # Apply the pattern
             pattern._apply_tag_operation(delta_url)
 
             # Clean up if delta becomes identical to curated
@@ -705,12 +844,53 @@ def create(self, request, *args, **kwargs):
             return Response(status=status.HTTP_400_BAD_REQUEST, data={"error": "Division is required."})
 
 
+# class TdammTagPatternViewSet(CollectionFilterMixin, viewsets.ModelViewSet):
+#     queryset = DeltaTdammTagPattern.objects.all()
+#     serializer_class = TdammTagPatternSerializer
+
+#     def get_queryset(self):
+#         return super().get_queryset().order_by("match_pattern")
+
+
 class TdammTagPatternViewSet(CollectionFilterMixin, viewsets.ModelViewSet):
     queryset = DeltaTdammTagPattern.objects.all()
     serializer_class = TdammTagPatternSerializer
 
-    def get_queryset(self):
-        return super().get_queryset().order_by("match_pattern")
+    # def create(self, request, *args, **kwargs):
+    #     # Handle single tag parameter from frontend
+    #     tag = request.data.get('tag')
+    #     if tag:
+    #         # Make a mutable copy of the data
+    #         data = request.data.copy()
+    #         # Convert single tag to tags array
+    #         data['tags'] = [tag]
+    #         # Use this modified data for serialization
+    #         serializer = self.get_serializer(data=data)
+    #         serializer.is_valid(raise_exception=True)
+    #         self.perform_create(serializer)
+    #         headers = self.get_success_headers(serializer.data)
+    #         return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
+
+    #     return super().create(request, *args, **kwargs)
+
+    def create(self, request, *args, **kwargs):
+        data = request.data.copy()
+
+        if "tag" in data:
+            tag = data.pop("tag")
+            data["tags"] = [tag]
+
+        # Create serializer with cleaned data
+        serializer = self.get_serializer(data=data)
+
+        # Print data for debugging
+        print(f"Data going to serializer: {data}")
+
+        # Continue with validation and creation
+        serializer.is_valid(raise_exception=True)
+        self.perform_create(serializer)
+        headers = self.get_success_headers(serializer.data)
+        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
 
 
 class CollectionViewSet(viewsets.ModelViewSet):
diff --git a/sde_indexing_helper/static/js/delta_url_list.js b/sde_indexing_helper/static/js/delta_url_list.js
index 46c562c0..81a17d8d 100644
--- a/sde_indexing_helper/static/js/delta_url_list.js
+++ b/sde_indexing_helper/static/js/delta_url_list.js
@@ -1057,8 +1057,12 @@ var tdamm_tag_patterns_table = $("#tdamm_tag_patterns_table").DataTable({
           sortable: false,
       },
       {
-          data: "tag_display",
-          class: "whiteText"
+          data: "tags_display",
+          class: "whiteText",
+          render: function(data, type, row) {
+            if (!data || !data.length) return "None";
+            return Array.isArray(data) ? data.join(", ") : data;
+        }
       },
       {
           data: "operation_display",
@@ -1088,7 +1092,7 @@ var tdamm_tag_patterns_table = $("#tdamm_tag_patterns_table").DataTable({
       },
       { data: "id", visible: false, searchable: false },
       { data: "match_pattern_type", visible: false },
-      { data: "tag", visible: false },
+      { data: "tags", visible: false },
       { data: "operation", visible: false },
       // { data: "source", visible: false },
   ],
@@ -1151,59 +1155,102 @@ function handleDeleteTdammTagPatternButtonClick() {
   });
 }
 
+// function postTdammTagPattern(match_pattern, match_pattern_type, tag, operation, source="manual") {
+//   console.log("Posting tag pattern:", {
+//     match_pattern,
+//     match_pattern_type,
+//     tag,
+//     operation,
+//     source
+//   });
+
+//   if (!match_pattern) {
+//       toastr.error("Please provide a match pattern.");
+//       return;
+//   }
+
+//   if (!tag) {
+//       toastr.error("Please select a TDAMM tag.");
+//       return;
+//   }
+
+//   if (!operation) {
+//       toastr.error("Please select an operation (Add or Remove).");
+//       return;
+//   }
+
+//   if (!source) {
+//       toastr.error("Please select a source (Manual or ML).");
+//       return;
+//   }
+
+//   $.ajax({
+//       url: "/api/tdamm-tag-patterns/",
+//       type: "POST",
+//       data: {
+//           collection: collection_id,
+//           match_pattern: match_pattern,
+//           match_pattern_type: match_pattern_type,
+//           tags: [tag],
+//           operation: operation,
+//           source: source,
+//           csrfmiddlewaretoken: csrftoken,
+//       },
+//       success: function (data) {
+//           console.log("Success:", data);
+//           $("#delta_urls_table").DataTable().ajax.reload(null, false);
+//           $("#tdamm_tag_patterns_table").DataTable().ajax.reload(null, false);
+//           if (currentTab === "") { // Only add a notification if we are on the first tab
+//               newTdammTagPatternsCount = newTdammTagPatternsCount + 1;
+//               $("#tdammTagPatternsTab").html(
+//                   `TDAMM Tag Patterns <span class="pill notifyBadge badge badge-pill badge-primary">` +
+//                   newTdammTagPatternsCount + " new" +
+//                   `</span>`
+//               );
+//           }
+//       },
+//       error: function (xhr, status, error) {
+//           console.error("Error:", xhr.responseText);
+//           var errorMessage = xhr.responseText;
+//           if (errorMessage.includes("unique")) {
+//               toastr.success("Pattern already exists");
+//               return;
+//           }
+//           toastr.error(errorMessage);
+//       },
+//   });
+// }
+
 function postTdammTagPattern(match_pattern, match_pattern_type, tag, operation, source="manual") {
-  if (!match_pattern) {
-      toastr.error("Please provide a match pattern.");
-      return;
-  }
+  // Log to see what's being sent
+  console.log("Sending tag:", tag);
 
-  if (!tag) {
-      toastr.error("Please select a TDAMM tag.");
-      return;
-  }
+  // Create FormData to properly handle the array
+  var formData = new FormData();
+  formData.append('collection', collection_id);
+  formData.append('match_pattern', match_pattern);
+  formData.append('match_pattern_type', match_pattern_type);
+  formData.append('operation', operation);
+  formData.append('source', source);
+  formData.append('csrfmiddlewaretoken', csrftoken);
 
-  if (!operation) {
-      toastr.error("Please select an operation (Add or Remove).");
-      return;
-  }
-
-  if (!source) {
-      toastr.error("Please select a source (Manual or ML).");
-      return;
-  }
+  // Add tag as individual value (server will convert to array)
+  formData.append('tag', tag);
 
   $.ajax({
       url: "/api/tdamm-tag-patterns/",
       type: "POST",
-      data: {
-          collection: collection_id,
-          match_pattern: match_pattern,
-          match_pattern_type: match_pattern_type,
-          tag: tag,
-          operation: operation,
-          source: source,
-          csrfmiddlewaretoken: csrftoken,
-      },
-      success: function (data) {
-          $("#delta_urls_table").DataTable().ajax.reload(null, false);
-          $("#tdamm_tag_patterns_table").DataTable().ajax.reload(null, false);
-          if (currentTab === "") { // Only add a notification if we are on the first tab
-              newTdammTagPatternsCount = newTdammTagPatternsCount + 1;
-              $("#tdammTagPatternsTab").html(
-                  `TDAMM Tag Patterns <span class="pill notifyBadge badge badge-pill badge-primary">` +
-                  newTdammTagPatternsCount + " new" +
-                  `</span>`
-              );
-          }
-      },
-      error: function (xhr, status, error) {
-          var errorMessage = xhr.responseText;
-          if (errorMessage.includes("unique")) {
-              toastr.success("Pattern already exists");
-              return;
-          }
-          toastr.error(errorMessage);
+      data: formData,
+      processData: false,
+      contentType: false,
+      success: function(data) {
+          console.log("Success:", data);
+          // Rest of success handler
       },
+      error: function(xhr) {
+          console.error("Error:", xhr.responseText);
+          // Rest of error handler
+      }
   });
 }
 

From 26a44e7c35fc531e6973bdcad7b697dd6fb3c150 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanurjsharma@gmail.com>
Date: Wed, 2 Apr 2025 13:22:34 -0500
Subject: [PATCH 32/35] Merged migrations

---
 .../migrations/0082_merge_20250402_1127.py          | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 sde_collections/migrations/0082_merge_20250402_1127.py

diff --git a/sde_collections/migrations/0082_merge_20250402_1127.py b/sde_collections/migrations/0082_merge_20250402_1127.py
new file mode 100644
index 00000000..f4c582a4
--- /dev/null
+++ b/sde_collections/migrations/0082_merge_20250402_1127.py
@@ -0,0 +1,13 @@
+# Generated by Django 4.2.9 on 2025-04-02 16:27
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("sde_collections", "0077_alter_candidateurl_tdamm_tag_manual_and_more"),
+        ("sde_collections", "0081_alter_deltatdammtagpattern_tags"),
+    ]
+
+    operations = []

From 8205c2499d2ad9ed07a5fd328de9d56b4688eb92 Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanurjsharma@gmail.com>
Date: Wed, 2 Apr 2025 16:53:09 -0500
Subject: [PATCH 33/35] Updated add and remove tag in views

---
 sde_collections/views.py | 449 ++++++++++++++++++++++++++++-----------
 1 file changed, 327 insertions(+), 122 deletions(-)

diff --git a/sde_collections/views.py b/sde_collections/views.py
index 48b0b123..3917e9bd 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -331,30 +331,60 @@ def update_division(self, request, pk=None):
             return Response(status=status.HTTP_200_OK)
         return Response(status=status.HTTP_400_BAD_REQUEST, data={"error": "Division is required."})
 
-    # @action(detail=True, methods=["post"], url_path="remove_tag")
-    # def remove_tag(self, request, pk=None):
+    # @action(detail=True, methods=["post"], url_path="add_tag")
+    # def add_tag(self, request, pk=None):
     #     delta_url = self.get_object()
     #     tag = request.data.get("tag")
-    #     source = request.data.get("source")
+    #     source = request.data.get("source", "manual")
 
     #     if not tag:
     #         return Response({"error": "Tag not specified"}, status=400)
 
     #     try:
-    #         # delta_url.remove_tag(tag, source)
-    #         pattern = DeltaTdammTagPattern.objects.filter(
-    #             collection=delta_url.collection, match_pattern=delta_url.url, tag=tag, source=source
+    #         # Create or get a pattern for this specific URL
+    #         pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+    #             collection=delta_url.collection,
+    #             match_pattern=delta_url.url,
+    #             match_pattern_type=1,
+    #             # tag=tag,
+    #             operation=OperationChoices.ADD,
+    #             source=source,
+    #             defaults={"tags": [tag]},
+    #         )
+
+    #         if not created:
+    #             # Add tag if not already present
+    #             current_tags = pattern.tags or []
+    #             if tag not in current_tags:
+    #                 pattern.tags = current_tags + [tag]
+    #                 pattern.save()
+
+    #         # Remove from REMOVE pattern if it exists
+    #         remove_pattern = DeltaTdammTagPattern.objects.filter(
+    #             collection=delta_url.collection,
+    #             match_pattern=delta_url.url,
+    #             operation=OperationChoices.REMOVE,
+    #             source=source,
     #         ).first()
 
-    #         if pattern:
-    #             pattern.delete()
+    #         if remove_pattern and remove_pattern.tags and tag in remove_pattern.tags:
+    #             # Remove this tag from the remove pattern
+    #             remove_pattern.tags = [t for t in remove_pattern.tags if t != tag]
+    #             if not remove_pattern.tags:
+    #                 remove_pattern.delete()
+    #             else:
+    #                 remove_pattern.save()
+
+    #         # Apply the pattern
+    #         pattern._apply_tag_operation(delta_url)
+
     #         return Response({"status": "success"})
     #     except Exception as e:
     #         logger.error(f"Error occurred: {str(e)}")
     #         return Response({"error": "An internal error has occurred."}, status=500)
 
-    @action(detail=True, methods=["post"], url_path="remove_tag")
-    def remove_tag(self, request, pk=None):
+    @action(detail=True, methods=["post"], url_path="add_tag")
+    def add_tag(self, request, pk=None):
         delta_url = self.get_object()
         tag = request.data.get("tag")
         source = request.data.get("source", "manual")
@@ -363,73 +393,104 @@ def remove_tag(self, request, pk=None):
             return Response({"error": "Tag not specified"}, status=400)
 
         try:
-            # Create or get a pattern for this specific URL
-            pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+            # Check for existing remove pattern with this tag
+            remove_pattern = DeltaTdammTagPattern.objects.filter(
                 collection=delta_url.collection,
                 match_pattern=delta_url.url,
                 match_pattern_type=1,
-                # tag=tag,
                 operation=OperationChoices.REMOVE,
                 source=source,
-                defaults={"tags": [tag]},
-            )
+            ).first()
 
-            if not created:
-                # Add tag to remove list if not already present
-                current_tags = pattern.tags or []
-                if tag not in current_tags:
-                    pattern.tags = current_tags + [tag]
-                    pattern.save()
+            if remove_pattern and remove_pattern.tags and tag in remove_pattern.tags:
+                # Remove the tag from the remove pattern
+                remove_pattern.tags = [t for t in remove_pattern.tags if t != tag]
+                if not remove_pattern.tags:
+                    remove_pattern.delete()
+                else:
+                    remove_pattern.save()
+                    # Apply the modified remove pattern
+                    remove_pattern._apply_tag_operation(delta_url)
 
-            # Remove from ADD pattern if it exists
-            add_pattern = DeltaTdammTagPattern.objects.filter(
+            # Check for existing add pattern
+            add_pattern, created = DeltaTdammTagPattern.objects.get_or_create(
                 collection=delta_url.collection,
                 match_pattern=delta_url.url,
+                match_pattern_type=1,
                 operation=OperationChoices.ADD,
                 source=source,
-            ).first()
+                defaults={"tags": [tag]},
+            )
 
-            if add_pattern and add_pattern.tags and tag in add_pattern.tags:
-                # Remove this tag from the add pattern
-                add_pattern.tags = [t for t in add_pattern.tags if t != tag]
-                if not add_pattern.tags:
-                    add_pattern.delete()
-                else:
+            if not created:
+                # Add tag if not already present
+                current_tags = add_pattern.tags or []
+                if tag not in current_tags:
+                    add_pattern.tags = current_tags + [tag]
                     add_pattern.save()
 
-            # Apply the pattern
-            pattern._apply_tag_operation(delta_url)
+            # Always apply the add pattern
+            add_pattern._apply_tag_operation(delta_url)
 
             return Response({"status": "success"})
         except Exception as e:
             logger.error(f"Error occurred: {str(e)}")
             return Response({"error": "An internal error has occurred."}, status=500)
 
-    # @action(detail=True, methods=["post"], url_path="add_tag")
-    # def add_tag(self, request, pk=None):
+    # @action(detail=True, methods=["post"], url_path="remove_tag")
+    # def remove_tag(self, request, pk=None):
     #     delta_url = self.get_object()
     #     tag = request.data.get("tag")
-    #     source = request.data.get("source")
+    #     source = request.data.get("source", "manual")
 
     #     if not tag:
     #         return Response({"error": "Tag not specified"}, status=400)
 
     #     try:
-    #         # delta_url.add_tag(tag, source)
-    #         DeltaTdammTagPattern.objects.create(
+    #         # Create or get a pattern for this specific URL
+    #         pattern, created = DeltaTdammTagPattern.objects.get_or_create(
     #             collection=delta_url.collection,
     #             match_pattern=delta_url.url,
     #             match_pattern_type=1,
-    #             tag=tag,
+    #             # tag=tag,
+    #             operation=OperationChoices.REMOVE,
     #             source=source,
+    #             defaults={"tags": [tag]},
     #         )
+
+    #         if not created:
+    #             # Add tag to remove list if not already present
+    #             current_tags = pattern.tags or []
+    #             if tag not in current_tags:
+    #                 pattern.tags = current_tags + [tag]
+    #                 pattern.save()
+
+    #         # Remove from ADD pattern if it exists
+    #         add_pattern = DeltaTdammTagPattern.objects.filter(
+    #             collection=delta_url.collection,
+    #             match_pattern=delta_url.url,
+    #             operation=OperationChoices.ADD,
+    #             source=source,
+    #         ).first()
+
+    #         if add_pattern and add_pattern.tags and tag in add_pattern.tags:
+    #             # Remove this tag from the add pattern
+    #             add_pattern.tags = [t for t in add_pattern.tags if t != tag]
+    #             if not add_pattern.tags:
+    #                 add_pattern.delete()
+    #             else:
+    #                 add_pattern.save()
+
+    #         # Apply the pattern
+    #         pattern._apply_tag_operation(delta_url)
+
     #         return Response({"status": "success"})
     #     except Exception as e:
-    #         logger.error("An error occurred while adding a tag to DeltaURL: %s", str(e))
+    #         logger.error(f"Error occurred: {str(e)}")
     #         return Response({"error": "An internal error has occurred."}, status=500)
 
-    @action(detail=True, methods=["post"], url_path="add_tag")
-    def add_tag(self, request, pk=None):
+    @action(detail=True, methods=["post"], url_path="remove_tag")
+    def remove_tag(self, request, pk=None):
         delta_url = self.get_object()
         tag = request.data.get("tag")
         source = request.data.get("source", "manual")
@@ -438,48 +499,97 @@ def add_tag(self, request, pk=None):
             return Response({"error": "Tag not specified"}, status=400)
 
         try:
-            # Create or get a pattern for this specific URL
-            pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+            # Get current tags
+            current_tags = delta_url.tdamm_tag_manual or []
+
+            # Check if there's an add pattern with this tag
+            add_pattern = DeltaTdammTagPattern.objects.filter(
                 collection=delta_url.collection,
                 match_pattern=delta_url.url,
                 match_pattern_type=1,
-                # tag=tag,
                 operation=OperationChoices.ADD,
                 source=source,
-                defaults={"tags": [tag]},
-            )
-
-            if not created:
-                # Add tag if not already present
-                current_tags = pattern.tags or []
-                if tag not in current_tags:
-                    pattern.tags = current_tags + [tag]
-                    pattern.save()
-
-            # Remove from REMOVE pattern if it exists
-            remove_pattern = DeltaTdammTagPattern.objects.filter(
-                collection=delta_url.collection,
-                match_pattern=delta_url.url,
-                operation=OperationChoices.REMOVE,
-                source=source,
             ).first()
 
-            if remove_pattern and remove_pattern.tags and tag in remove_pattern.tags:
-                # Remove this tag from the remove pattern
-                remove_pattern.tags = [t for t in remove_pattern.tags if t != tag]
-                if not remove_pattern.tags:
-                    remove_pattern.delete()
+            if add_pattern and add_pattern.tags and tag in add_pattern.tags:
+                # Remove tag from ADD pattern
+                add_pattern.tags = [t for t in add_pattern.tags if t != tag]
+
+                # Delete pattern if empty, otherwise save it
+                if not add_pattern.tags:
+                    add_pattern.delete()
                 else:
-                    remove_pattern.save()
+                    add_pattern.save()
 
-            # Apply the pattern
-            pattern._apply_tag_operation(delta_url)
+                # Important: Directly remove the tag from the URL
+                if tag in current_tags:
+                    delta_url.tdamm_tag_manual = [t for t in current_tags if t != tag]
+                    delta_url.save()
+
+                    # Explicitly call cleanup
+                    if hasattr(delta_url, "_cleanup_if_needed"):
+                        delta_url._cleanup_if_needed()
+
+            # If tag still exists in URL, create a REMOVE pattern
+            elif tag in current_tags:
+                remove_pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+                    collection=delta_url.collection,
+                    match_pattern=delta_url.url,
+                    match_pattern_type=1,
+                    operation=OperationChoices.REMOVE,
+                    source=source,
+                    defaults={"tags": [tag]},
+                )
+
+                if not created:
+                    if tag not in (remove_pattern.tags or []):
+                        remove_pattern.tags = (remove_pattern.tags or []) + [tag]
+                        remove_pattern.save()
+
+                # Directly remove the tag from the URL
+                delta_url.tdamm_tag_manual = [t for t in current_tags if t != tag]
+                delta_url.save()
+
+                # Explicitly call cleanup
+                if hasattr(delta_url, "_cleanup_if_needed"):
+                    delta_url._cleanup_if_needed()
+
+            # Force refresh all patterns for this URL to ensure consistency
+            self._refresh_url_tags(delta_url)
 
             return Response({"status": "success"})
         except Exception as e:
             logger.error(f"Error occurred: {str(e)}")
             return Response({"error": "An internal error has occurred."}, status=500)
 
+    def _refresh_url_tags(self, url_obj):
+        """Refresh URL tags by reapplying all patterns affecting this URL."""
+        # Get all patterns affecting this URL
+        add_patterns = DeltaTdammTagPattern.objects.filter(
+            collection=url_obj.collection, delta_urls=url_obj, operation=OperationChoices.ADD
+        )
+
+        remove_patterns = DeltaTdammTagPattern.objects.filter(
+            collection=url_obj.collection, delta_urls=url_obj, operation=OperationChoices.REMOVE
+        )
+
+        # Collect all tags from ADD patterns
+        add_tags = set()
+        for pattern in add_patterns:
+            add_tags.update(pattern.tags or [])
+
+        # Collect all tags from REMOVE patterns
+        remove_tags = set()
+        for pattern in remove_patterns:
+            remove_tags.update(pattern.tags or [])
+
+        # Final tags = (add tags) - (remove tags)
+        final_tags = list(add_tags - remove_tags)
+
+        # Update URL tags
+        url_obj.tdamm_tag_manual = final_tags if final_tags else None
+        url_obj.save()
+
 
 class CuratedURLViewSet(CollectionFilterMixin, viewsets.ModelViewSet):
     queryset = CuratedUrl.objects.all()
@@ -523,15 +633,46 @@ def update_division(self, request, pk=None):
     #         # Create delta URL first
     #         delta_url = curated_url._create_or_update_delta()
 
-    #         # Then apply operation to the delta
+    #         # Then apply tag operations to the delta
     #         pattern, created = DeltaTdammTagPattern.objects.get_or_create(
     #             collection=curated_url.collection,
     #             match_pattern=curated_url.url,
     #             match_pattern_type=1,
-    #             tag=tag,
     #             operation=OperationChoices.ADD,
     #             source=source,
+    #             defaults={"tags": [tag]},
     #         )
+
+    #         if not created:
+    #             # Add tag if not already present
+    #             current_tags = pattern.tags or []
+    #             if tag not in current_tags:
+    #                 pattern.tags = current_tags + [tag]
+    #                 pattern.save()
+
+    #         if not created:
+    #             # Add tag if not already present
+    #             current_tags = pattern.tags or []
+    #             if tag not in current_tags:
+    #                 pattern.tags = current_tags + [tag]
+    #                 pattern.save()
+
+    #         # Remove from REMOVE pattern if it exists
+    #         remove_pattern = DeltaTdammTagPattern.objects.filter(
+    #             collection=delta_url.collection,
+    #             match_pattern=delta_url.url,
+    #             operation=OperationChoices.REMOVE,
+    #             source=source,
+    #         ).first()
+
+    #         if remove_pattern and remove_pattern.tags and tag in remove_pattern.tags:
+    #             # Remove this tag from the remove pattern
+    #             remove_pattern.tags = [t for t in remove_pattern.tags if t != tag]
+    #             if not remove_pattern.tags:
+    #                 remove_pattern.delete()
+    #             else:
+    #                 remove_pattern.save()
+
     #         pattern._apply_tag_operation(delta_url)
 
     #         # Clean up if delta becomes identical to curated
@@ -556,34 +697,11 @@ def add_tag(self, request, pk=None):
             # Create delta URL first
             delta_url = curated_url._create_or_update_delta()
 
-            # Then apply tag operations to the delta
-            pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+            # Check for existing remove pattern with this tag
+            remove_pattern = DeltaTdammTagPattern.objects.filter(
                 collection=curated_url.collection,
                 match_pattern=curated_url.url,
                 match_pattern_type=1,
-                operation=OperationChoices.ADD,
-                source=source,
-                defaults={"tags": [tag]},
-            )
-
-            if not created:
-                # Add tag if not already present
-                current_tags = pattern.tags or []
-                if tag not in current_tags:
-                    pattern.tags = current_tags + [tag]
-                    pattern.save()
-
-            if not created:
-                # Add tag if not already present
-                current_tags = pattern.tags or []
-                if tag not in current_tags:
-                    pattern.tags = current_tags + [tag]
-                    pattern.save()
-
-            # Remove from REMOVE pattern if it exists
-            remove_pattern = DeltaTdammTagPattern.objects.filter(
-                collection=delta_url.collection,
-                match_pattern=delta_url.url,
                 operation=OperationChoices.REMOVE,
                 source=source,
             ).first()
@@ -595,8 +713,28 @@ def add_tag(self, request, pk=None):
                     remove_pattern.delete()
                 else:
                     remove_pattern.save()
+                    # Apply the modified remove pattern
+                    remove_pattern._apply_tag_operation(delta_url)
 
-            pattern._apply_tag_operation(delta_url)
+            # Get or create add pattern
+            add_pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+                collection=curated_url.collection,
+                match_pattern=curated_url.url,
+                match_pattern_type=1,
+                operation=OperationChoices.ADD,
+                source=source,
+                defaults={"tags": [tag]},
+            )
+
+            if not created:
+                # Add tag if not already present
+                current_tags = add_pattern.tags or []
+                if tag not in current_tags:
+                    add_pattern.tags = current_tags + [tag]
+                    add_pattern.save()
+
+            # Always apply the add pattern
+            add_pattern._apply_tag_operation(delta_url)
 
             # Clean up if delta becomes identical to curated
             if not delta_url.to_delete and delta_url._fields_match(curated_url):
@@ -620,15 +758,40 @@ def add_tag(self, request, pk=None):
     #         # Create delta URL first
     #         delta_url = curated_url._create_or_update_delta()
 
-    #         # Then apply operation to the delta
+    #         # Create or get a pattern for tag removal
     #         pattern, created = DeltaTdammTagPattern.objects.get_or_create(
     #             collection=curated_url.collection,
     #             match_pattern=curated_url.url,
     #             match_pattern_type=1,
-    #             tag=tag,
-    #             operation=OperationChoices.REMOVE,
+    #             operation=DeltaTdammTagPattern.OperationChoices.REMOVE,
     #             source=source,
+    #             defaults={"tags": [tag]},
     #         )
+
+    #         if not created:
+    #             # Add tag to removal list if not already present
+    #             current_tags = pattern.tags or []
+    #             if tag not in current_tags:
+    #                 pattern.tags = current_tags + [tag]
+    #                 pattern.save()
+
+    #         # Check for and update ADD pattern if it exists
+    #         add_pattern = DeltaTdammTagPattern.objects.filter(
+    #             collection=curated_url.collection,
+    #             match_pattern=curated_url.url,
+    #             operation=DeltaTdammTagPattern.OperationChoices.ADD,
+    #             source=source,
+    #         ).first()
+
+    #         if add_pattern and add_pattern.tags and tag in add_pattern.tags:
+    #             # Remove tag from add pattern
+    #             add_pattern.tags = [t for t in add_pattern.tags if t != tag]
+    #             if not add_pattern.tags:
+    #                 add_pattern.delete()
+    #             else:
+    #                 add_pattern.save()
+
+    #         # Apply the pattern
     #         pattern._apply_tag_operation(delta_url)
 
     #         # Clean up if delta becomes identical to curated
@@ -653,41 +816,55 @@ def remove_tag(self, request, pk=None):
             # Create delta URL first
             delta_url = curated_url._create_or_update_delta()
 
-            # Create or get a pattern for tag removal
-            pattern, created = DeltaTdammTagPattern.objects.get_or_create(
-                collection=curated_url.collection,
-                match_pattern=curated_url.url,
-                match_pattern_type=1,
-                operation=DeltaTdammTagPattern.OperationChoices.REMOVE,
-                source=source,
-                defaults={"tags": [tag]},
-            )
-
-            if not created:
-                # Add tag to removal list if not already present
-                current_tags = pattern.tags or []
-                if tag not in current_tags:
-                    pattern.tags = current_tags + [tag]
-                    pattern.save()
+            # Get current tags
+            current_tags = delta_url.tdamm_tag_manual or []
 
-            # Check for and update ADD pattern if it exists
+            # Check if there's an add pattern with this tag
             add_pattern = DeltaTdammTagPattern.objects.filter(
-                collection=curated_url.collection,
-                match_pattern=curated_url.url,
-                operation=DeltaTdammTagPattern.OperationChoices.ADD,
+                collection=delta_url.collection,
+                match_pattern=delta_url.url,
+                match_pattern_type=1,
+                operation=OperationChoices.ADD,
                 source=source,
             ).first()
 
             if add_pattern and add_pattern.tags and tag in add_pattern.tags:
-                # Remove tag from add pattern
+                # Remove tag from ADD pattern
                 add_pattern.tags = [t for t in add_pattern.tags if t != tag]
+
+                # Delete pattern if empty, otherwise save it
                 if not add_pattern.tags:
                     add_pattern.delete()
                 else:
                     add_pattern.save()
 
-            # Apply the pattern
-            pattern._apply_tag_operation(delta_url)
+                # Directly remove the tag from the URL
+                if tag in current_tags:
+                    delta_url.tdamm_tag_manual = [t for t in current_tags if t != tag]
+                    delta_url.save()
+
+            # If tag still exists in URL, create a REMOVE pattern
+            elif tag in current_tags or tag in (curated_url.tdamm_tag_manual or []):
+                remove_pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+                    collection=curated_url.collection,
+                    match_pattern=curated_url.url,
+                    match_pattern_type=1,
+                    operation=OperationChoices.REMOVE,
+                    source=source,
+                    defaults={"tags": [tag]},
+                )
+
+                if not created:
+                    if tag not in (remove_pattern.tags or []):
+                        remove_pattern.tags = (remove_pattern.tags or []) + [tag]
+                        remove_pattern.save()
+
+                # Directly remove the tag from the delta URL
+                delta_url.tdamm_tag_manual = [t for t in current_tags if t != tag]
+                delta_url.save()
+
+            # Force refresh all patterns for this URL
+            self._refresh_url_tags(delta_url)
 
             # Clean up if delta becomes identical to curated
             if not delta_url.to_delete and delta_url._fields_match(curated_url):
@@ -698,6 +875,34 @@ def remove_tag(self, request, pk=None):
             logger.error(f"Error occurred: {str(e)}")
             return Response({"error": "An internal error has occurred."}, status=500)
 
+    def _refresh_url_tags(self, url_obj):
+        """Refresh URL tags by reapplying all patterns affecting this URL."""
+        # Get all patterns affecting this URL
+        add_patterns = DeltaTdammTagPattern.objects.filter(
+            collection=url_obj.collection, delta_urls=url_obj, operation=OperationChoices.ADD
+        )
+
+        remove_patterns = DeltaTdammTagPattern.objects.filter(
+            collection=url_obj.collection, delta_urls=url_obj, operation=OperationChoices.REMOVE
+        )
+
+        # Collect all tags from ADD patterns
+        add_tags = set()
+        for pattern in add_patterns:
+            add_tags.update(pattern.tags or [])
+
+        # Collect all tags from REMOVE patterns
+        remove_tags = set()
+        for pattern in remove_patterns:
+            remove_tags.update(pattern.tags or [])
+
+        # Final tags = (add tags) - (remove tags)
+        final_tags = list(add_tags - remove_tags)
+
+        # Update URL tags
+        url_obj.tdamm_tag_manual = final_tags if final_tags else None
+        url_obj.save()
+
 
 class DeltaURLBulkCreateView(generics.ListCreateAPIView):
     queryset = DeltaUrl.objects.all()

From 10eba72fea5b413085cfe580fdc70470a609af7a Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanurjsharma@gmail.com>
Date: Wed, 2 Apr 2025 16:56:26 -0500
Subject: [PATCH 34/35] Updated unapply and _apply_tag_operation

---
 sde_collections/models/delta_patterns.py | 214 ++++++++++++++---------
 1 file changed, 127 insertions(+), 87 deletions(-)

diff --git a/sde_collections/models/delta_patterns.py b/sde_collections/models/delta_patterns.py
index e650d2a6..a0f361e3 100644
--- a/sde_collections/models/delta_patterns.py
+++ b/sde_collections/models/delta_patterns.py
@@ -831,57 +831,80 @@ def apply(self):
 
     def unapply(self):
         """Remove tag operation effects with comprehensive handling for multiple tags."""
-        DeltaUrl = apps.get_model("sde_collections", "DeltaUrl")
+        # DeltaUrl = apps.get_model("sde_collections", "DeltaUrl")
         CuratedUrl = apps.get_model("sde_collections", "CuratedUrl")
 
         # Store affected URLs
-        affected_urls = [(delta.id, delta.url) for delta in self.delta_urls.all()]
+        affected_urls = list(self.delta_urls.all())
 
-        # Clear relationships
+        # Clear relationship before deleting to avoid cascade issues
         self.delta_urls.clear()
         self.curated_urls.clear()
 
         # Process each affected URL
-        for delta_id, url in affected_urls:
-            try:
-                delta = DeltaUrl.objects.get(id=delta_id)
-                curated = CuratedUrl.objects.get(collection=delta.collection, url=url)
-
-                # Revert tags based on operation
-                if delta.tdamm_tag_manual:
-                    if self.operation == self.OperationChoices.ADD:
-                        # Remove the tags we added
-                        delta.tdamm_tag_manual = [t for t in delta.tdamm_tag_manual if t not in self.tags]
-                    elif self.operation == self.OperationChoices.REMOVE:
-                        # Add back tags that were in ML but we removed
-                        ml_tags = delta.tdamm_tag_ml or []
-                        for tag in self.tags:
-                            if tag in ml_tags and tag not in (delta.tdamm_tag_manual or []):
-                                if not delta.tdamm_tag_manual:
-                                    delta.tdamm_tag_manual = []
-                                delta.tdamm_tag_manual.append(tag)
-
-                    if not delta.tdamm_tag_manual:
-                        delta.tdamm_tag_manual = None
+        for delta_url in affected_urls:
+            current_tags = delta_url.tdamm_tag_manual or []
+            changed = False
+
+            # If it was an ADD pattern, remove these tags
+            if self.operation == OperationChoices.ADD and self.tags:
+                # Remove all tags that were added by this pattern
+                new_tags = [t for t in current_tags if t not in self.tags]
+                if new_tags != current_tags:
+                    delta_url.tdamm_tag_manual = new_tags if new_tags else None
+                    changed = True
 
-                    delta.save()
+            # If it was a REMOVE pattern, we don't need to add back tags automatically
+            # Other patterns will be reapplied by refresh_url_tags below
 
-                # Check ALL pattern types that might affect this URL
-                other_patterns_exist = (
-                    DeltaExcludePattern.objects.filter(delta_urls=delta).exists()
-                    or DeltaIncludePattern.objects.filter(delta_urls=delta).exists()
-                    or DeltaTitlePattern.objects.filter(delta_urls=delta).exists()
-                    or DeltaDocumentTypePattern.objects.filter(delta_urls=delta).exists()
-                    or DeltaDivisionPattern.objects.filter(delta_urls=delta).exists()
-                    or DeltaTdammTagPattern.objects.filter(delta_urls=delta).exists()
-                )
+            if changed:
+                delta_url.save()
 
-                # Only delete if no other patterns affect it AND it matches curated
-                if not other_patterns_exist and delta._fields_match(curated) and not delta.to_delete:
-                    DeltaUrl.objects.filter(id=delta_id).delete()
+            # Refresh all patterns for this URL to ensure consistency
+            self._refresh_url_tags(delta_url)
 
-            except (DeltaUrl.DoesNotExist, CuratedUrl.DoesNotExist):
-                continue
+            # Check for cleanup
+            try:
+                curated_url = CuratedUrl.objects.get(collection=delta_url.collection, url=delta_url.url)
+                if not delta_url.to_delete and delta_url._fields_match(curated_url):
+                    delta_url.delete()
+            except CuratedUrl.DoesNotExist:
+                pass
+
+    def _refresh_url_tags(self, url_obj):
+        """Refresh URL tags by reapplying all patterns affecting this URL."""
+        DeltaTdammTagPattern = apps.get_model("sde_collections", "DeltaTdammTagPattern")
+
+        # Get all patterns affecting this URL
+        add_patterns = DeltaTdammTagPattern.objects.filter(
+            collection=self.collection, delta_urls=url_obj, operation=OperationChoices.ADD
+        ).exclude(
+            id=self.id
+        )  # Exclude this pattern
+
+        remove_patterns = DeltaTdammTagPattern.objects.filter(
+            collection=self.collection, delta_urls=url_obj, operation=OperationChoices.REMOVE
+        ).exclude(
+            id=self.id
+        )  # Exclude this pattern
+
+        # Collect all tags from ADD patterns
+        add_tags = set()
+        for pattern in add_patterns:
+            add_tags.update(pattern.tags or [])
+
+        # Collect all tags from REMOVE patterns
+        remove_tags = set()
+        for pattern in remove_patterns:
+            remove_tags.update(pattern.tags or [])
+
+        # Final tags = (add tags) - (remove tags)
+        final_tags = list(add_tags - remove_tags)
+
+        # Update URL tags
+        if set(url_obj.tdamm_tag_manual or []) != set(final_tags):
+            url_obj.tdamm_tag_manual = final_tags if final_tags else None
+            url_obj.save()
 
     def _would_operation_change_tags(self, url_obj):
         """Determine if applying the operation would change the tags."""
@@ -905,79 +928,96 @@ def _would_operation_change_tags(self, url_obj):
             )
 
     # def _apply_tag_operation(self, url_obj):
-    #     """Apply the tag operation with proper ML copying logic."""
-    #     ml_tags = url_obj.tdamm_tag_ml or []
     #     manual_tags = url_obj.tdamm_tag_manual or []
     #     changed = False
 
-    #     if self.operation == self.OperationChoices.ADD:  # for the add operation
-    #         if self.source == "ml":
-    #             # Copy ML tags to manual and add new tag
-    #             current_tags = ml_tags or []
-    #             new_tags = list(current_tags)
-    #             if self.tag not in new_tags:
-    #                 new_tags.append(self.tag)
-    #                 url_obj.tdamm_tag_manual = new_tags
-    #                 changed = True
-    #         else:  # 'manual'
-    #             # Add directly to manual tags
-    #             current_tags = manual_tags or []
-    #             if self.tag not in current_tags:
-    #                 current_tags.append(self.tag)
-    #                 url_obj.tdamm_tag_manual = current_tags
+    #     print(f"Applying operation {self.operation} to URL: {url_obj.url}")
+    #     print(f"Pattern tags: {self.tags}")
+    #     print(f"Current manual tags: {manual_tags}")
+
+    #     if self.operation == OperationChoices.ADD:
+    #         # Add all tags in the list
+    #         current_tags = manual_tags or []
+    #         for tag in self.tags:
+    #             if tag not in current_tags:
+    #                 current_tags.append(tag)
     #                 changed = True
-    #     else:  # for the remove operation
-    #         if self.source == "ml":
-    #             # Copy ML tags minus the removed tag
-    #             if ml_tags:
-    #                 new_manual_tags = [t for t in ml_tags if t != self.tag]
-    #                 if not manual_tags or set(manual_tags) != set(new_manual_tags):
-    #                     url_obj.tdamm_tag_manual = new_manual_tags
-    #                     changed = True
-    #         else:  # 'manual'
-    #             # Remove directly from manual tags
-    #             if manual_tags and self.tag in manual_tags:
-    #                 manual_tags.remove(self.tag)
-    #                 url_obj.tdamm_tag_manual = manual_tags
+    #         if changed:
+    #             print(f"New tags after ADD: {current_tags}")
+    #             url_obj.tdamm_tag_manual = current_tags
+    #     else:  # REMOVE
+    #         # Remove all tags in the list
+    #         if manual_tags:
+    #             new_tags = [t for t in manual_tags if t not in self.tags]
+    #             if new_tags != manual_tags:
+    #                 print(f"New tags after REMOVE: {new_tags}")
+    #                 url_obj.tdamm_tag_manual = new_tags
     #                 changed = True
 
     #     if changed:
     #         url_obj.save()
     #         if hasattr(url_obj, "_cleanup_if_needed"):
     #             url_obj._cleanup_if_needed()
+    #         print(f"URL saved with new tags: {url_obj.tdamm_tag_manual}")
 
     def _apply_tag_operation(self, url_obj):
+        """Apply tag operations to the URL with proper synchronization."""
         manual_tags = url_obj.tdamm_tag_manual or []
         changed = False
 
-        print(f"Applying operation {self.operation} to URL: {url_obj.url}")
-        print(f"Pattern tags: {self.tags}")
-        print(f"Current manual tags: {manual_tags}")
+        # Ensure tags is a list, not None
+        self.tags = self.tags or []
 
         if self.operation == OperationChoices.ADD:
-            # Add all tags in the list
-            current_tags = manual_tags or []
-            for tag in self.tags:
-                if tag not in current_tags:
-                    current_tags.append(tag)
-                    changed = True
-            if changed:
-                print(f"New tags after ADD: {current_tags}")
-                url_obj.tdamm_tag_manual = current_tags
-        else:  # REMOVE
-            # Remove all tags in the list
+            # For ADD operations, we want to synchronize the tags
+            # This means the URL should have exactly the tags in the pattern
+            # Get tags from all ADD patterns that apply to this URL
+            all_add_tags = set(self.tags)
+
+            # Find all other ADD patterns for this URL
+            other_add_patterns = DeltaTdammTagPattern.objects.filter(
+                collection=self.collection,
+                operation=OperationChoices.ADD,
+                delta_urls__id=url_obj.id,  # This pattern applies to this URL
+            ).exclude(id=self.id)
+
+            # Add tags from other applicable ADD patterns
+            for pattern in other_add_patterns:
+                all_add_tags.update(pattern.tags or [])
+
+            # Find all REMOVE patterns for this URL
+            remove_patterns = DeltaTdammTagPattern.objects.filter(
+                collection=self.collection,
+                operation=OperationChoices.REMOVE,
+                delta_urls__id=url_obj.id,  # This pattern applies to this URL
+            )
+
+            # Remove tags specified by REMOVE patterns
+            remove_tags = set()
+            for pattern in remove_patterns:
+                remove_tags.update(pattern.tags or [])
+
+            # Final tags = (all add tags) - (all remove tags)
+            final_tags = list(all_add_tags - remove_tags)
+
+            # Update if different from current tags
+            if set(final_tags) != set(manual_tags):
+                url_obj.tdamm_tag_manual = final_tags
+                changed = True
+
+        elif self.operation == OperationChoices.REMOVE:
+            # For REMOVE operations, just remove the tags
             if manual_tags:
                 new_tags = [t for t in manual_tags if t not in self.tags]
-                if new_tags != manual_tags:
-                    print(f"New tags after REMOVE: {new_tags}")
-                    url_obj.tdamm_tag_manual = new_tags
+                if len(new_tags) != len(manual_tags):
+                    url_obj.tdamm_tag_manual = new_tags if new_tags else None
                     changed = True
 
+        # Save changes
         if changed:
             url_obj.save()
             if hasattr(url_obj, "_cleanup_if_needed"):
                 url_obj._cleanup_if_needed()
-            print(f"URL saved with new tags: {url_obj.tdamm_tag_manual}")
 
     def _revert_tag_operation(self, url_obj):
         """Revert the effects of the tag operation."""

From 0d2df052dc61b2b838ff7646b76e2c9acc766eeb Mon Sep 17 00:00:00 2001
From: Dhanur Sharma <dhanurjsharma@gmail.com>
Date: Thu, 3 Apr 2025 18:36:33 -0500
Subject: [PATCH 35/35] add_tag functional

---
 sde_collections/views.py | 594 ++++++++++++++++++++++++++-------------
 1 file changed, 394 insertions(+), 200 deletions(-)

diff --git a/sde_collections/views.py b/sde_collections/views.py
index 3917e9bd..c2f9dc29 100644
--- a/sde_collections/views.py
+++ b/sde_collections/views.py
@@ -393,49 +393,101 @@ def add_tag(self, request, pk=None):
             return Response({"error": "Tag not specified"}, status=400)
 
         try:
-            # Check for existing remove pattern with this tag
-            remove_pattern = DeltaTdammTagPattern.objects.filter(
-                collection=delta_url.collection,
-                match_pattern=delta_url.url,
-                match_pattern_type=1,
-                operation=OperationChoices.REMOVE,
-                source=source,
-            ).first()
-
-            if remove_pattern and remove_pattern.tags and tag in remove_pattern.tags:
-                # Remove the tag from the remove pattern
-                remove_pattern.tags = [t for t in remove_pattern.tags if t != tag]
-                if not remove_pattern.tags:
-                    remove_pattern.delete()
-                else:
-                    remove_pattern.save()
-                    # Apply the modified remove pattern
-                    remove_pattern._apply_tag_operation(delta_url)
+            # Get current manual and ML tags
+            manual_tags = delta_url.tdamm_tag_manual
+            ml_tags = delta_url.tdamm_tag_ml or []
+
+            logger.info(f"Adding tag '{tag}' to URL: {delta_url.url}")
+            logger.info(f"Current manual tags: {manual_tags}")
+            logger.info(f"Current ML tags: {ml_tags}")
+
+            # STEP 1: Update URL's manual tags
+
+            # Case 3: No manual tags, but ML tags exist - copy ML tags to manual
+            if (manual_tags is None or len(manual_tags) == 0) and ml_tags:
+                logger.info("No manual tags, but ML tags exist - copying ML tags to manual")
+                working_tags = list(ml_tags)
+            # Case 1 & 2: Empty or existing manual tags
+            else:
+                working_tags = list(manual_tags) if manual_tags is not None else []
+
+            # Add the new tag if not already present
+            if tag not in working_tags:
+                working_tags.append(tag)
+                delta_url.tdamm_tag_manual = working_tags
+                delta_url.save()
+                logger.info(f"Updated URL tags to: {working_tags}")
+
+            # STEP 2: Find or update ADD pattern
+
+            # Look for existing ADD patterns for this URL
+            existing_patterns = list(
+                DeltaTdammTagPattern.objects.filter(
+                    collection=delta_url.collection,
+                    match_pattern=delta_url.url,
+                    match_pattern_type=1,
+                    operation=OperationChoices.ADD,
+                )
+            )
+
+            logger.info(f"Found {len(existing_patterns)} existing ADD patterns")
+
+            # Update existing pattern or create new one
+            if existing_patterns:
+                # Use the first pattern found
+                add_pattern = existing_patterns[0]
+                logger.info(f"Updating existing pattern {add_pattern.id}, current tags: {add_pattern.tags}")
+
+                # Ensure pattern has all current tags
+                pattern_tags = set(add_pattern.tags or [])
+                for current_tag in working_tags:
+                    pattern_tags.add(current_tag)
+
+                add_pattern.tags = list(pattern_tags)
+                add_pattern.source = source  # Update source to match current request
+                add_pattern.save()
+                logger.info(f"Updated pattern tags to: {add_pattern.tags}")
+
+                # Delete any other duplicate patterns
+                for pattern in existing_patterns[1:]:
+                    logger.info(f"Deleting duplicate pattern {pattern.id}")
+                    pattern.delete()
+            else:
+                # Create a new pattern with all working tags
+                logger.info(f"Creating new ADD pattern with tags: {working_tags}")
+                add_pattern = DeltaTdammTagPattern.objects.create(
+                    collection=delta_url.collection,
+                    match_pattern=delta_url.url,
+                    match_pattern_type=1,
+                    operation=OperationChoices.ADD,
+                    source=source,
+                    tags=working_tags,
+                )
+                logger.info(f"Created pattern {add_pattern.id}")
 
-            # Check for existing add pattern
-            add_pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+            # STEP 3: Check for and update any REMOVE patterns
+
+            remove_patterns = DeltaTdammTagPattern.objects.filter(
                 collection=delta_url.collection,
                 match_pattern=delta_url.url,
                 match_pattern_type=1,
-                operation=OperationChoices.ADD,
-                source=source,
-                defaults={"tags": [tag]},
+                operation=OperationChoices.REMOVE,
             )
 
-            if not created:
-                # Add tag if not already present
-                current_tags = add_pattern.tags or []
-                if tag not in current_tags:
-                    add_pattern.tags = current_tags + [tag]
-                    add_pattern.save()
-
-            # Always apply the add pattern
-            add_pattern._apply_tag_operation(delta_url)
+            for remove_pattern in remove_patterns:
+                if remove_pattern.tags and tag in remove_pattern.tags:
+                    remove_pattern.tags = [t for t in remove_pattern.tags if t != tag]
+                    if not remove_pattern.tags:
+                        logger.info(f"Deleting empty REMOVE pattern {remove_pattern.id}")
+                        remove_pattern.delete()
+                    else:
+                        logger.info(f"Updated REMOVE pattern {remove_pattern.id} to {remove_pattern.tags}")
+                        remove_pattern.save()
 
             return Response({"status": "success"})
         except Exception as e:
             logger.error(f"Error occurred: {str(e)}")
-            return Response({"error": "An internal error has occurred."}, status=500)
+            return Response({"error": f"An internal error has occurred: {str(e)}"}, status=500)
 
     # @action(detail=True, methods=["post"], url_path="remove_tag")
     # def remove_tag(self, request, pk=None):
@@ -500,95 +552,133 @@ def remove_tag(self, request, pk=None):
 
         try:
             # Get current tags
-            current_tags = delta_url.tdamm_tag_manual or []
-
-            # Check if there's an add pattern with this tag
-            add_pattern = DeltaTdammTagPattern.objects.filter(
-                collection=delta_url.collection,
-                match_pattern=delta_url.url,
-                match_pattern_type=1,
-                operation=OperationChoices.ADD,
-                source=source,
-            ).first()
-
-            if add_pattern and add_pattern.tags and tag in add_pattern.tags:
-                # Remove tag from ADD pattern
-                add_pattern.tags = [t for t in add_pattern.tags if t != tag]
-
-                # Delete pattern if empty, otherwise save it
-                if not add_pattern.tags:
-                    add_pattern.delete()
-                else:
-                    add_pattern.save()
+            manual_tags = delta_url.tdamm_tag_manual or []
+            ml_tags = delta_url.tdamm_tag_ml or []
 
-                # Important: Directly remove the tag from the URL
-                if tag in current_tags:
-                    delta_url.tdamm_tag_manual = [t for t in current_tags if t != tag]
-                    delta_url.save()
+            # First, let's log what patterns exist for debugging
+            logger.info(f"Looking for patterns matching URL: {delta_url.url}")
 
-                    # Explicitly call cleanup
-                    if hasattr(delta_url, "_cleanup_if_needed"):
-                        delta_url._cleanup_if_needed()
-
-            # If tag still exists in URL, create a REMOVE pattern
-            elif tag in current_tags:
-                remove_pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+            # Find ALL add patterns that might contain this tag
+            add_patterns = list(
+                DeltaTdammTagPattern.objects.filter(
                     collection=delta_url.collection,
                     match_pattern=delta_url.url,
                     match_pattern_type=1,
-                    operation=OperationChoices.REMOVE,
+                    operation=OperationChoices.ADD,
                     source=source,
-                    defaults={"tags": [tag]},
                 )
+            )
 
-                if not created:
-                    if tag not in (remove_pattern.tags or []):
-                        remove_pattern.tags = (remove_pattern.tags or []) + [tag]
-                        remove_pattern.save()
+            logger.info(f"Found {len(add_patterns)} ADD patterns")
+            for pat in add_patterns:
+                logger.info(f"ADD pattern {pat.id}: tags={pat.tags}")
 
-                # Directly remove the tag from the URL
-                delta_url.tdamm_tag_manual = [t for t in current_tags if t != tag]
+            # Flag to track if we modified an ADD pattern
+            modified_add_pattern = False
+
+            # Check ALL add patterns (there might be duplicates)
+            for add_pattern in add_patterns:
+                if add_pattern.tags and tag in add_pattern.tags:
+                    logger.info(f"Modifying ADD pattern {add_pattern.id}")
+
+                    # Remove the tag from the pattern's tags
+                    add_pattern.tags = [t for t in add_pattern.tags if t != tag]
+
+                    # Save or delete the pattern
+                    if not add_pattern.tags:
+                        logger.info(f"Deleting empty ADD pattern {add_pattern.id}")
+                        add_pattern.delete()
+                    else:
+                        logger.info(f"Saving ADD pattern {add_pattern.id} with tags {add_pattern.tags}")
+                        add_pattern.save()
+
+                    modified_add_pattern = True
+
+            # Always update the URL's tags to remove the tag
+            if tag in manual_tags:
+                new_tags = [t for t in manual_tags if t != tag]
+                # Set to None if empty, not empty list
+                delta_url.tdamm_tag_manual = new_tags if new_tags else None
                 delta_url.save()
+                logger.info(f"Updated URL tags: {delta_url.tdamm_tag_manual}")
+
+            # If we modified an ADD pattern, we're done - no need for a REMOVE pattern
+            if modified_add_pattern:
+                return Response({"status": "success"})
+
+            # Only create a REMOVE pattern if tag is in ML tags
+            if tag in ml_tags:
+                logger.info(f"Creating/updating REMOVE pattern for ML tag {tag}")
+
+                # Find existing REMOVE patterns
+                remove_patterns = list(
+                    DeltaTdammTagPattern.objects.filter(
+                        collection=delta_url.collection,
+                        match_pattern=delta_url.url,
+                        match_pattern_type=1,
+                        operation=OperationChoices.REMOVE,
+                        source=source,
+                    )
+                )
 
-                # Explicitly call cleanup
-                if hasattr(delta_url, "_cleanup_if_needed"):
-                    delta_url._cleanup_if_needed()
+                logger.info(f"Found {len(remove_patterns)} REMOVE patterns")
 
-            # Force refresh all patterns for this URL to ensure consistency
-            self._refresh_url_tags(delta_url)
+                if remove_patterns:
+                    # Update the first REMOVE pattern
+                    remove_pattern = remove_patterns[0]
+                    current_tags = remove_pattern.tags or []
+                    if tag not in current_tags:
+                        remove_pattern.tags = current_tags + [tag]
+                        remove_pattern.save()
+                        logger.info(f"Updated REMOVE pattern {remove_pattern.id} with tags {remove_pattern.tags}")
+                else:
+                    # Create new REMOVE pattern
+                    remove_pattern = DeltaTdammTagPattern.objects.create(
+                        collection=delta_url.collection,
+                        match_pattern=delta_url.url,
+                        match_pattern_type=1,
+                        operation=OperationChoices.REMOVE,
+                        source=source,
+                        tags=[tag],
+                    )
+                    logger.info(f"Created new REMOVE pattern {remove_pattern.id} with tag {tag}")
+
+            # Call cleanup if needed
+            if hasattr(delta_url, "_cleanup_if_needed"):
+                delta_url._cleanup_if_needed()
 
             return Response({"status": "success"})
         except Exception as e:
             logger.error(f"Error occurred: {str(e)}")
-            return Response({"error": "An internal error has occurred."}, status=500)
+            return Response({"error": f"An internal error has occurred: {str(e)}"}, status=500)
 
-    def _refresh_url_tags(self, url_obj):
-        """Refresh URL tags by reapplying all patterns affecting this URL."""
-        # Get all patterns affecting this URL
-        add_patterns = DeltaTdammTagPattern.objects.filter(
-            collection=url_obj.collection, delta_urls=url_obj, operation=OperationChoices.ADD
-        )
+    # def _refresh_url_tags(self, url_obj):
+    #     """Refresh URL tags by reapplying all patterns affecting this URL."""
+    #     # Get all patterns affecting this URL
+    #     add_patterns = DeltaTdammTagPattern.objects.filter(
+    #         collection=url_obj.collection, delta_urls=url_obj, operation=OperationChoices.ADD
+    #     )
 
-        remove_patterns = DeltaTdammTagPattern.objects.filter(
-            collection=url_obj.collection, delta_urls=url_obj, operation=OperationChoices.REMOVE
-        )
+    #     remove_patterns = DeltaTdammTagPattern.objects.filter(
+    #         collection=url_obj.collection, delta_urls=url_obj, operation=OperationChoices.REMOVE
+    #     )
 
-        # Collect all tags from ADD patterns
-        add_tags = set()
-        for pattern in add_patterns:
-            add_tags.update(pattern.tags or [])
+    #     # Collect all tags from ADD patterns
+    #     add_tags = set()
+    #     for pattern in add_patterns:
+    #         add_tags.update(pattern.tags or [])
 
-        # Collect all tags from REMOVE patterns
-        remove_tags = set()
-        for pattern in remove_patterns:
-            remove_tags.update(pattern.tags or [])
+    #     # Collect all tags from REMOVE patterns
+    #     remove_tags = set()
+    #     for pattern in remove_patterns:
+    #         remove_tags.update(pattern.tags or [])
 
-        # Final tags = (add tags) - (remove tags)
-        final_tags = list(add_tags - remove_tags)
+    #     # Final tags = (add tags) - (remove tags)
+    #     final_tags = list(add_tags - remove_tags)
 
-        # Update URL tags
-        url_obj.tdamm_tag_manual = final_tags if final_tags else None
-        url_obj.save()
+    #     # Update URL tags
+    #     url_obj.tdamm_tag_manual = final_tags if final_tags else None
+    #     url_obj.save()
 
 
 class CuratedURLViewSet(CollectionFilterMixin, viewsets.ModelViewSet):
@@ -697,53 +787,106 @@ def add_tag(self, request, pk=None):
             # Create delta URL first
             delta_url = curated_url._create_or_update_delta()
 
-            # Check for existing remove pattern with this tag
-            remove_pattern = DeltaTdammTagPattern.objects.filter(
-                collection=curated_url.collection,
-                match_pattern=curated_url.url,
-                match_pattern_type=1,
-                operation=OperationChoices.REMOVE,
-                source=source,
-            ).first()
-
-            if remove_pattern and remove_pattern.tags and tag in remove_pattern.tags:
-                # Remove this tag from the remove pattern
-                remove_pattern.tags = [t for t in remove_pattern.tags if t != tag]
-                if not remove_pattern.tags:
-                    remove_pattern.delete()
-                else:
-                    remove_pattern.save()
-                    # Apply the modified remove pattern
-                    remove_pattern._apply_tag_operation(delta_url)
+            # Get current manual and ML tags
+            manual_tags = delta_url.tdamm_tag_manual
+            ml_tags = curated_url.tdamm_tag_ml or []
+
+            logger.info(f"Adding tag '{tag}' to URL: {curated_url.url}")
+            logger.info(f"Current manual tags: {manual_tags}")
+            logger.info(f"Current ML tags: {ml_tags}")
+
+            # STEP 1: Update URL's manual tags
+
+            # Case 3: No manual tags, but ML tags exist - copy ML tags to manual
+            if (manual_tags is None or len(manual_tags) == 0) and ml_tags:
+                logger.info("No manual tags, but ML tags exist - copying ML tags to manual")
+                working_tags = list(ml_tags)
+            # Case 1 & 2: Empty or existing manual tags
+            else:
+                working_tags = list(manual_tags) if manual_tags is not None else []
+
+            # Add the new tag if not already present
+            if tag not in working_tags:
+                working_tags.append(tag)
+                delta_url.tdamm_tag_manual = working_tags
+                delta_url.save()
+                logger.info(f"Updated URL tags to: {working_tags}")
+
+            # STEP 2: Find or update ADD pattern
+
+            # Look for existing ADD patterns for this URL
+            existing_patterns = list(
+                DeltaTdammTagPattern.objects.filter(
+                    collection=curated_url.collection,
+                    match_pattern=curated_url.url,
+                    match_pattern_type=1,
+                    operation=OperationChoices.ADD,
+                )
+            )
 
-            # Get or create add pattern
-            add_pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+            logger.info(f"Found {len(existing_patterns)} existing ADD patterns")
+
+            # Update existing pattern or create new one
+            if existing_patterns:
+                # Use the first pattern found
+                add_pattern = existing_patterns[0]
+                logger.info(f"Updating existing pattern {add_pattern.id}, current tags: {add_pattern.tags}")
+
+                # Ensure pattern has all current tags
+                pattern_tags = set(add_pattern.tags or [])
+                for current_tag in working_tags:
+                    pattern_tags.add(current_tag)
+
+                add_pattern.tags = list(pattern_tags)
+                add_pattern.source = source  # Update source to match current request
+                add_pattern.save()
+                logger.info(f"Updated pattern tags to: {add_pattern.tags}")
+
+                # Delete any other duplicate patterns
+                for pattern in existing_patterns[1:]:
+                    logger.info(f"Deleting duplicate pattern {pattern.id}")
+                    pattern.delete()
+            else:
+                # Create a new pattern with all working tags
+                logger.info(f"Creating new ADD pattern with tags: {working_tags}")
+                add_pattern = DeltaTdammTagPattern.objects.create(
+                    collection=curated_url.collection,
+                    match_pattern=curated_url.url,
+                    match_pattern_type=1,
+                    operation=OperationChoices.ADD,
+                    source=source,
+                    tags=working_tags,
+                )
+                logger.info(f"Created pattern {add_pattern.id}")
+
+            # STEP 3: Check for and update any REMOVE patterns
+
+            remove_patterns = DeltaTdammTagPattern.objects.filter(
                 collection=curated_url.collection,
                 match_pattern=curated_url.url,
                 match_pattern_type=1,
-                operation=OperationChoices.ADD,
-                source=source,
-                defaults={"tags": [tag]},
+                operation=OperationChoices.REMOVE,
             )
 
-            if not created:
-                # Add tag if not already present
-                current_tags = add_pattern.tags or []
-                if tag not in current_tags:
-                    add_pattern.tags = current_tags + [tag]
-                    add_pattern.save()
-
-            # Always apply the add pattern
-            add_pattern._apply_tag_operation(delta_url)
+            for remove_pattern in remove_patterns:
+                if remove_pattern.tags and tag in remove_pattern.tags:
+                    remove_pattern.tags = [t for t in remove_pattern.tags if t != tag]
+                    if not remove_pattern.tags:
+                        logger.info(f"Deleting empty REMOVE pattern {remove_pattern.id}")
+                        remove_pattern.delete()
+                    else:
+                        logger.info(f"Updated REMOVE pattern {remove_pattern.id} to {remove_pattern.tags}")
+                        remove_pattern.save()
 
-            # Clean up if delta becomes identical to curated
+            # Clean up delta if it matches curated
             if not delta_url.to_delete and delta_url._fields_match(curated_url):
+                logger.info(f"Deleting delta URL {delta_url.url} as it matches curated URL")
                 delta_url.delete()
 
             return Response({"status": "success"})
         except Exception as e:
             logger.error(f"Error occurred: {str(e)}")
-            return Response({"error": "An internal error has occurred."}, status=500)
+            return Response({"error": f"An internal error has occurred: {str(e)}"}, status=500)
 
     # @action(detail=True, methods=["post"], url_path="remove_tag")
     # def remove_tag(self, request, pk=None):
@@ -817,91 +960,142 @@ def remove_tag(self, request, pk=None):
             delta_url = curated_url._create_or_update_delta()
 
             # Get current tags
-            current_tags = delta_url.tdamm_tag_manual or []
-
-            # Check if there's an add pattern with this tag
-            add_pattern = DeltaTdammTagPattern.objects.filter(
-                collection=delta_url.collection,
-                match_pattern=delta_url.url,
-                match_pattern_type=1,
-                operation=OperationChoices.ADD,
-                source=source,
-            ).first()
-
-            if add_pattern and add_pattern.tags and tag in add_pattern.tags:
-                # Remove tag from ADD pattern
-                add_pattern.tags = [t for t in add_pattern.tags if t != tag]
+            manual_tags = delta_url.tdamm_tag_manual or []
+            ml_tags = curated_url.tdamm_tag_ml or []
 
-                # Delete pattern if empty, otherwise save it
-                if not add_pattern.tags:
-                    add_pattern.delete()
-                else:
-                    add_pattern.save()
-
-                # Directly remove the tag from the URL
-                if tag in current_tags:
-                    delta_url.tdamm_tag_manual = [t for t in current_tags if t != tag]
-                    delta_url.save()
+            # First, let's log what patterns exist for debugging
+            logger.info(f"Looking for patterns matching URL: {curated_url.url}")
 
-            # If tag still exists in URL, create a REMOVE pattern
-            elif tag in current_tags or tag in (curated_url.tdamm_tag_manual or []):
-                remove_pattern, created = DeltaTdammTagPattern.objects.get_or_create(
+            # Find ALL add patterns that might contain this tag
+            add_patterns = list(
+                DeltaTdammTagPattern.objects.filter(
                     collection=curated_url.collection,
                     match_pattern=curated_url.url,
                     match_pattern_type=1,
-                    operation=OperationChoices.REMOVE,
+                    operation=OperationChoices.ADD,
                     source=source,
-                    defaults={"tags": [tag]},
                 )
+            )
 
-                if not created:
-                    if tag not in (remove_pattern.tags or []):
-                        remove_pattern.tags = (remove_pattern.tags or []) + [tag]
-                        remove_pattern.save()
+            logger.info(f"Found {len(add_patterns)} ADD patterns")
+            for pat in add_patterns:
+                logger.info(f"ADD pattern {pat.id}: tags={pat.tags}")
+
+            # Flag to track if we modified an ADD pattern
+            modified_add_pattern = False
+
+            # Check ALL add patterns (there might be duplicates)
+            for add_pattern in add_patterns:
+                if add_pattern.tags and tag in add_pattern.tags:
+                    logger.info(f"Modifying ADD pattern {add_pattern.id}")
+
+                    # Remove the tag from the pattern's tags
+                    add_pattern.tags = [t for t in add_pattern.tags if t != tag]
 
-                # Directly remove the tag from the delta URL
-                delta_url.tdamm_tag_manual = [t for t in current_tags if t != tag]
+                    # Save or delete the pattern
+                    if not add_pattern.tags:
+                        logger.info(f"Deleting empty ADD pattern {add_pattern.id}")
+                        add_pattern.delete()
+                    else:
+                        logger.info(f"Saving ADD pattern {add_pattern.id} with tags {add_pattern.tags}")
+                        add_pattern.save()
+
+                    modified_add_pattern = True
+
+            # Always update the URL's tags to remove the tag
+            if tag in manual_tags:
+                new_tags = [t for t in manual_tags if t != tag]
+                # Set to None if empty, not empty list
+                delta_url.tdamm_tag_manual = new_tags if new_tags else None
                 delta_url.save()
+                logger.info(f"Updated URL tags: {delta_url.tdamm_tag_manual}")
+
+            # If we modified an ADD pattern and there are no tags left, possibly we can delete the delta
+            if modified_add_pattern and (delta_url.tdamm_tag_manual is None or len(delta_url.tdamm_tag_manual) == 0):
+                # Check if the delta can be deleted
+                if not delta_url.to_delete and delta_url._fields_match(curated_url):
+                    logger.info(f"Deleting delta URL {delta_url.id} as it matches curated URL")
+                    delta_url.delete()
+                    return Response({"status": "success"})
+
+            # If we modified an ADD pattern, we're done - no need for a REMOVE pattern
+            if modified_add_pattern:
+                return Response({"status": "success"})
+
+            # Only create a REMOVE pattern if tag is in ML tags
+            if tag in ml_tags:
+                logger.info(f"Creating/updating REMOVE pattern for ML tag {tag}")
+
+                # Find existing REMOVE patterns
+                remove_patterns = list(
+                    DeltaTdammTagPattern.objects.filter(
+                        collection=curated_url.collection,
+                        match_pattern=curated_url.url,
+                        match_pattern_type=1,
+                        operation=OperationChoices.REMOVE,
+                        source=source,
+                    )
+                )
 
-            # Force refresh all patterns for this URL
-            self._refresh_url_tags(delta_url)
+                logger.info(f"Found {len(remove_patterns)} REMOVE patterns")
+
+                if remove_patterns:
+                    # Update the first REMOVE pattern
+                    remove_pattern = remove_patterns[0]
+                    current_tags = remove_pattern.tags or []
+                    if tag not in current_tags:
+                        remove_pattern.tags = current_tags + [tag]
+                        remove_pattern.save()
+                        logger.info(f"Updated REMOVE pattern {remove_pattern.id} with tags {remove_pattern.tags}")
+                else:
+                    # Create new REMOVE pattern
+                    remove_pattern = DeltaTdammTagPattern.objects.create(
+                        collection=curated_url.collection,
+                        match_pattern=curated_url.url,
+                        match_pattern_type=1,
+                        operation=OperationChoices.REMOVE,
+                        source=source,
+                        tags=[tag],
+                    )
+                    logger.info(f"Created new REMOVE pattern {remove_pattern.id} with tag {tag}")
 
             # Clean up if delta becomes identical to curated
             if not delta_url.to_delete and delta_url._fields_match(curated_url):
+                logger.info(f"Deleting delta URL {delta_url.id} as it matches curated URL")
                 delta_url.delete()
 
             return Response({"status": "success"})
         except Exception as e:
             logger.error(f"Error occurred: {str(e)}")
-            return Response({"error": "An internal error has occurred."}, status=500)
-
-    def _refresh_url_tags(self, url_obj):
-        """Refresh URL tags by reapplying all patterns affecting this URL."""
-        # Get all patterns affecting this URL
-        add_patterns = DeltaTdammTagPattern.objects.filter(
-            collection=url_obj.collection, delta_urls=url_obj, operation=OperationChoices.ADD
-        )
-
-        remove_patterns = DeltaTdammTagPattern.objects.filter(
-            collection=url_obj.collection, delta_urls=url_obj, operation=OperationChoices.REMOVE
-        )
-
-        # Collect all tags from ADD patterns
-        add_tags = set()
-        for pattern in add_patterns:
-            add_tags.update(pattern.tags or [])
-
-        # Collect all tags from REMOVE patterns
-        remove_tags = set()
-        for pattern in remove_patterns:
-            remove_tags.update(pattern.tags or [])
-
-        # Final tags = (add tags) - (remove tags)
-        final_tags = list(add_tags - remove_tags)
-
-        # Update URL tags
-        url_obj.tdamm_tag_manual = final_tags if final_tags else None
-        url_obj.save()
+            return Response({"error": f"An internal error has occurred: {str(e)}"}, status=500)
+
+    # def _refresh_url_tags(self, url_obj):
+    #     """Refresh URL tags by reapplying all patterns affecting this URL."""
+    #     # Get all patterns affecting this URL
+    #     add_patterns = DeltaTdammTagPattern.objects.filter(
+    #         collection=url_obj.collection, delta_urls=url_obj, operation=OperationChoices.ADD
+    #     )
+
+    #     remove_patterns = DeltaTdammTagPattern.objects.filter(
+    #         collection=url_obj.collection, delta_urls=url_obj, operation=OperationChoices.REMOVE
+    #     )
+
+    #     # Collect all tags from ADD patterns
+    #     add_tags = set()
+    #     for pattern in add_patterns:
+    #         add_tags.update(pattern.tags or [])
+
+    #     # Collect all tags from REMOVE patterns
+    #     remove_tags = set()
+    #     for pattern in remove_patterns:
+    #         remove_tags.update(pattern.tags or [])
+
+    #     # Final tags = (add tags) - (remove tags)
+    #     final_tags = list(add_tags - remove_tags)
+
+    #     # Update URL tags
+    #     url_obj.tdamm_tag_manual = final_tags if final_tags else None
+    #     url_obj.save()
 
 
 class DeltaURLBulkCreateView(generics.ListCreateAPIView):