Fix a bug with time zone reporting in alerts.

alertproviders/parksnpeaks.py

@@ -49,7 +49,8 @@ class ParksNPeaks(HTTPAlertProvider):
                 logging.warn("PNP alert found with sig " + alert.sig + ", developer needs to add support for this!")
 
             # If this is POTA, SOTA or WWFF data we already have it through other means, so ignore. Otherwise, add to
-            # the alert list.
+            # the alert list. Note that while ZLOTA has its own spots API, it doesn't have its own alerts API. So that
+            # means the PnP *spot* provider rejects ZLOTA spots here, but the PnP *alerts* provider here allows ZLOTA.
             if alert.sig not in ["POTA", "SOTA", "WWFF"]:
                 new_alerts.append(alert)
         return new_alerts

alertproviders/wota.py

@@ -0,0 +1,60 @@
+import re
+from datetime import datetime
+
+import pytz
+from rss_parser import RSSParser
+
+from alertproviders.http_alert_provider import HTTPAlertProvider
+from core.sig_utils import get_icon_for_sig
+from data.alert import Alert
+
+
+# Alert provider for Wainwrights on the Air
+class WOTA(HTTPAlertProvider):
+    POLL_INTERVAL_SEC = 3600
+    ALERTS_URL = "https://www.wota.org.uk/alerts_rss.php"
+    RSS_DATE_TIME_FORMAT = "%a, %d %b %Y %H:%M:%S %z"
+
+    def __init__(self, provider_config):
+        super().__init__(provider_config, self.ALERTS_URL, self.POLL_INTERVAL_SEC)
+
+    def http_response_to_alerts(self, http_response):
+        new_alerts = []
+        rss = RSSParser.parse(http_response.content.decode())
+        # Iterate through source data
+        for source_alert in rss.channel.items:
+            # Pick apart the title
+            title_split = source_alert.title.split(" on ")
+            dx_call = title_split[0]
+            ref = None
+            ref_name = None
+            if len(title_split) > 1:
+                ref_split = title_split[1].split(" - ")
+                ref = ref_split[0]
+                if len(ref_split) > 1:
+                    ref_name = ref_split[1]
+
+            # Pick apart the description
+            desc_split = source_alert.description.split(". ")
+            freqs_modes = desc_split[0].replace("Frequencies/modes:", "").strip()
+            comment = None
+            if len(desc_split) > 1:
+                comment = desc_split[1].strip()
+
+            time = datetime.strptime(source_alert.pub_date.content, self.RSS_DATE_TIME_FORMAT).astimezone(pytz.UTC)
+
+            # Convert to our alert format
+            alert = Alert(source=self.name,
+                          source_id=source_alert.guid.content,
+                          dx_calls=[dx_call],
+                          freqs_modes=freqs_modes,
+                          comment=comment,
+                          sig="WOTA",
+                          sig_refs=[ref] if ref else [],
+                          sig_refs_names=[ref_name] if ref_name else [],
+                          icon=get_icon_for_sig("WOTA"),
+                          start_time=time.timestamp())
+
+            # Add to our list.
+            new_alerts.append(alert)
+        return new_alerts

core/constants.py

@@ -26,7 +26,8 @@ SIGS = [
    SIG(name="ZLOTA", description="New Zealand on the Air", icon="kiwi-bird", ref_regex=r"ZL[A-Z]/[A-Z]{2}\-\d+"),
    SIG(name="KRMNPA", description="Keith Roget Memorial National Parks Award", icon="earth-oceania", ref_regex=r""),
    SIG(name="WAB", description="Worked All Britain", icon="table-cells-large", ref_regex=r"[A-Z]{1,2}[0-9]{2}"),
-   SIG(name="WAI", description="Worked All Ireland", icon="table-cells-large", ref_regex=r"[A-Z][0-9]{2}")
+   SIG(name="WAI", description="Worked All Ireland", icon="table-cells-large", ref_regex=r"[A-Z][0-9]{2}"),
+   SIG(name="WOTA", description="Wainwrights on the Air", icon="w", ref_regex=r"[A-Z]{3}-[0-9]{2}")
 ]
 
 # Modes. Note "DIGI" and "DIGITAL" are also supported but are normalised into "DATA".

spotproviders/parksnpeaks.py

@@ -19,9 +19,6 @@ class ParksNPeaks(HTTPSpotProvider):
     SIOTA_LIST_URL = "https://www.silosontheair.com/data/silos.csv"
     SIOTA_LIST_CACHE_TIME_DAYS = 30
     SIOTA_LIST_CACHE = CachedSession("cache/siota_data_cache", expire_after=timedelta(days=SIOTA_LIST_CACHE_TIME_DAYS))
-    ZLOTA_LIST_URL = "https://ontheair.nz/assets/assets.json"
-    ZLOTA_LIST_CACHE_TIME_DAYS = 30
-    ZLOTA_LIST_CACHE = CachedSession("cache/zlota_data_cache", expire_after=timedelta(days=ZLOTA_LIST_CACHE_TIME_DAYS))
 
     def __init__(self, provider_config):
         super().__init__(provider_config, self.SPOTS_URL, self.POLL_INTERVAL_SEC)
@@ -52,7 +49,7 @@ class ParksNPeaks(HTTPSpotProvider):
 
             # Extract a de_call if it's in the comment but not in the "actSpoter" field
             m = re.search(r"\(de ([A-Za-z0-9]*)\)", spot.comment)
-            if (not spot.de_call or spot.de_call == "ZLOTA") and m:
+            if not spot.de_call and m:
                 spot.de_call = m.group(1)
 
             # Log a warning for the developer if PnP gives us an unknown programme we've never seen before
@@ -70,20 +67,10 @@ class ParksNPeaks(HTTPSpotProvider):
                         spot.dx_grid = row["LOCATOR"]
                         break
 
-            # ZLOTA name/lat/lon lookup
-            if spot.sig == "ZLOTA":
-                zlota_data = self.ZLOTA_LIST_CACHE.get(self.ZLOTA_LIST_URL, headers=HTTP_HEADERS).json()
-                for asset in zlota_data:
-                    if asset["code"] == spot.sig_refs[0]:
-                        spot.sig_refs_names = [asset["name"]]
-                        spot.dx_latitude = asset["y"]
-                        spot.dx_longitude = asset["x"]
-                        break
-
             # Note there is currently no support for KRMNPA location lookup, see issue #61.
 
-            # If this is POTA, SOTA or WWFF data we already have it through other means, so ignore. Otherwise, add to
-            # the spot list.
-            if spot.sig not in ["POTA", "SOTA", "WWFF"]:
+            # If this is POTA, SOTA, WWFF or ZLOTA data we already have it through other means, so ignore. Otherwise,
+            # add to the spot list.
+            if spot.sig not in ["POTA", "SOTA", "WWFF", "ZLOTA"]:
                 new_spots.append(spot)
         return new_spots

spotproviders/wota.py

@@ -0,0 +1,23 @@
+import re
+
+from rss_parser import RSSParser
+
+from spotproviders.http_spot_provider import HTTPSpotProvider
+
+
+# Spot provider for Wainwrights on the Air
+class WOTA(HTTPSpotProvider):
+    POLL_INTERVAL_SEC = 120
+    SPOTS_URL = "https://www.wota.org.uk/spots_rss.php"
+
+    def __init__(self, provider_config):
+        super().__init__(provider_config, self.SPOTS_URL, self.POLL_INTERVAL_SEC)
+
+    def http_response_to_spots(self, http_response):
+        new_spots = []
+        rss = RSSParser.parse(http_response.content.decode())
+        # Iterate through source data
+        for source_alert in rss.channel.items:
+            break
+            # TODO: Need to see a live spot to know what this feed looks like
+        return new_spots

spotproviders/zlota.py

@@ -0,0 +1,59 @@
+import csv
+import logging
+import re
+from datetime import datetime, timedelta
+
+import pytz
+from requests_cache import CachedSession
+
+from core.constants import HTTP_HEADERS
+from core.sig_utils import get_icon_for_sig
+from data.spot import Spot
+from spotproviders.http_spot_provider import HTTPSpotProvider
+
+
+# Spot provider for ZLOTA
+class ZLOTA(HTTPSpotProvider):
+    POLL_INTERVAL_SEC = 120
+    SPOTS_URL = "https://ontheair.nz/api/spots?zlota_only=true"
+    LIST_URL = "https://ontheair.nz/assets/assets.json"
+    LIST_CACHE_TIME_DAYS = 30
+    LIST_CACHE = CachedSession("cache/zlota_data_cache", expire_after=timedelta(days=LIST_CACHE_TIME_DAYS))
+
+    def __init__(self, provider_config):
+        super().__init__(provider_config, self.SPOTS_URL, self.POLL_INTERVAL_SEC)
+
+    def http_response_to_spots(self, http_response):
+        new_spots = []
+        # Iterate through source data
+        for source_spot in http_response.json():
+            # Frequency is often inconsistent as to whether it's in Hz or kHz. Make a guess.
+            freq_hz = float(source_spot["frequency"])
+            if freq_hz < 1000000:
+                freq_hz = freq_hz * 1000
+
+            # Convert to our spot format
+            spot = Spot(source=self.name,
+                        source_id=source_spot["id"],
+                        dx_call=source_spot["activator"].upper(),
+                        de_call=source_spot["spotter"].upper(),
+                        freq=freq_hz,
+                        mode=source_spot["mode"].upper().strip(),
+                        comment=source_spot["comments"],
+                        sig="ZLOTA",
+                        sig_refs=[source_spot["reference"]],
+                        sig_refs_names=[source_spot["name"]],
+                        icon=get_icon_for_sig("ZLOTA"),
+                        time=datetime.fromisoformat(source_spot["referenced_time"]).astimezone(pytz.UTC).timestamp())
+
+            # ZLOTA name/lat/lon lookup
+            zlota_data = self.LIST_CACHE.get(self.LIST_URL, headers=HTTP_HEADERS).json()
+            for asset in zlota_data:
+                if asset["code"] == spot.sig_refs[0]:
+                    spot.sig_refs_names = [asset["name"]]
+                    spot.dx_latitude = asset["y"]
+                    spot.dx_longitude = asset["x"]
+                    break
+
+            new_spots.append(spot)
+        return new_spots

webassets/js/alerts.js

@@ -124,16 +124,13 @@ function addAlertRowsToTable(tbody, alerts) {
         var showRef = $("#tableShowRef")[0].checked;
 
         // Get times for the alert, and convert to local time if necessary.
-        var start_time_unix = moment.unix(a["start_time"]);
-        var start_time = start_time_unix.utc();
-        if (useLocalTime) {
-            start_time = start_time.local();
-        }
-        var end_time_unix = moment.unix(a["end_time"]);
-        var end_time = end_time_unix.utc();
-        if (useLocalTime) {
-            end_time = end_time.local();
-        }
+        var start_time_utc = moment.unix(a["start_time"]).utc();
+        var start_time_local = start_time_utc.clone().local();
+        console.log(a["dx_calls"])
+        start_time = useLocalTime ? start_time_local : start_time_utc;
+        var end_time_utc = moment.unix(a["end_time"]).utc();
+        var end_time_local = end_time_utc.clone().local();
+        end_time = useLocalTime ? end_time_local : end_time_utc;
 
         // Format the times for display. Start time is displayed as e.g. 7 Oct 12:34 unless the time is in a
         // different year to the current year, in which case the year is inserted between month and hour.
@@ -143,8 +140,8 @@ function addAlertRowsToTable(tbody, alerts) {
         // Overriding all of that, if the start time is 00:00 and the end time is 23:59 when considered in UTC, the
         // hours and minutes are stripped out from the display, as we assume the server is just giving us full days.
         // Finally, if there is no end date set, "---" is displayed.
-        var whole_days = start_time_unix.utc().format("HH:mm") == "00:00" &&
-            (end_time_unix != null || end_time_unix > 0 || end_time_unix.utc().format("HH:mm") == "23:59");
+        var whole_days = start_time_utc.format("HH:mm") == "00:00" &&
+            (end_time_utc != null || end_time_utc > 0 || end_time_utc.format("HH:mm") == "23:59");
         var hours_minutes_format = whole_days ? "" : " HH:mm";
         var start_time_formatted = start_time.format("D MMM" + hours_minutes_format);
         if (start_time.format("YYYY") != moment().format("YYYY")) {
@@ -153,11 +150,13 @@ function addAlertRowsToTable(tbody, alerts) {
             start_time_formatted = start_time.format("[Today]" + hours_minutes_format);
         }
         var end_time_formatted = "---";
-        if (end_time_unix != null && end_time_unix > 0 && end_time != null) {
+        if (end_time_utc != null && end_time_utc > 0 && end_time != null) {
             var end_time_formatted = whole_days ? start_time_formatted : end_time.format("HH:mm");
             if (end_time.format("D MMM") != start_time.format("D MMM")) {
                 if (end_time.format("YYYY") != moment().format("YYYY")) {
                     end_time_formatted = end_time.format("D MMM YYYY" + hours_minutes_format);
+                } else if (useLocalTime && end_time.format("D MMM YYYY") == moment().format("D MMM YYYY")) {
+                    end_time_formatted = end_time.format("[Today]" + hours_minutes_format);
                 } else {
                     end_time_formatted = end_time.format("D MMM" + hours_minutes_format);
                 }

webassets/js/spots.js

@@ -88,7 +88,7 @@ function updateTable() {
         // Format a UTC or local time for display
         var time = moment.unix(s["time"]).utc();
         if (useLocalTime) {
-            time = time.local();
+            time.local();
         }
         var time_formatted = time.format("HH:mm");