Add the TSN.XML.Weather module (passing pickle/unpickle tests).

[dead/htsn-import.git] / src / Main.hs

diff --git a/src/Main.hs b/src/Main.hs
index 6a0380091a65d60f342b86bdb65190e4d024bce5..10b1acecd0382cba9660198c2d07368ad353eef1 100644 (file)
--- a/src/Main.hs
+++ b/src/Main.hs
@@ -3,6 +3,7 @@
 module Main
 where
 
+-- System imports.
 import Control.Arrow ( (&&&), (>>^), arr, returnA )
 import Control.Concurrent ( threadDelay )
 import Control.Exception ( SomeException, catch )
@@ -29,9 +30,9 @@ import Text.XML.HXT.Core (
   hasName,
   readDocument,
   runX,
-  unpickleDoc,
-  xpickle)
+  unpickleDoc )
 
+-- Local imports.
 import Backend ( Backend(..) )
 import CommandLine ( get_args )
 import Configuration ( Configuration(..), merge_optional )
@@ -45,25 +46,26 @@ import Network.Services.TSN.Report (
   report_error )
 import TSN.DbImport ( DbImport(..), ImportResult(..) )
 import qualified TSN.XML.Heartbeat as Heartbeat ( verify )
-import qualified TSN.XML.Injuries as Injuries ( Message )
-import qualified TSN.XML.InjuriesDetail as InjuriesDetail ( Message )
-import qualified TSN.XML.News as News ( Message )
---import qualified TSN.XML.Odds as Odds ( Odds )
+import qualified TSN.XML.Injuries as Injuries ( pickle_message )
+import qualified TSN.XML.InjuriesDetail as InjuriesDetail ( pickle_message )
+import qualified TSN.XML.News as News ( pickle_message )
+import qualified TSN.XML.Odds as Odds ( pickle_message )
+import qualified TSN.XML.Weather as Weather ( pickle_message )
 import Xml ( DtdName(..), parse_opts )
 
 
 -- | This is where most of the work happens. This function is called
 --   on every file that we would like to import. It determines which
---   importer to use based on the DTD, processes the file, and then
---   returns whether or not any records were imported. If the file was
---   processed, the number of records imported is returned (wrapped in
---   a Just). Otherwise, if the file was not processed, 'Nothing' is
+--   importer to use based on the DTD, attempts to process the file,
+--   and then returns whether or not it was successful. If the file
+--   was processed, 'True' is returned. Otherwise, 'False' is
 --   returned.
 --
---   Since we are already in arrow world with HXT, the
---   'import_with_dtd' function is lifted to an 'Arrow' as well with
---   'arr'. This prevents us from having to do a bunch of unwrapping
---   and rewrapping with the associated error checking.
+--   The implementation is straightforward with one exception: since
+--   we are already in arrow world with HXT, the @import_with_dtd@
+--   function is lifted to an 'Arrow' as well with 'arr'. This
+--   prevents us from having to do a bunch of unwrapping and
+--   rewrapping with the associated error checking.
 --
 import_file :: Configuration -- ^ A configuration object needed for the
                              --   'backend' and 'connection_string'.
@@ -135,11 +137,11 @@ import_file cfg path = do
         -- We special-case the heartbeat so it doesn't have to run in
         -- the database monad.
       | dtd == "Heartbeat.dtd" = Heartbeat.verify xml
-      | otherwise = do
+      | otherwise =
         -- We need NoMonomorphismRestriction here.
         if backend cfg == Postgres
-        then withPostgresqlConn cs $ runDbConn $ importer
-        else withSqliteConn cs $ runDbConn $ importer
+        then withPostgresqlConn cs $ runDbConn importer
+        else withSqliteConn cs $ runDbConn importer
         where
           -- | Pull the real connection String out  of the configuration.
           cs :: String
@@ -150,22 +152,25 @@ import_file cfg path = do
 
           importer
             | dtd == "injuriesxml.dtd" = do
-               let m = unpickleDoc xpickle xml :: Maybe Injuries.Message
+               let m = unpickleDoc Injuries.pickle_message xml
                let errmsg = "Could not unpickle injuriesxml."
                maybe (return $ ImportFailed errmsg) migrate_and_import m
 
             | dtd == "Injuries_Detail_XML.dtd" = do
-                let m = unpickleDoc xpickle xml :: Maybe InjuriesDetail.Message
+                let m = unpickleDoc InjuriesDetail.pickle_message xml
                 let errmsg = "Could not unpickle Injuries_Detail_XML."
                 maybe (return $ ImportFailed errmsg) migrate_and_import m
 
 
             | dtd == "newsxml.dtd" = do
-                let m = unpickleDoc xpickle xml :: Maybe News.Message
+                let m = unpickleDoc News.pickle_message xml
                 let errmsg = "Could not unpickle newsxml."
                 maybe (return $ ImportFailed errmsg) migrate_and_import m
 
-            -- | dtd == "Odds_XML.dtd" = undefined
+            | dtd == "Odds_XML.dtd" = do
+                let m = unpickleDoc Odds.pickle_message xml
+                let errmsg = "Could not unpickle Odds_XML."
+                maybe (return $ ImportFailed errmsg) migrate_and_import m
 
             | otherwise = do
               let infomsg =
@@ -174,10 +179,11 @@ import_file cfg path = do
 
 
 -- | Entry point of the program. It twiddles some knobs for
---   configuration options and then calls 'import_file' on each XML file
---   given on the command-line.
+--   configuration options and then calls 'import_file' on each XML
+--   file given on the command-line.
 --
---   Any file successfully processed is then removed, and we're done.
+--   Any file successfully processed is then optionally removed, and
+--   we're done.
 --
 main :: IO ()
 main = do
@@ -210,7 +216,7 @@ main = do
   let victims = [ p | (p, True) <- result_pairs ]
   let imported_count = length victims
   report_info $ "Imported " ++ (show imported_count) ++ " document(s) total."
-  mapM_ (kill True) victims
+  when (remove cfg) $ mapM_ (kill True) victims
 
   where
     -- | Wrap these two actions into one function so that we don't