story/VOGRE-7

.env_app-example

@@ -10,4 +10,6 @@ CONCEPTPOWER_USERID=
 CONCEPTPOWER_PASSWORD=
 CONCEPTPOWER_ENDPOINT=
 CONCEPTPOWER_NAMESPACE=
-BASE_URL=http://localhost:8000/
+BASE_URL=http://localhost:8000/
+QUADRIGA_ENDPOINT=
+QUADRIGA_COLLECTION_ID=

annotations/admin.py

@@ -1,7 +1,6 @@
 from django.contrib import admin
 from annotations.forms import *
 from annotations.models import *
-from annotations.tasks import submit_relationsets_to_quadriga
 
 from itertools import groupby
 
@@ -50,81 +49,12 @@ def created_by(self, obj):
         return obj.createdBy
 
 
-def submit_relationsets(modeladmin, request, queryset):
-    """
-    Submit selected :class:`.RelationSet`\s to Quadriga.
-
-    Will quietly skip any :class:`.RelationSet`\s that have already been
-    submitted.
-    """
-
-    queryset = queryset.filter(submitted=False, pending=False)
-
-    # Do not submit a relationset to Quadriga if the constituent interpretations
-    #  involve concepts that are not resolved.
-    all_rsets = [rs for rs in queryset if rs.ready()]
-
-    project_grouper = lambda rs: getattr(rs.project, 'quadriga_id', -1)
-    for project_id, project_group in groupby(sorted(all_rsets, key=project_grouper), key=project_grouper):
-        for text_id, text_group in groupby(project_group, key=lambda rs: rs.occursIn.id):
-            text = Text.objects.get(pk=text_id)
-            for user_id, user_group in groupby(text_group, key=lambda rs: rs.createdBy.id):
-                user = VogonUser.objects.get(pk=user_id)
-                # We lose the iterator after the first pass, so we want a list here.
-                rsets = []
-                for rs in user_group:
-                    rsets.append(rs.id)
-                    rs.pending = True
-                    rs.save()
-                kwargs = {}
-                if project_id:
-                    kwargs.update({
-                        'project_id': project_id,
-                    })
-                submit_relationsets_to_quadriga.delay(rsets, text.id, user.id, **kwargs)
-
-
-def submit_relationsets_synch(modeladmin, request, queryset):
-    """
-    Submit selected :class:`.RelationSet`\s to Quadriga.
-
-    Will quietly skip any :class:`.RelationSet`\s that have already been
-    submitted.
-    """
-
-    queryset = queryset.filter(submitted=False, pending=False)
-
-    # Do not submit a relationset to Quadriga if the constituent interpretations
-    #  involve concepts that are not resolved.
-    all_rsets = [rs for rs in queryset if rs.ready()]
-
-    project_grouper = lambda rs: getattr(rs.project, 'quadriga_id', -1)
-    for project_id, project_group in groupby(sorted(all_rsets, key=project_grouper), key=project_grouper):
-        for text_id, text_group in groupby(project_group, key=lambda rs: rs.occursIn.id):
-            text = Text.objects.get(pk=text_id)
-            for user_id, user_group in groupby(text_group, key=lambda rs: rs.createdBy.id):
-                user = VogonUser.objects.get(pk=user_id)
-                # We lose the iterator after the first pass, so we want a list here.
-                rsets = []
-                for rs in user_group:
-                    rsets.append(rs.id)
-                    rs.pending = True
-                    rs.save()
-                kwargs = {}
-                if project_id and project_id > 0:
-                    kwargs.update({
-                        'project_id': project_id,
-                    })
-                submit_relationsets_to_quadriga(rsets, text.id, user.id, **kwargs)
-
-
 class RelationSetAdmin(admin.ModelAdmin):
     class Meta:
         model = RelationSet
 
     list_display = ('id', 'createdBy', 'occursIn', 'created', 'ready',
-                    'pending', 'submitted', )
-    actions = (submit_relationsets, submit_relationsets_synch)
+                    'submitted', 'status',)
 
 
 class AppellationAdmin(admin.ModelAdmin):

annotations/middleware.py

@@ -0,0 +1,58 @@
+from django.utils.deprecation import MiddlewareMixin
+from annotations.models import RelationSet
+from asgiref.sync import async_to_sync, sync_to_async
+from django.utils import timezone
+from datetime import timedelta
+
+class CheckRelationSetStatusMiddleware(MiddlewareMixin):
+    """
+    Middleware to ensure that RelationSets are correctly marked as ready to submit.
+    This middleware runs before each request to check and update the status of 
+    RelationSets. RelationSets must have one of three statuses:
+
+    - 'not_ready': Concepts are not yet resolved or merged.
+    - 'ready_to_submit': All concepts are resolved and the RelationSet is ready for submission.
+    - 'submitted': This is handled separately in the submission workflow and does not need to 
+                   be updated here.
+
+    The purpose of this middleware is to automate the readiness check and ensure that 
+    RelationSets are always in the correct state before they can be submitted to Quadriga.
+    """
+
+    # Cache the last check time to reduce query frequency
+    last_check_time = None
+    check_interval = timedelta(minutes=5)  # Adjust the interval as needed
+
+    def process_request(self, request):
+        """
+        Synchronous method called before each request. It triggers the status check
+        asynchronously, with a rate limit based on `check_interval` to reduce load.
+        """
+        if self.should_run_check():
+            async_to_sync(self.check_and_update_relation_sets)()
+
+    def should_run_check(self):
+        """
+        Determines whether the status check should be run based on the defined interval.
+        """
+        current_time = timezone.now()
+        if not self.last_check_time or (current_time - self.last_check_time) > self.check_interval:
+            self.last_check_time = current_time
+            return True
+        return False
+
+    async def check_and_update_relation_sets(self):
+        """
+        This asynchronous function is responsible for checking and updating the 
+        statuses of RelationSets in bulk. It uses the `update_status` method of 
+        each RelationSet instance to evaluate and adjust their status based on 
+        readiness conditions.
+        """
+        # Fetch RelationSets that need a status check asynchronously
+        relation_sets = await sync_to_async(list)(
+            RelationSet.objects.filter(status__in=['not_ready', 'ready_to_submit'])
+        )
+
+        # Update statuses for each RelationSet using the update_status method from Relationset model
+        for relation_set in relation_sets:
+            await sync_to_async(relation_set.update_status)()

annotations/migrations/0042_relationset_status.py

@@ -0,0 +1,18 @@
+# Generated by Django 2.2.20 on 2024-10-29 16:52
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('annotations', '0041_delete_importedcitesphereitem'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='relationset',
+            name='status',
+            field=models.CharField(choices=[('not_ready', 'Not Ready'), ('ready_to_submit', 'Ready to Submit'), ('submitted', 'Submitted')], default='not_ready', max_length=20),
+        ),
+    ]

annotations/migrations/0043_remove_relationset_pending.py

@@ -0,0 +1,17 @@
+# Generated by Django 2.2.20 on 2024-10-29 18:22
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('annotations', '0042_relationset_status'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='relationset',
+            name='pending',
+        ),
+    ]

annotations/models.py

@@ -787,12 +787,15 @@ class RelationSet(models.Model):
     occursIn = models.ForeignKey('Text', related_name='relationsets', on_delete=models.CASCADE)
     """The text on which this RelationSet is based."""
 
-    pending = models.BooleanField(default=False)
-    """
-    A :class:`.RelationSet` is pending if it has been selected for submission,
-    but the submission process has not yet completed. The primary purpose of
-    this field is to prevent duplicate submissions.
-    """
+    STATUS_CHOICES = [
+        ('not_ready', 'Not Ready'),
+        ('ready_to_submit', 'Ready to Submit'),
+        ('submitted', 'Submitted'),
+    ]
+
+    status = models.CharField(
+        max_length=20, choices=STATUS_CHOICES, default='not_ready'
+    )
 
     submitted = models.BooleanField(default=False)
     """
@@ -908,6 +911,17 @@ def ready(self):
         return all(map(criteria, values))
     ready.boolean = True    # So that we can display a nifty icon in changelist.
 
+    def update_status(self):
+        """
+        Check if the RelationSet is ready and update the status accordingly.
+        """
+        if self.ready():  # Check readiness based on the concepts
+            if self.status != 'submitted':  # Avoid overriding submitted status
+                self.status = 'ready_to_submit'
+        else:
+            self.status = 'not_ready'
+        self.save()
+
     def appellations(self):
         """
         Get all non-predicate appellations in child :class:`.Relation`\s.
@@ -1148,4 +1162,4 @@ class DocumentPosition(models.Model):
 
     If :attr:`.position_type` is :attr:`.WHOLE_DOCUMENT`\, then this can be
     blank.
-    """
+    """

annotations/quadriga.py

@@ -245,26 +245,6 @@ def to_quadruples(relationsets, text, user, network_label=None,
     return project, params
 
 
-def submit_relationsets(relationsets, text, user,
-                        userid=settings.QUADRIGA_USERID,
-                        password=settings.QUADRIGA_PASSWORD,
-                        endpoint=settings.QUADRIGA_ENDPOINT, **kwargs):
-    """
-    Submit the :class:`.RelationSet`\s in ``relationsets`` to Quadriga.
-    """
-    payload, params = to_quadruples(relationsets, text, user, toString=True, **kwargs)
-    auth = HTTPBasicAuth(userid, password)
-    headers = {'Accept': 'application/xml'}
-    r = requests.post(endpoint, data=payload, auth=auth, headers=headers)
-
-    if r.status_code == requests.codes.ok:
-        response_data = parse_response(r.text)
-        response_data.update(params)
-        return True, response_data
-
-    return False, r.text
-
-
 def parse_response(raw_response):
     QDNS = '{http://www.digitalhps.org/Quadriga}'
     root = ET.fromstring(raw_response)

annotations/serializers.py

@@ -122,7 +122,7 @@ class Meta:
         model = RelationSet
         fields = ('id', 'label', 'created', 'template', 'createdBy',
                   'occursIn', 'appellations', 'concepts', 'project',
-                  'representation', 'date_appellations')  #
+                  'representation', 'date_appellations', 'status')  #
 
 
 class TemporalBoundsSerializer(serializers.ModelSerializer):

annotations/static/annotations/css/annotators/text.css

@@ -199,3 +199,7 @@
       border: 0;
       background-color: rgb(250, 250, 250);
   }
+
+  .relation-submitted {
+    border-left: 4px solid #7aef7a;
+}