+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 Data.Time.Git( approxidate )
-import Data.Time.LocalTime( utcToLocalTime, getTimeZone )
-import Data.Time.Clock.POSIX( posixSecondsToUTCTime )
-import Data.List.Split( splitOn )
-import Data.List( zip4, intersperse )
-import Data.Maybe( fromJust )
-import Control.Monad( forM_ )
-import Text.Printf
+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
-main = do
- logfile_name : _ <- getArgs
- logfile_content <- readFile logfile_name
- let loglines = lines logfile_content
- loglines_split = map (splitOn ";") loglines
+data Opt = Opt
+ { optVerbose :: Bool
+ , optVersion :: Bool
+ , optHelp :: Bool
+ , optInputFiles :: [String]
+ , optOutputFile :: String
+ , optInputFormat :: String
+ , optOutputFormat :: String
+ , optStartDate :: String
+ , optEndDate :: String
+ }
+
+defaultOpts :: Opt
+defaultOpts = Opt
+ { optVerbose = False
+ , optVersion = False
+ , optHelp = False
+ , optInputFiles = []
+ , optOutputFile = ""
+ , optInputFormat = "%FT%T%z"
+ , optOutputFormat = "%FT%T%z"
+ , optStartDate = ""
+ , optEndDate = ""
+ }
- entries = map (head . tail) loglines_split
+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"
+ ]
- timestrings_finish = map head loglines_split
- timestrings_start = "" : init timestrings_finish
+-- 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
- timestamps_finish = map timestringToEpoch timestrings_finish
- timestamps_start = 0 : init timestamps_finish
+main :: IO ()
+main = do
+ -- SECTION: option processing
+ (givenOptions,args,errs) <- getArgs >>= return . getOpt Permute availableOptions
- timestamps_deltas = zipWith (-) timestamps_finish timestamps_start
- timestamps_deltas_HMMSS = map secondsToHMMSS timestamps_deltas
+ unless (null errs) $ do
+ mapM_ (hPutStr stderr) errs
+ exitFailure
- delta_entry_tuples = zip timestamps_deltas_HMMSS entries
- summaries = zip4 (map show timestrings_start) (map show timestrings_finish) timestamps_deltas_HMMSS entries
+ effectiveOptions <- foldl (>>=) (return defaultOpts) givenOptions
- forM_ summaries $ \(start, finish, delta, entry) ->
- putStrLn $ concat $ intersperse ";" [start, finish, delta, entry]
+ let
+ inDateFmt = optInputFormat effectiveOptions
+ outDateFmt = optOutputFormat effectiveOptions
-timestringToEpoch :: String -> Integer
-timestringToEpoch = fromJust . approxidate
+ startDate = parseToZonedTime inDateFmt $ optStartDate effectiveOptions
+ endDate = parseToZonedTime inDateFmt $ optEndDate effectiveOptions
+ -- SECTION: option processing
-secondsToHMMSS :: (Num seconds, Show seconds, Integral seconds, Text.Printf.PrintfArg seconds) => seconds -> String
-secondsToHMMSS seconds = printf "%d:%02d:%02d" h m s
- where
- (mLeft, s) = seconds `divMod` 60
- (h, m) = mLeft `divMod` 60
+ loglines <- case optInputFiles effectiveOptions of
+ files@(_:_) -> T.lines . T.concat <$> mapM TIO.readFile files
+ [] -> T.lines <$> TIO.getContents
-getStartOfDay :: Num t => t -> t
-getStartOfDay time = 0
+ let
+ timestampLogentryMap = Map.fromList $ map Diddo.parseDiddoLogline loglines
+ (_, _, startedTimestampLogentryMap) = Map.splitLookup (zonedTimeToUTC startDate) timestampLogentryMap
+ (endedTimestampLogentryMap, lastEntry, _) = Map.splitLookup (zonedTimeToUTC endDate) startedTimestampLogentryMap
+ timestampDiddoMap = logentryMapToDiddoMap timestampLogentryMap
---epochToTimestring :: Num t => t -> String
---epochToTimestring epochtime = let getTZ = getTimeZone utctime in utcToLocalTime getTZ utctime
--- where
--- tz = getTimeZone utctime
--- utctime = posixSecondsToUTCTime epochtime
+ -- DEBUG
+ mapM_ putStrLn args
+ -- DEBUG
---getTZ time = do
--- getTimeZone time
+ mapM_ (TIO.putStrLn . snd) $ Map.toAscList $ Map.map (Diddo.formatDiddo outDateFmt) timestampDiddoMap
projects / user / henk / code / haskell / diddohs.git / blobdiff