X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=diddohs.hs;h=6884d1462cd52cb50d96fb6fc36c7b7dbf42fba4;hb=95d1857e437aa09e1161be075c654c50afd91dd8;hp=d2a796bc05d4e3a010cd6f6b969228ca322cab55;hpb=79eb0216f15e1a8570cfae7ae5ed83da74ca30b8;p=user%2Fhenk%2Fcode%2Fhaskell%2Fdiddohs.git

diff --git a/diddohs.hs b/diddohs.hs
index d2a796b..6884d14 100644
--- a/diddohs.hs
+++ b/diddohs.hs
@@ -1,79 +1,114 @@
-import Control.Applicative( (<$>), (<*>) )
-import Data.DateTime( DateTime(..), parseDateTime, formatDateTime, startOfTime, diffSeconds )
-import Data.List.Split( splitOn )
-import Data.List( zipWith4, transpose )
-import Data.Maybe( fromJust, fromMaybe )
-import Data.Monoid( mempty )
-import Data.Time.Clock( secondsToDiffTime )
-import Data.Time.Format( parseTime, formatTime )
-import Data.Time.LocalTime( LocalTime(..), ZonedTime(..), zonedTimeToUTC, midnight, localDay )
-import Diddo.Entry( DiddoEntry(..) )
-import HMSTime( HMSTime(..), secondsToHMS )
-import Options.Applicative( execParser, info, strOption, long, help, helper, briefDesc, fullDesc, progDesc, header, (<>) )
+import Control.Applicative( (<$>) )
+import Control.Monad( unless )
+import Data.Time.Clock( UTCTime(..) )
+import Data.Time.LocalTime( TimeZone(), ZonedTime(..), zonedTimeToUTC, utcToZonedTime )
+import Diddo( Diddo(..), LogEntry(..), parseDiddoLogline, formatDiddo, logToDiddo, parseToZonedTime )
+import System.Console.GetOpt
 import System.Environment( getArgs )
-import System.Locale
+import System.Exit( exitSuccess, exitFailure )
+import System.IO( stderr, hPutStr )
+import qualified Data.Map as Map
+import qualified Data.Text as T
+import qualified Data.Text.IO as TIO
 
-data DiddoOpts = DiddoOpts
-  { inDateFmt :: String
-  , inFile :: String
-  }
+data Opt = Opt
+    { optVerbose        :: Bool
+    , optVersion        :: Bool
+    , optHelp           :: Bool
+    , optInputFiles     :: [String]
+    , optOutputFile     :: String
+    , optInputFormat    :: String
+    , optOutputFormat   :: String
+    , optStartDate      :: String
+    , optEndDate        :: String
+    }
 
-parseToZonedTime :: String -> String -> ZonedTime
-parseToZonedTime format = fromMaybe (error "Input data broken.") . parseTime defaultTimeLocale format
+defaultOpts :: Opt
+defaultOpts = Opt
+    { optVerbose        = False
+    , optVersion        = False
+    , optHelp           = False
+    , optInputFiles     = []
+    , optOutputFile     = ""
+    , optInputFormat    = "%FT%T%z"
+    , optOutputFormat   = "%FT%T%z"
+    , optStartDate      = ""
+    , optEndDate        = ""
+    }
 
-parseISOsecondsTime :: String -> ZonedTime
-parseISOsecondsTime = parseToZonedTime $ iso8601DateFormat $ Just "%T%z"
+availableOptions :: [OptDescr (Opt -> IO Opt)]
+availableOptions =
+    [ Option ['h']    ["help"]
+        (NoArg (\ _ -> putStrLn (usageInfo "Usage: diddohs [OPTION...]" availableOptions) >> exitSuccess))
+        "Display program help"
+    , Option ['v']    ["verbose"]
+        (NoArg (\ opts -> return opts { optVerbose = True }))
+        "More detailed output"
+    , Option ['V']    ["version"]
+        (NoArg (\ opts -> return opts { optVersion = True }))
+        "Display program version"
+    , Option ['f']    ["file"]
+        (ReqArg (\ arg opts -> return opts { optInputFiles = optInputFiles opts ++ [arg]}) "FILE" )
+        "Read from FILE"
+    , Option ['w']    ["output"]
+        (ReqArg (\ arg opts -> return opts { optOutputFile = arg }) "FILE")
+        "Write to FILE"
+    , Option ['i']    ["informat"]
+        (ReqArg (\ arg opts -> return opts { optInputFormat = arg }) "FORMAT")
+        "Timeformat used in input"
+    , Option ['o']    ["outformat"]
+        (ReqArg (\ arg opts -> return opts { optOutputFormat = arg }) "FORMAT")
+        "Timeformat used in output"
+    , Option ['s']    ["start"]
+        (ReqArg (\ arg opts -> return opts { optStartDate = arg }) "DATE")
+        "Start of reporting period"
+    , Option ['e']    ["end"]
+        (ReqArg (\ arg opts -> return opts { optEndDate = arg }) "DATE")
+        "End of reporting period"
+    ]
 
-parseRFC822Time :: String -> ZonedTime
-parseRFC822Time = parseToZonedTime rfc822DateFormat
+-- SECTION: Map of logentries to Map of Diddos
+logentryMapToDiddoMap :: Map.Map UTCTime Diddo.LogEntry -> Map.Map UTCTime Diddo.Diddo
+logentryMapToDiddoMap logmap = Map.mapWithKey toDddEntry logmap
+    where
+        toDddEntry key value    = Diddo.logToDiddo (precedingTimestamp key) value
+        precedingTimestamp x    = case Map.lookupLT x logmap of
+            Just (y,_)          -> y
+            Nothing             -> fst $ Map.findMin logmap
+-- SECTION: Map of logentries to Map of DiddoEntries
 
-formatZonedTime :: String -> ZonedTime -> String
-formatZonedTime format = formatTime defaultTimeLocale format
+main :: IO ()
+main = do
+    -- SECTION: option processing
+    (givenOptions,args,errs) <- getArgs >>= return . getOpt Permute availableOptions
+
+    unless (null errs) $ do
+        mapM_ (hPutStr stderr) errs
+        exitFailure
 
-zonedTimesDeltas :: ZonedTime -> [ZonedTime] -> [Integer]
-zonedTimesDeltas startTime timestamps =
-  let
-    startTimeUTC        = zonedTimeToUTC startTime
-    relevantTimestamps  = dropWhile (< startTimeUTC) $ map zonedTimeToUTC timestamps
-  in
-    zipWith diffSeconds relevantTimestamps $ startTimeUTC : init relevantTimestamps
+    effectiveOptions <- foldl (>>=) (return defaultOpts) givenOptions
 
-startOfZonedDay :: ZonedTime -> ZonedTime
-startOfZonedDay time = ZonedTime (LocalTime day midnight) $ zonedTimeZone time
-  where
-    day = localDay $ zonedTimeToLocalTime time
+    let
+        inDateFmt               = optInputFormat effectiveOptions
+        outDateFmt              = optOutputFormat effectiveOptions
 
-mainWithOpts :: DiddoOpts -> IO ()
-mainWithOpts opts =
-  do
-    [
-      timeStamps
-      , entryText
-      ]                     <- transpose . map (splitOn ";") . lines <$> readFile (inFile opts)
+        startDate               = parseToZonedTime inDateFmt $ optStartDate effectiveOptions
+        endDate                 = parseToZonedTime inDateFmt $ optEndDate effectiveOptions
+    -- SECTION: option processing
+
+    loglines <- case optInputFiles effectiveOptions of
+            files@(_:_)     -> T.lines . T.concat <$> mapM TIO.readFile files
+            []              -> T.lines <$> TIO.getContents
 
     let
-      parseCustomTime       = parseToZonedTime $ inDateFmt opts
---      parsedTimes           = map (parseToZonedTime $ inDateFmt opts) timeStamps
-      parsedTimes           = map parseCustomTime timeStamps
-      deltasHMS             = map secondsToHMS $ zonedTimesDeltas (startOfZonedDay $ head parsedTimes) parsedTimes
-      diddos_summarized     = zipWith4 DiddoEntry
-                                ((formatZonedTime (inDateFmt opts) $ startOfZonedDay $ head parsedTimes) : init timeStamps)
-                                timeStamps deltasHMS entryText
+        timestampLogentryMap                        = Map.fromList $ map Diddo.parseDiddoLogline loglines
+        (_, _, startedTimestampLogentryMap)         = Map.splitLookup (zonedTimeToUTC startDate) timestampLogentryMap
+        (endedTimestampLogentryMap, lastEntry, _)   = Map.splitLookup (zonedTimeToUTC endDate) startedTimestampLogentryMap
+        timestampDiddoMap                           = logentryMapToDiddoMap timestampLogentryMap
 
-    mapM_ print diddos_summarized
+    -- DEBUG
+    mapM_ putStrLn args
+    -- DEBUG
 
-main :: IO ()
-main = execParser opts >>= mainWithOpts
-  where
-    opts = info (helper <*> parser)
-      ( header "diddohs - A Time/Task Tracker"
-     <> progDesc "Diddoh Desc"
---     <> briefDesc
-     <> fullDesc
-     )
-    parser = DiddoOpts
-      <$> strOption ( long "indateform"
-                   <> help "Input date format, see date(1)"
-                   )
-      <*> strOption ( long "infile" )
+    mapM_ (TIO.putStrLn . snd) $ Map.toAscList $ Map.map (Diddo.formatDiddo outDateFmt) timestampDiddoMap