Adding VOEvents for superevents

Adding API resource for creating and getting VOEvents from superevents.

gracedb/alerts/superevent_utils.py

@@ -5,7 +5,7 @@ from .main import issue_alerts
 from core.urls import build_absolute_uri
 from superevents.api.serializers import SupereventSerializer, \
     SupereventLogSerializer, SupereventLabelSerializer, \
-    SupereventEMObservationSerializer
+    SupereventEMObservationSerializer, SupereventVOEventSerializer
 from superevents.shortcuts import is_superevent
 
 import logging
@@ -110,13 +110,22 @@ def issue_alert_for_superevent_label_removal(labelling, request=None):
     description = "UPDATE: {label} removed".format(label=labelling.label.name)
 
     # Send alerts
-    # TODO: should this be a 'label' alert or an 'update' alert
     issue_alerts(labelling.superevent, alert_type="update", url=url,
         description=description, serialized_object=None)
 
 
 def issue_alert_for_superevent_voevent(voevent, request=None):
-    pass
+    # Get URL for superevent webview and serialized label
+    url, serialized_object = superevent_alert_helper(voevent,
+        SupereventVOEventSerializer, request=request)
+
+    # Description
+    description = "VOEVENT: {filename}".format(filename=voevent.filename)
+
+    # Send alerts
+    issue_alerts(voevent.superevent, alert_type="update", url=url,
+        file_name=voevent.filename, description=description,
+        serialized_object=serialized_object)
 
 
 def issue_alert_for_superevent_emobservation(emobservation, request=None):

gracedb/superevents/api/serializers.py

@@ -377,6 +377,18 @@ class SupereventLogTagSerializer(serializers.ModelSerializer):
 
 
 class SupereventVOEventSerializer(serializers.ModelSerializer):
+    default_error_messages = {
+        'no_gpstime': _('Cannot build a VOEvent because preferred event does '
+                        'not have a gpstime.'),
+        'skymap_file_required': _('Skymap filename is required for initial '
+                                  'and update VOEvents.'),
+        'skymap_type_required': _('Skymap type is required for initial and '
+                                  'update VOEvents.'),
+        'skymap_not_found': _('Skymap file {filename} not found for this '
+                              'superevent.'),
+        'skymap_image_not_found': _('Skymap image file {filename} not found '
+                                    'for this superevent.'),
+    }
     # Read only fields
     issuer = serializers.SlugRelatedField(slug_field='username',
         read_only=True)
@@ -384,16 +396,44 @@ class SupereventVOEventSerializer(serializers.ModelSerializer):
         read_only=True)
     links = serializers.SerializerMethodField(read_only=True)
 
+    # Write only fields
+    user = serializers.HiddenField(write_only=True,
+        default=serializers.CurrentUserDefault())
+    superevent = serializers.HiddenField(write_only=True,
+        default=ParentObjectDefault(context_key='superevent'))
+    skymap_type = serializers.CharField(write_only=True, required=False)
+    skymap_filename = serializers.CharField(write_only=True, required=False)
+    skymap_image_filename = serializers.CharField(write_only=True,
+        required=False)
+    vetted = serializers.BooleanField(write_only=True, default=False)
+    internal = serializers.BooleanField(write_only=True, default=True)
+    open_alert = serializers.BooleanField(write_only=True, default=False)
+    hardware_inj = serializers.BooleanField(write_only=True, default=False)
+    CoincComment = serializers.BooleanField(write_only=True, default=False)
+    ProbHasNS = serializers.FloatField(write_only=True, min_value=0,
+        max_value=1, required=False)
+    ProbHasRemnant = serializers.FloatField(write_only=True, min_value=0,
+        max_value=1, required=False)
+
     class Meta:
         model = VOEvent
         fields = ('voevent_type', 'file_version', 'ivorn', 'created',
-            'issuer', 'filename', 'N', 'links')
+            'issuer', 'filename', 'N', 'links', 'skymap_type',
+            'skymap_filename', 'skymap_image_filename', 'vetted', 'internal',
+            'open_alert', 'hardware_inj', 'CoincComment', 'ProbHasNS',
+            'ProbHasRemnant', 'superevent', 'user')
+
+    def __init__(self, *args, **kwargs):
+        super(SupereventVOEventSerializer, self).__init__(*args, **kwargs)
+        self.fields['file_version'].read_only = True
+        self.fields['filename'].read_only = True
+        self.fields['ivorn'].read_only = True
 
     def get_links(self, obj):
         file_link = None
         if obj.filename:
-            file_name = "{name},{version}".format(obj.filename, 
-                obj.file_version)
+            file_name = "{name},{version}".format(name=obj.filename,
+                version=obj.file_version)
             file_link = gracedb_reverse('superevents:superevent-file-detail',
                 args=[obj.superevent.superevent_id, file_name],
                 request=self.context.get('request', None)),
@@ -406,8 +446,63 @@ class SupereventVOEventSerializer(serializers.ModelSerializer):
         }
         return link_dict
 
-    # TODO:
-    # VOEvent creation!!
+    def validate(self, data):
+        data = super(SupereventVOEventSerializer, self).validate(data)
+
+        # Get data
+        superevent = data.get('superevent')
+        voevent_type = data.get('voevent_type')
+        skymap_filename = data.get('skymap_filename', None)
+        skymap_type = data.get('skymap_type', None)
+        skymap_image_filename = data.get('skymap_image_filename', None)
+
+        # Checks to do:
+        # Preferred event must have gpstime
+        if not superevent.preferred_event.gpstime:
+            self.fail('no_gpstime')
+
+        # initial and update VOEvents must have a skymap, and
+        # preliminary VOEvents can have a skymap
+        if (voevent_type in ["IN", "UP"] or
+           (voevent_type == "PR" and skymap_filename != None)):
+
+            # Check skymap filename
+            if not skymap_filename:
+                self.fail('skymap_file_required')
+
+            # Check skymap type
+            if not skymap_type:
+                self.fail('skymap_type_required')
+
+            # Check if skymap fits file exists
+            full_skymap_path = os.path.join(superevent.datadir,
+                skymap_filename)
+            if not os.path.exists(full_skymap_path):
+                self.fail('skymap_not_found', filename=skymap_filename)
+
+            if skymap_image_filename:
+                full_skymap_image_path = os.path.join(superevent.datadir,
+                    skymap_image_filename)
+                if not os.path.exists(full_skymap_image_path):
+                    self.fail('skymap_image_not_found', filename=
+                        skymap_image_filename)
+
+        return data
+
+    def create(self, validated_data):
+
+        from ..utils import create_voevent_for_superevent
+
+        # Pop some data
+        superevent = validated_data.pop('superevent')
+        issuer = validated_data.pop('user')
+
+        # Call create function - creates VOEvent object and also runs
+        # buildVOEvent to create the related file.
+        voevent = create_voevent_for_superevent(superevent, issuer,
+            **validated_data)
+
+        return voevent
 
 
 class SupereventEMFootprintSerializer(serializers.ModelSerializer):

gracedb/superevents/utils.py

 from django.shortcuts import get_object_or_404
 
+from .buildVOEvent import construct_voevent_file
+from .models import Superevent, Log, Labelling, EMObservation, EMFootprint, \
+    VOEvent, Signoff
 from .shortcuts import is_superevent
 from .models import Superevent, Log, Labelling, EMObservation, EMFootprint
 from events.models import Event, EventLog, Tag
@@ -10,7 +13,8 @@ from alerts.superevent_utils import issue_alert_for_superevent_creation, \
     issue_alert_for_superevent_log, \
     issue_alert_for_superevent_label_creation, \
     issue_alert_for_superevent_label_removal, \
-    issue_alert_for_superevent_emobservation
+    issue_alert_for_superevent_emobservation, \
+    issue_alert_for_superevent_voevent
 from alerts.event_utils import issue_alert_for_event_log
 
 import os
@@ -453,3 +457,51 @@ def create_emobservation_for_superevent(superevent, submitter, ra_list,
         issue_alert_for_superevent_emobservation(emo)
 
     return emo
+
+
+def create_voevent_for_superevent(superevent, issuer, voevent_type,
+    skymap_type=None, skymap_filename=None, skymap_image_filename=None,
+    internal=True, vetted=False, open_alert=False, hardware_inj=False,
+    CoincComment=False, ProbHasNS=None, ProbHasRemnant=None,
+    add_log_message=True, issue_alert=True):
+
+    # Instantiate VOEvent object
+    voevent = VOEvent.objects.create(superevent=superevent, issuer=issuer,
+        voevent_type=voevent_type)
+
+    # Construct VOEvent file text
+    voevent_text, ivorn = construct_voevent_file(superevent, voevent,
+        skymap_type=skymap_type, skymap_filename=skymap_filename,
+        skymap_image_filename=skymap_image_filename, internal=internal,
+        vetted=vetted, open_alert=open_alert, hardware_inj=hardware_inj,
+        CoincComment=CoincComment, ProbHasNS=ProbHasNS,
+        ProbHasRemnant=ProbHasRemnant)
+
+    # Save versioned VOEvent file
+    voevent_display_type = dict(VOEvent.VOEVENT_TYPE_CHOICES) \
+        [voevent.voevent_type].capitalize()
+    voevent_filename = "{superevent}-{N}-{voevent_type}.xml".format(
+        superevent=superevent.superevent_id, N=voevent.N,
+        voevent_type=voevent_display_type)
+    version = create_versioned_file(voevent_filename, superevent.datadir,
+        voevent_text)
+
+    # Update VOEvent object
+    voevent.filename = voevent_filename
+    voevent.file_version = version
+    voevent.ivorn = ivorn
+    voevent.save(update_fields=['filename', 'file_version', 'ivorn'])
+
+    # Create a log entry to document the new VOEvent (tag it as em_follow)
+    if add_log_message:
+        comment = "New VOEvent"
+        em_follow = Tag.objects.get(name='em_follow')
+        voevent_log = create_log(issuer, comment, superevent,
+            filename=voevent.filename, file_version=voevent.file_version,
+            tags=[em_follow], issue_alert=False)
+
+    # Issue an alert
+    if issue_alert:
+        issue_alert_for_superevent_voevent(voevent)
+
+    return voevent