restructure: get the tracker to work again

This should hopefully be the final (major) part of the restructuring: a
tracker no longer has to know which trip it is on (and indeed it has no
idea for now), instead the server keeps state about which trips are
currently running and will insert incoming pings in a hopefully
reasonable manner, based on their geoposition & time.

There's lots of associated TODO items here (especially there should be
manual overrides for all this logic in the web ui), but that's work for
a future me.

(incidentally, this also adds support for sending all log messages out
via ntfy-sh)

3 files changed, 79 insertions, 24 deletions

diff --git a/lib/Server/ControlRoom.hs b/lib/Server/ControlRoom.hs
index 9d15bcf..5292620 100644
--- a/lib/Server/ControlRoom.hs
+++ b/lib/Server/ControlRoom.hs
@@ -17,6 +17,7 @@ import           Control.Monad.IO.Class    (MonadIO (liftIO))
 import qualified Data.Aeson                as A
 import qualified Data.ByteString.Char8     as C8
 import qualified Data.ByteString.Lazy      as LB
+import           Data.Coerce               (coerce)
 import           Data.Function             (on, (&))
 import           Data.Functor              ((<&>))
 import           Data.List                 (lookup, nubBy)
@@ -86,6 +87,7 @@ mkYesod "ControlRoom" [parseRoutes|
 
 /obu OnboardUnitMenuR GET
 /obu/#UUID OnboardUnitR GET
+/tracker OnboardTrackerR GET
 |]
 
 emptyMarkup :: MarkupM a -> Bool
@@ -96,6 +98,7 @@ instance Yesod ControlRoom where
   authRoute _ = Just $ AuthR LoginR
   isAuthorized OnboardUnitMenuR _ = pure Authorized
   isAuthorized (OnboardUnitR _) _ = pure Authorized
+  isAuthorized OnboardTrackerR _ = pure Authorized
   isAuthorized (AuthR _) _ = pure Authorized
   isAuthorized _ _ = do
     UffdConfig{..} <- getYesod <&> serverConfigLogin . getSettings
@@ -200,7 +203,7 @@ getTicketsR = do
   gtfs <- getYesod <&> getGtfs
 
   -- TODO: tickets should have all trip information saved
-  tickets <- runDB $ selectList [ TicketDay ==. day ] [] >>= mapM (\ticket -> do
+  tickets <- runDB $ selectList [ TicketDay ==. day ] [ Asc TicketTripName ] >>= mapM (\ticket -> do
     stops <- selectList [ StopTicket ==. entityKey ticket ] []
     startStation <- getJust (stopStation $ entityVal $ head stops)
     pure (ticket, startStation, fmap entityVal stops))
@@ -317,9 +320,11 @@ getTicketViewR ticketId = do
     pure (entityVal stop, station))
 
   anns <- runDB $ selectList [ AnnouncementTicket ==. ticketKey ] []
-  trackerIds <- runDB $ selectList [ TrackerTicketTicket ==. ticketKey ] []
+  joins <- runDB $ selectList [ TrackerTicketTicket ==. ticketKey ] []
     <&> fmap (trackerTicketTracker . entityVal)
-  trackers <- runDB $ selectList [ TrackerId <-. trackerIds ] [Asc TrackerExpires]
+  trackers <- runDB $ selectList
+    ([ TrackerId <-. joins ] ||. [ TrackerCurrentTicket ==. Just ticketKey ])
+    [Asc TrackerExpires]
   lastPing <- runDB $ selectFirst [ TrainPingToken <-. fmap entityKey trackers ] [Desc TrainPingTimestamp]
   anchors <- runDB $ selectList [ TrainAnchorTicket ==. ticketKey ] []
     <&> nonEmpty . fmap entityVal
@@ -511,7 +516,9 @@ getTokenBlock token = do
   case maybe of
     Just r@Tracker{..} -> do
       liftIO $ print r
-      redirect RootR
+      redirect $ case trackerCurrentTicket of
+        Just ticket -> TicketViewR (coerce ticket)
+        Nothing     -> RootR
     Nothing -> notFound
 
 getOnboardUnitMenuR :: Handler Html
@@ -525,14 +532,16 @@ getOnboardUnitMenuR = do
 
   defaultLayout $ do
     [whamlet|
-<h1>_{MsgOBU}
-<section>
-  _{MsgChooseTrain}
-  $forall (Entity (TicketKey ticketId) Ticket{..}, firstStop) <- tickets
-    <hr>
-    <a href="@{OnboardUnitR ticketId}">
-      #{ticketTripName}: #{ticketHeadsign} #{stopDeparture firstStop}
-|]
+      <h1>_{MsgOBU}
+      <section>
+       _{MsgChooseTrain}
+       $forall (Entity (TicketKey ticketId) Ticket{..}, firstStop) <- tickets
+         <hr>
+         <a href="@{OnboardUnitR ticketId}">
+          #{ticketTripName}: #{ticketHeadsign} #{stopDeparture firstStop}
+      <section>
+        <a href="@{OnboardTrackerR}">_{MsgStartTracking}
+    |]
 
 getOnboardUnitR :: UUID -> Handler Html
 getOnboardUnitR ticketId = do
@@ -541,6 +550,12 @@ getOnboardUnitR ticketId = do
     Just ticket -> pure ticket
   defaultLayout $(whamletFile "site/obu.hamlet")
 
+getOnboardTrackerR :: Handler Html
+getOnboardTrackerR = do
+  defaultLayout
+    $( whamletFile "site/tracker.hamlet")
+
+
 announceForm :: UUID -> Html -> MForm Handler (FormResult Announcement, Widget)
 announceForm ticketId = renderDivs $ Announcement
   <$> pure (TicketKey ticketId)
diff --git a/lib/Server/GTFS_RT.hs b/lib/Server/GTFS_RT.hs
index 48a84db..d2e53a1 100644
--- a/lib/Server/GTFS_RT.hs
+++ b/lib/Server/GTFS_RT.hs
@@ -155,13 +155,14 @@ gtfsRealtimeServer gtfs@GTFS{..} dbpool =
 
       ticket <- selectList [TicketCompleted ==. False] []
 
-      positions <- forM ticket $ \(Entity key ticket) -> do
-        selectFirst [TrainPingTicket ==. key] [Desc TrainPingTimestamp] >>= \case
-          Nothing -> pure Nothing
-          Just lastPing ->
-            pure (Just $ mkPosition (lastPing, ticket))
-
-      defFeedMessage (catMaybes positions)
+      -- TODO: reimplement this (since trainpings no longer reference tickets it's gone for now)
+      -- positions <- forM ticket $ \(Entity key ticket) -> do
+      --   selectFirst [TrainPingTicket ==. key] [Desc TrainPingTimestamp] >>= \case
+      --     Nothing -> pure Nothing
+      --     Just lastPing ->
+      --       pure (Just $ mkPosition (lastPing, ticket))
+
+      defFeedMessage [] -- (catMaybes positions)
 
       where
         mkPosition :: (Entity TrainPing, Ticket) -> RT.FeedEntity
diff --git a/lib/Server/Util.hs b/lib/Server/Util.hs
index 5ffb829..0106428 100644
--- a/lib/Server/Util.hs
+++ b/lib/Server/Util.hs
@@ -1,28 +1,67 @@
+{-# LANGUAGE BlockArguments  #-}
+{-# LANGUAGE RecordWildCards #-}
 -- | mostly the monad the service runs in
-module Server.Util (Service, ServiceM, runService, sendErrorMsg, secondsNow, utcToSeconds) where
+module Server.Util (Service, ServiceM, runService, sendErrorMsg, secondsNow, utcToSeconds, runLogging) where
 
+import           Config                 (LoggingConfig (..))
+import           Control.Exception      (handle, try)
+import           Control.Monad.Extra    (void, whenJust)
 import           Control.Monad.IO.Class (MonadIO (liftIO))
-import           Control.Monad.Logger   (LoggingT, runStderrLoggingT)
+import           Control.Monad.Logger   (Loc, LogLevel (..), LogSource, LogStr,
+                                         LoggingT (..), defaultOutput,
+                                         fromLogStr, runStderrLoggingT)
+import           Control.Monad.Reader   (ReaderT (..))
 import qualified Data.Aeson             as A
 import           Data.ByteString        (ByteString)
+import qualified Data.ByteString        as C8
 import           Data.Text              (Text)
+import qualified Data.Text              as T
+import           Data.Text.Encoding     (decodeUtf8Lenient)
 import           Data.Time              (Day, UTCTime (..), diffUTCTime,
                                          getCurrentTime,
                                          nominalDiffTimeToSeconds)
+import           Fmt                    ((+|), (|+))
+import           GHC.IO.Exception       (IOException (IOError))
 import           GTFS                   (Seconds (..))
 import           Prometheus             (MonadMonitor (doIO))
 import           Servant                (Handler, ServerError, ServerT, err404,
                                          errBody, errHeaders, throwError)
+import           System.IO              (stderr)
+import           System.Process.Extra   (callProcess)
 
-type ServiceM  = LoggingT Handler
+type ServiceM  = LoggingT (ReaderT LoggingConfig Handler)
 type Service api = ServerT api ServiceM
 
-runService :: ServiceM a -> Handler a
-runService = runStderrLoggingT
+runService :: LoggingConfig -> ServiceM a -> Handler a
+runService conf m = runReaderT (runLogging conf m) conf
 
 instance MonadMonitor ServiceM where
   doIO = liftIO
 
+runLogging :: MonadIO m => LoggingConfig -> LoggingT m a -> m a
+runLogging LoggingConfig{..} logging = runLoggingT logging printLogMsg
+  where printLogMsg loc source level msg = do
+          -- this is what runStderrLoggingT does
+          defaultOutput stderr loc source level msg
+
+          whenJust loggingConfigNtfyToken \token -> handle ntfyFailed do
+            callProcess "ntfy"
+              [ "send"
+              , "--token=" <> T.unpack token
+              , "--title="+|loggingConfigHostname|+"/"+|"tracktrain"
+              , "--priority="+|show (ntfyPriority level)|+""
+              , T.unpack loggingConfigNtfyTopic
+              , T.unpack (decodeUtf8Lenient (fromLogStr msg)) ]
+
+        ntfyFailed (e :: IOError) =
+          putStrLn ("calling ntfy failed:"+|show e|+".")
+        ntfyPriority level = case level of
+          LevelDebug   -> 2
+          LevelInfo    -> 3
+          LevelWarn    -> 4
+          LevelError   -> 5
+          LevelOther _ -> 0
+
 
 sendErrorMsg :: Text -> ServiceM a
 sendErrorMsg msg = throwError err404