1067 lines
35 KiB
Haskell
1067 lines
35 KiB
Haskell
module Internal.Utils
|
|
( compareDate
|
|
, expandDatePat
|
|
, askDays
|
|
, fromWeekday
|
|
, inDaySpan
|
|
, fromGregorian'
|
|
, resolveDaySpan
|
|
, resolveDaySpan_
|
|
, intersectDaySpan
|
|
, throwAppError
|
|
, liftInner
|
|
, liftExceptT
|
|
, liftExcept
|
|
, liftIOExcept
|
|
, liftIOExceptT
|
|
, combineError
|
|
, combineError_
|
|
, combineError3
|
|
, combineErrors
|
|
, mapErrors
|
|
, combineErrorM
|
|
, combineErrorM3
|
|
, combineErrorIO2
|
|
, combineErrorIO3
|
|
, combineErrorIOM2
|
|
, combineErrorIOM3
|
|
, collectErrorsIO
|
|
, mapErrorsIO
|
|
, mapErrorsPooledIO
|
|
, showError
|
|
, lookupErr
|
|
, uncurry3
|
|
, dateMatches
|
|
, valMatches
|
|
, lookupAccount
|
|
, lookupAccountKey
|
|
, lookupAccountType
|
|
, lookupCurrency
|
|
, lookupCurrencyKey
|
|
, lookupCurrencyPrec
|
|
, lookupTag
|
|
, mapAdd_
|
|
, groupKey
|
|
, groupWith
|
|
, balanceTxs
|
|
, expandTransfers
|
|
, expandTransfer
|
|
, entryPair
|
|
, singleQuote
|
|
, keyVals
|
|
, realFracToDecimalP
|
|
, roundToP
|
|
, compileRegex
|
|
, matchMaybe
|
|
, matchGroupsMaybe
|
|
)
|
|
where
|
|
|
|
import Control.Monad.Error.Class
|
|
import Control.Monad.Except
|
|
import Data.Decimal
|
|
import Data.Time.Format.ISO8601
|
|
import qualified Database.Esqueleto.Experimental as E
|
|
import GHC.Real
|
|
import Internal.Types.Main
|
|
import RIO
|
|
import qualified RIO.List as L
|
|
import qualified RIO.Map as M
|
|
import qualified RIO.NonEmpty as NE
|
|
import RIO.State
|
|
import qualified RIO.Text as T
|
|
import RIO.Time
|
|
import qualified RIO.Vector as V
|
|
import Text.Regex.TDFA hiding (matchAll)
|
|
import Text.Regex.TDFA.Text
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- intervals
|
|
|
|
expandDatePat :: DaySpan -> DatePat -> AppExcept [Day]
|
|
expandDatePat b (Cron cp) = expandCronPat b cp
|
|
expandDatePat i (Mod mp) = return $ expandModPat mp i
|
|
|
|
expandModPat :: ModPat -> DaySpan -> [Day]
|
|
expandModPat ModPat {mpStart = s, mpBy = b, mpUnit = u, mpRepeats = r} bs =
|
|
takeWhile (<= upper) $
|
|
(`addFun` start) . (* b')
|
|
<$> maybe id (take . fromIntegral) r [0 ..]
|
|
where
|
|
(lower, upper) = fromDaySpan bs
|
|
start = maybe lower fromGregorian' s
|
|
b' = fromIntegral b
|
|
addFun = case u of
|
|
Day -> addDays
|
|
Week -> addDays . (* 7)
|
|
Month -> addGregorianMonthsClip
|
|
Year -> addGregorianYearsClip
|
|
|
|
expandCronPat :: DaySpan -> CronPat -> AppExcept [Day]
|
|
expandCronPat b CronPat {cpYear, cpMonth, cpDay, cpWeekly} =
|
|
combineError3 yRes mRes dRes $ \ys ms ds ->
|
|
filter validWeekday $
|
|
mapMaybe (uncurry3 toDay) $
|
|
takeWhile (\((y, _), m, d) -> (y, m, d) <= (yb1, mb1, db1)) $
|
|
dropWhile (\((y, _), m, d) -> (y, m, d) < (yb0, mb0, db0)) $
|
|
[(y, m, d) | y <- (\y -> (y, isLeapYear y)) <$> ys, m <- ms, d <- ds]
|
|
where
|
|
yRes = case cpYear of
|
|
Nothing -> return [yb0 .. yb1]
|
|
Just pat -> do
|
|
ys <- expandMDYPat (fromIntegral yb0) (fromIntegral yb1) pat
|
|
return $ dropWhile (< yb0) $ fromIntegral <$> ys
|
|
mRes = expandMD 12 cpMonth
|
|
dRes = expandMD 31 cpDay
|
|
(s, e) = fromDaySpan b
|
|
(yb0, mb0, db0) = toGregorian s
|
|
(yb1, mb1, db1) = toGregorian $ addDays (-1) e
|
|
expandMD lim =
|
|
fmap (fromIntegral <$>)
|
|
. maybe (return [1 .. lim]) (expandMDYPat 1 lim)
|
|
expandW (OnDay x) = [fromEnum x]
|
|
expandW (OnDays xs) = fromEnum <$> xs
|
|
ws = maybe [] expandW cpWeekly
|
|
validWeekday = if null ws then const True else \day -> dayToWeekday day `elem` ws
|
|
toDay (y, leap) m d
|
|
| m == 2 && (not leap && d > 28 || leap && d > 29) = Nothing
|
|
| m `elem` [4, 6, 9, 11] && d > 30 = Nothing
|
|
| otherwise = Just $ fromGregorian y m d
|
|
|
|
expandMDYPat :: Natural -> Natural -> MDYPat -> AppExcept [Natural]
|
|
expandMDYPat lower upper (Single x) = return [x | lower <= x && x <= upper]
|
|
expandMDYPat lower upper (Multi xs) = return $ dropWhile (<= lower) $ takeWhile (<= upper) xs
|
|
expandMDYPat lower upper (After x) = return [max lower x .. upper]
|
|
expandMDYPat lower upper (Before x) = return [lower .. min upper x]
|
|
expandMDYPat lower upper (Between x y) = return [max lower x .. min upper y]
|
|
expandMDYPat lower upper (Repeat RepeatPat {rpStart = s, rpBy = b, rpRepeats = r})
|
|
| b < 1 = throwAppError $ DatePatternError s b r ZeroLength
|
|
| otherwise = do
|
|
k <- limit r
|
|
return $ dropWhile (<= lower) $ takeWhile (<= k) [s + i * b | i <- [0 ..]]
|
|
where
|
|
limit Nothing = return upper
|
|
limit (Just n)
|
|
-- this guard not only produces the error for the user but also protects
|
|
-- from an underflow below it
|
|
| n < 1 = throwAppError $ DatePatternError s b r ZeroRepeats
|
|
| otherwise = return $ min (s + b * (n - 1)) upper
|
|
|
|
dayToWeekday :: Day -> Int
|
|
dayToWeekday (ModifiedJulianDay d) = mod (fromIntegral d + 2) 7
|
|
|
|
askDays
|
|
:: (MonadFinance m, MonadAppError m)
|
|
=> DatePat
|
|
-> Maybe Interval
|
|
-> m [Day]
|
|
askDays dp i = do
|
|
globalSpan <- asks (unBSpan . tsBudgetScope)
|
|
case i of
|
|
Just i' -> do
|
|
localSpan <- liftExcept $ resolveDaySpan i'
|
|
maybe (return []) expand $ intersectDaySpan globalSpan localSpan
|
|
Nothing -> expand globalSpan
|
|
where
|
|
expand = liftExcept . (`expandDatePat` dp)
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- dates
|
|
|
|
-- | Lame weekday converter since day of weeks aren't in dhall (yet)
|
|
fromWeekday :: Weekday -> DayOfWeek
|
|
fromWeekday Mon = Monday
|
|
fromWeekday Tue = Tuesday
|
|
fromWeekday Wed = Wednesday
|
|
fromWeekday Thu = Thursday
|
|
fromWeekday Fri = Friday
|
|
fromWeekday Sat = Saturday
|
|
fromWeekday Sun = Sunday
|
|
|
|
gregTup :: Gregorian -> (Integer, Int, Int)
|
|
gregTup Gregorian {gYear, gMonth, gDay} =
|
|
( fromIntegral gYear
|
|
, fromIntegral gMonth
|
|
, fromIntegral gDay
|
|
)
|
|
|
|
gregMTup :: GregorianM -> (Integer, Int)
|
|
gregMTup GregorianM {gmYear, gmMonth} =
|
|
( fromIntegral gmYear
|
|
, fromIntegral gmMonth
|
|
)
|
|
|
|
data YMD_ = Y_ !Integer | YM_ !Integer !Int | YMD_ !Integer !Int !Int
|
|
|
|
fromYMDMatcher :: YMDMatcher -> YMD_
|
|
fromYMDMatcher m = case m of
|
|
Y y -> Y_ $ fromIntegral y
|
|
YM g -> uncurry YM_ $ gregMTup g
|
|
YMD g -> uncurry3 YMD_ $ gregTup g
|
|
|
|
compareDate :: DateMatcher -> Day -> Ordering
|
|
compareDate (On md) x =
|
|
case fromYMDMatcher md of
|
|
Y_ y' -> compare y y'
|
|
YM_ y' m' -> compare (y, m) (y', m')
|
|
YMD_ y' m' d' -> compare (y, m, d) (y', m', d')
|
|
where
|
|
(y, m, d) = toGregorian x
|
|
compareDate (In md offset) x = do
|
|
case fromYMDMatcher md of
|
|
Y_ y' -> compareRange y' y
|
|
YM_ y' m' -> compareRange (toMonth y' m') $ toMonth y m
|
|
YMD_ y' m' d' ->
|
|
let s = toModifiedJulianDay $ fromGregorian y' m' d'
|
|
in compareRange s $ toModifiedJulianDay x
|
|
where
|
|
(y, m, _) = toGregorian x
|
|
compareRange start z
|
|
| z < start = LT
|
|
| otherwise = if (start + fromIntegral offset - 1) < z then GT else EQ
|
|
toMonth year month = (year * 12) + fromIntegral month
|
|
|
|
fromGregorian' :: Gregorian -> Day
|
|
fromGregorian' = uncurry3 fromGregorian . gregTup
|
|
|
|
inDaySpan :: DaySpan -> Day -> Bool
|
|
inDaySpan bs = withinDays (fromDaySpan bs)
|
|
|
|
withinDays :: (Day, Day) -> Day -> Bool
|
|
withinDays (d0, d1) x = d0 <= x && x < d1
|
|
|
|
resolveDaySpan :: Interval -> AppExcept DaySpan
|
|
resolveDaySpan i@Interval {intStart = s} =
|
|
resolveDaySpan_ (s {gYear = gYear s + 50}) i
|
|
|
|
intersectDaySpan :: DaySpan -> DaySpan -> Maybe DaySpan
|
|
intersectDaySpan a b =
|
|
if b' > a' then Nothing else Just $ toDaySpan (a', b')
|
|
where
|
|
(a0, a1) = fromDaySpan a
|
|
(b0, b1) = fromDaySpan b
|
|
a' = max a0 a1
|
|
b' = min b0 b1
|
|
|
|
resolveDaySpan_ :: Gregorian -> Interval -> AppExcept DaySpan
|
|
resolveDaySpan_ def Interval {intStart = s, intEnd = e} =
|
|
-- TODO the default isn't checked here :/
|
|
case fromGregorian' <$> e of
|
|
Nothing -> return $ toDaySpan_ $ fromGregorian' def
|
|
Just e_
|
|
| s_ < e_ -> return $ toDaySpan_ e_
|
|
| otherwise -> throwAppError $ DaySpanError s e
|
|
where
|
|
s_ = fromGregorian' s
|
|
toDaySpan_ end = toDaySpan (s_, end)
|
|
|
|
fromDaySpan :: DaySpan -> (Day, Day)
|
|
fromDaySpan (d, n) = (d, addDays (fromIntegral n + 1) d)
|
|
|
|
-- ASSUME a < b
|
|
toDaySpan :: (Day, Day) -> DaySpan
|
|
toDaySpan (a, b) = (a, fromIntegral $ diffDays b a - 1)
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- matching
|
|
|
|
valMatches :: ValMatcher -> Rational -> AppExcept Bool
|
|
valMatches ValMatcher {vmDen, vmSign, vmNum, vmPrec} x
|
|
| Just d_ <- vmDen, d_ >= p = throwAppError $ MatchValPrecisionError d_ p
|
|
| otherwise =
|
|
return $
|
|
checkMaybe (s ==) vmSign
|
|
&& checkMaybe (n ==) vmNum
|
|
&& checkMaybe ((d * fromIntegral p ==) . fromIntegral) vmDen
|
|
where
|
|
(n, d) = properFraction $ abs x
|
|
p = 10 ^ vmPrec
|
|
s = signum x >= 0
|
|
checkMaybe = maybe True
|
|
|
|
dateMatches :: DateMatcher -> Day -> Bool
|
|
dateMatches md = (EQ ==) . compareDate md
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- error flow control
|
|
|
|
throwAppError :: MonadAppError m => AppError -> m a
|
|
throwAppError e = throwError $ AppException [e]
|
|
|
|
liftInner :: Monad m => ExceptT e Identity a -> ExceptT e m a
|
|
liftInner = mapExceptT (return . runIdentity)
|
|
|
|
liftExceptT :: MonadError e m => ExceptT e m a -> m a
|
|
liftExceptT x = runExceptT x >>= either throwError return
|
|
|
|
liftExcept :: MonadError e m => Except e a -> m a
|
|
liftExcept = either throwError return . runExcept
|
|
|
|
liftIOExceptT :: MonadIO m => AppExceptT m a -> m a
|
|
liftIOExceptT = fromEither <=< runExceptT
|
|
|
|
liftIOExcept :: MonadIO m => AppExcept a -> m a
|
|
liftIOExcept = fromEither . runExcept
|
|
|
|
combineError :: MonadAppError m => m a -> m b -> (a -> b -> c) -> m c
|
|
combineError a b f = combineErrorM a b (\x y -> pure $ f x y)
|
|
|
|
combineError_ :: MonadAppError m => m a -> m b -> m ()
|
|
combineError_ a b = do
|
|
_ <- catchError a $ \e ->
|
|
throwError =<< catchError (e <$ b) (return . (e <>))
|
|
_ <- b
|
|
return ()
|
|
|
|
combineErrorM :: MonadAppError m => m a -> m b -> (a -> b -> m c) -> m c
|
|
combineErrorM a b f = do
|
|
a' <- catchError a $ \e ->
|
|
throwError =<< catchError (e <$ b) (return . (e <>))
|
|
f a' =<< b
|
|
|
|
combineError3 :: MonadAppError m => m a -> m b -> m c -> (a -> b -> c -> d) -> m d
|
|
combineError3 a b c f =
|
|
combineError (combineError a b (,)) c $ \(x, y) z -> f x y z
|
|
|
|
combineErrorM3 :: MonadAppError m => m a -> m b -> m c -> (a -> b -> c -> m d) -> m d
|
|
combineErrorM3 a b c f = do
|
|
combineErrorM (combineErrorM a b (curry return)) c $ \(x, y) z -> f x y z
|
|
|
|
mapErrors :: (Traversable t, MonadAppError m) => (a -> m b) -> t a -> m (t b)
|
|
-- First, record number of each action. Then try each action. On first failure,
|
|
-- note it's position in the sequence, skip ahead to the untried actions,
|
|
-- collect failures and add to the first failure.
|
|
mapErrors f xs = mapM go $ enumTraversable xs
|
|
where
|
|
go (n, x) = catchError (f x) $ \e -> do
|
|
es <- fmap catMaybes $ mapM (err . f) $ drop (n + 1) $ toList xs
|
|
throwError $ foldr (<>) e es
|
|
err x = catchError (Nothing <$ x) (pure . Just)
|
|
|
|
combineErrors :: (Traversable t, MonadAppError m) => t (m a) -> m (t a)
|
|
combineErrors = mapErrors id
|
|
|
|
enumTraversable :: (Num n, Traversable t) => t a -> t (n, a)
|
|
enumTraversable = snd . L.mapAccumL go 0
|
|
where
|
|
go n x = (n + 1, (n, x))
|
|
|
|
combineErrorIO2 :: MonadUnliftIO m => m a -> m b -> (a -> b -> c) -> m c
|
|
combineErrorIO2 a b f = combineErrorIOM2 a b (\x y -> pure $ f x y)
|
|
|
|
combineErrorIO3 :: MonadUnliftIO m => m a -> m b -> m c -> (a -> b -> c -> d) -> m d
|
|
combineErrorIO3 a b c f = combineErrorIOM3 a b c (\x y z -> pure $ f x y z)
|
|
|
|
combineErrorIOM2 :: MonadUnliftIO m => m a -> m b -> (a -> b -> m c) -> m c
|
|
combineErrorIOM2 a b f = do
|
|
a' <- catch a $ \(AppException es) ->
|
|
(throwIO . AppException)
|
|
=<< catch (es <$ b) (\(AppException es') -> return (es' ++ es))
|
|
f a' =<< b
|
|
|
|
combineErrorIOM3 :: MonadUnliftIO m => m a -> m b -> m c -> (a -> b -> c -> m d) -> m d
|
|
combineErrorIOM3 a b c f =
|
|
combineErrorIOM2 (combineErrorIOM2 a b (curry return)) c $ \(x, y) z -> f x y z
|
|
|
|
mapErrorsPooledIO :: (Traversable t, MonadUnliftIO m) => Int -> (a -> m b) -> t a -> m (t b)
|
|
mapErrorsPooledIO t f xs = pooledMapConcurrentlyN t go $ enumTraversable xs
|
|
where
|
|
go (n, x) = catch (f x) $ \(AppException e) -> do
|
|
es <- fmap catMaybes $ mapM (err . f) $ drop (n + 1) $ toList xs
|
|
throwIO $ AppException $ foldr (<>) e es
|
|
err x = catch (Nothing <$ x) $ \(AppException es) -> pure $ Just es
|
|
|
|
mapErrorsIO :: (Traversable t, MonadUnliftIO m) => (a -> m b) -> t a -> m (t b)
|
|
mapErrorsIO f xs = mapM go $ enumTraversable xs
|
|
where
|
|
go (n, x) = catch (f x) $ \(AppException e) -> do
|
|
es <- fmap catMaybes $ mapM (err . f) $ drop (n + 1) $ toList xs
|
|
throwIO $ AppException $ foldr (<>) e es
|
|
err x = catch (Nothing <$ x) $ \(AppException es) -> pure $ Just es
|
|
|
|
collectErrorsIO :: (Traversable t, MonadUnliftIO m) => t (m a) -> m (t a)
|
|
collectErrorsIO = mapErrorsIO id
|
|
|
|
lookupErr :: (Ord k, Show k) => LookupSuberr -> k -> M.Map k v -> AppExcept v
|
|
lookupErr what k m = case M.lookup k m of
|
|
Just x -> return x
|
|
_ -> throwAppError $ LookupError what $ tshow k
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- error display
|
|
|
|
showError :: AppError -> [T.Text]
|
|
showError other = case other of
|
|
(StatementError ts ms) -> (showTx <$> ts) ++ (showMatch <$> ms)
|
|
(DaySpanError a b) ->
|
|
[T.unwords ["Could not create bounds from", showGregorian_ a, "and", showGreg b]]
|
|
where
|
|
showGreg (Just g) = showGregorian_ g
|
|
showGreg Nothing = "Inf"
|
|
(AccountTypeError a ts) ->
|
|
[ T.unwords
|
|
[ "account type of key"
|
|
, singleQuote $ unAcntID a
|
|
, "is not one of:"
|
|
, ts_
|
|
]
|
|
]
|
|
where
|
|
ts_ = T.intercalate ", " $ NE.toList $ fmap atName ts
|
|
(DatePatternError s b r p) -> [T.unwords [msg, "in pattern: ", pat]]
|
|
where
|
|
pat =
|
|
keyVals $
|
|
[ (k, v)
|
|
| (k, Just v) <-
|
|
[ ("start", Just $ tshow s)
|
|
, ("by", Just $ tshow b)
|
|
, ("repeats", tshow <$> r)
|
|
]
|
|
]
|
|
msg = case p of
|
|
ZeroLength -> "Zero repeat length"
|
|
ZeroRepeats -> "Zero repeats"
|
|
(RegexError re) -> [T.append "could not make regex from pattern: " re]
|
|
(ConversionError x isDouble) ->
|
|
[ T.unwords
|
|
[ "Could not convert to"
|
|
, if isDouble then "double" else "rational"
|
|
, "number: "
|
|
, x
|
|
]
|
|
]
|
|
(StatementIOError msg) -> [T.append "IO Error: " msg]
|
|
(ParseError msg) -> [T.append "Parse Error: " msg]
|
|
(MatchValPrecisionError d p) ->
|
|
[T.unwords ["Match denominator", tshow d, "must be less than", tshow p]]
|
|
(LookupError t f) ->
|
|
[T.unwords ["Could not find field", f, "when resolving", what]]
|
|
where
|
|
what = case t of
|
|
EntryIDField st -> T.unwords ["entry", idName st, "ID"]
|
|
EntryValField -> "entry value"
|
|
MatchField mt -> T.unwords [matchName mt, "match"]
|
|
DBKey st -> T.unwords ["database", idName st, "ID key"]
|
|
-- TODO this should be its own function
|
|
idName AcntField = "account"
|
|
idName CurField = "currency"
|
|
idName TagField = "tag"
|
|
matchName MatchNumeric = "numeric"
|
|
matchName MatchText = "text"
|
|
(PeriodError start next) ->
|
|
[ T.unwords
|
|
[ "First pay period on "
|
|
, singleQuote $ tshow start
|
|
, "must start before first income payment on "
|
|
, singleQuote $ tshow next
|
|
]
|
|
]
|
|
(LinkError i m) ->
|
|
[ T.unwords
|
|
[ "entry index"
|
|
, singleQuote $ tshow i
|
|
, "out of range: max index is"
|
|
, singleQuote $ tshow m
|
|
]
|
|
]
|
|
(DBError d) -> case d of
|
|
DBShouldBeEmpty -> ["database has no rows in 'config_state' but has other data"]
|
|
DBMultiScope -> ["database has multiple rows in 'config_state'"]
|
|
DBUpdateUnbalanced -> ["update is missing debit or credit entries"]
|
|
DBLinkError k l ->
|
|
let k' = T.append "in entry key: " $ tshow $ E.fromSqlKey k
|
|
in case l of
|
|
DBLinkNoScale -> [T.append "no link scale" k']
|
|
DBLinkNoValue -> [T.append "no link value" k']
|
|
DBLinkInvalidValue v isfixed ->
|
|
[ T.unwords
|
|
[ if isfixed
|
|
then "fixed link should not have value"
|
|
else "untyped value is ambiguous"
|
|
, singleQuote $ tshow v
|
|
, k'
|
|
]
|
|
]
|
|
DBLinkInvalidBalance -> [T.append "no value given for balance link" k']
|
|
DBLinkInvalidPercent -> [T.append "no value given for percent link" k']
|
|
|
|
showGregorian_ :: Gregorian -> T.Text
|
|
showGregorian_ Gregorian {gYear, gMonth, gDay} = T.intercalate "-" $ tshow <$> [gYear, gMonth, gDay]
|
|
|
|
showTx :: TxRecord -> T.Text
|
|
showTx TxRecord {trDate = d, trAmount = v, trDesc = e, trFile = f} =
|
|
T.append "Unmatched transaction: " $
|
|
keyVals
|
|
[ ("path", T.pack f)
|
|
, ("date", T.pack $ iso8601Show d)
|
|
, ("value", tshow v)
|
|
, ("description", doubleQuote $ unTxDesc e)
|
|
]
|
|
|
|
showMatch :: StatementParserRe -> T.Text
|
|
showMatch StatementParser {spDate, spVal, spDesc, spOther, spTimes, spPriority} =
|
|
T.append "Unused match: " $ keyVals [(x, y) | (x, Just y) <- kvs]
|
|
where
|
|
kvs =
|
|
[ ("date", showDateMatcher <$> spDate)
|
|
, ("val", showValMatcher spVal)
|
|
, ("desc", fst <$> spDesc)
|
|
, ("other", others)
|
|
, ("counter", Just $ maybe "Inf" tshow spTimes)
|
|
, ("priority", Just $ tshow spPriority)
|
|
]
|
|
others = case spOther of
|
|
[] -> Nothing
|
|
xs -> Just $ singleQuote $ T.concat $ showMatchOther <$> xs
|
|
|
|
-- | Convert match date to text
|
|
-- Single date matches will just show the single date, and ranged matches will
|
|
-- show an interval like [YY-MM-DD, YY-MM-DD)
|
|
showDateMatcher :: DateMatcher -> T.Text
|
|
showDateMatcher md = case md of
|
|
(On x) -> showYMDMatcher x
|
|
(In start n) -> T.concat ["[", showYMDMatcher start, " ", showYMD_ end, ")"]
|
|
where
|
|
-- TODO not DRY (this shifting thing happens during the comparison
|
|
-- function (kinda)
|
|
end = case fromYMDMatcher start of
|
|
Y_ y -> Y_ $ y + fromIntegral n
|
|
YM_ y m ->
|
|
let (y_, m_) = divMod (m + fromIntegral n - 1) 12
|
|
in YM_ (y + fromIntegral y_) (m + m_ + 1)
|
|
YMD_ y m d ->
|
|
uncurry3 YMD_ $
|
|
toGregorian $
|
|
addDays (fromIntegral n) $
|
|
fromGregorian y m d
|
|
|
|
-- | convert YMD match to text
|
|
showYMDMatcher :: YMDMatcher -> T.Text
|
|
showYMDMatcher = showYMD_ . fromYMDMatcher
|
|
|
|
showYMD_ :: YMD_ -> T.Text
|
|
showYMD_ md =
|
|
T.intercalate "-" $ L.take 3 (fmap tshow digits ++ L.repeat "*")
|
|
where
|
|
digits = case md of
|
|
Y_ y -> [fromIntegral y]
|
|
YM_ y m -> [fromIntegral y, m]
|
|
YMD_ y m d -> [fromIntegral y, m, d]
|
|
|
|
showValMatcher :: ValMatcher -> Maybe T.Text
|
|
showValMatcher ValMatcher {vmSign = Nothing, vmNum = Nothing, vmDen = Nothing} = Nothing
|
|
showValMatcher ValMatcher {vmNum, vmDen, vmSign, vmPrec} =
|
|
Just $ singleQuote $ keyVals [(k, v) | (k, Just v) <- kvs]
|
|
where
|
|
kvs =
|
|
[ ("sign", (\s -> if s then "+" else "-") <$> vmSign)
|
|
, ("numerator", tshow <$> vmNum)
|
|
, ("denominator", tshow <$> vmDen)
|
|
, ("precision", Just $ tshow vmPrec)
|
|
]
|
|
|
|
showMatchOther :: FieldMatcherRe -> T.Text
|
|
showMatchOther (Desc (Field f (re, _))) =
|
|
T.unwords ["desc field", singleQuote f, "with re", singleQuote re]
|
|
showMatchOther (Val (Field f mv)) =
|
|
T.unwords
|
|
[ "val field"
|
|
, singleQuote f
|
|
, "with match value"
|
|
, singleQuote $ fromMaybe "*" $ showValMatcher mv
|
|
]
|
|
|
|
singleQuote :: T.Text -> T.Text
|
|
singleQuote t = T.concat ["'", t, "'"]
|
|
|
|
doubleQuote :: T.Text -> T.Text
|
|
doubleQuote t = T.concat ["'", t, "'"]
|
|
|
|
keyVal :: T.Text -> T.Text -> T.Text
|
|
keyVal a b = T.concat [a, "=", b]
|
|
|
|
keyVals :: [(T.Text, T.Text)] -> T.Text
|
|
keyVals = T.intercalate "; " . fmap (uncurry keyVal)
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- random functions
|
|
|
|
groupKey :: Ord c => (a -> c) -> [(a, b)] -> [(a, NonEmpty b)]
|
|
groupKey f = fmap go . NE.groupAllWith (f . fst)
|
|
where
|
|
go xs@((c, _) :| _) = (c, fmap snd xs)
|
|
|
|
groupWith :: Ord b => (a -> b) -> [a] -> [(b, NonEmpty a)]
|
|
groupWith f = fmap go . NE.groupAllWith fst . fmap (\x -> (f x, x))
|
|
where
|
|
go xs@((c, _) :| _) = (c, fmap snd xs)
|
|
|
|
mapAdd_ :: (Ord k, Num v) => k -> v -> M.Map k v -> M.Map k v
|
|
mapAdd_ k v = M.alter (maybe (Just v) (Just . (+ v))) k
|
|
|
|
uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d
|
|
uncurry3 f (a, b, c) = f a b c
|
|
|
|
lookupAccount :: (MonadAppError m, MonadFinance m) => AcntID -> m (AccountRId, AcntType)
|
|
lookupAccount = lookupFinance AcntField tsAccountMap
|
|
|
|
lookupAccountKey :: (MonadAppError m, MonadFinance m) => AcntID -> m AccountRId
|
|
lookupAccountKey = fmap fst . lookupAccount
|
|
|
|
lookupAccountType :: (MonadAppError m, MonadFinance m) => AcntID -> m AcntType
|
|
lookupAccountType = fmap snd . lookupAccount
|
|
|
|
lookupCurrency :: (MonadAppError m, MonadFinance m) => CurID -> m CurrencyPrec
|
|
lookupCurrency = lookupFinance CurField tsCurrencyMap
|
|
|
|
lookupCurrencyKey :: (MonadAppError m, MonadFinance m) => CurID -> m CurrencyRId
|
|
lookupCurrencyKey = fmap cpID . lookupCurrency
|
|
|
|
lookupCurrencyPrec :: (MonadAppError m, MonadFinance m) => CurID -> m Precision
|
|
lookupCurrencyPrec = fmap cpPrec . lookupCurrency
|
|
|
|
lookupTag :: (MonadAppError m, MonadFinance m) => TagID -> m TagRId
|
|
lookupTag = lookupFinance TagField tsTagMap
|
|
|
|
lookupFinance
|
|
:: (MonadAppError m, MonadFinance m, Ord k, Show k)
|
|
=> EntryIDType
|
|
-> (TxState -> M.Map k a)
|
|
-> k
|
|
-> m a
|
|
lookupFinance t f c = (liftExcept . lookupErr (DBKey t) c) =<< asks f
|
|
|
|
balanceTxs
|
|
:: (MonadAppError m, MonadFinance m)
|
|
=> [EntryCRU]
|
|
-> m ([UEBalanced], [InsertTx])
|
|
balanceTxs ebs =
|
|
first concat . partitionEithers . catMaybes
|
|
<$> evalStateT (mapErrors go $ L.sortOn binDate ebs) M.empty
|
|
where
|
|
go (ToUpdate utx) =
|
|
fmap (Just . Left) $
|
|
liftInnerS $
|
|
either rebalanceTotalEntrySet rebalanceFullEntrySet utx
|
|
go (ToRead ReadEntry {reCurrency, reAcnt, reValue}) = do
|
|
modify $ mapAdd_ (reAcnt, reCurrency) reValue
|
|
return Nothing
|
|
go (ToInsert Tx {txPrimary, txOther, txMeta}) = do
|
|
e <- either balancePrimaryEntrySet balanceSecondaryEntrySet txPrimary
|
|
let tot = sum $ fmap (eValue . ieEntry) $ NE.toList $ iesFromEntries e
|
|
es <- mapErrors (goOther tot) txOther
|
|
let tx = InsertTx {itxMeta = txMeta, itxEntrySets = e :| es}
|
|
return $ Just $ Right tx
|
|
where
|
|
goOther tot =
|
|
either
|
|
balanceSecondaryEntrySet
|
|
(balancePrimaryEntrySet . fromShadow tot)
|
|
fromShadow tot e@EntrySet {esTotalValue} = e {esTotalValue = tot *. esTotalValue}
|
|
|
|
-- NOTE this sorting thing is super wonky; I'm basically sorting three different
|
|
-- levels of the hierarchy directory and assuming there will be no overlaps.
|
|
-- First, sort at the transaction level by day, priority, and description as
|
|
-- tiebreaker. Anything that shares those three keys will have an unstable sort
|
|
-- order. Within the entrysets, use the index as it appears in the
|
|
-- configuration, and same with the entries. Since we assume no overlap, nothing
|
|
-- "bad" should happen if the levels above entries/entrysets sort on 'Nothing'
|
|
-- for the indices they don't have at their level.
|
|
binDate :: EntryCRU -> (TxSortKey, Maybe EntrySetIndex, Maybe EntryIndex)
|
|
binDate (ToRead ReadEntry {reSortKey, reESIndex, reIndex}) = (reSortKey, Just reESIndex, Just reIndex)
|
|
binDate (ToInsert Tx {txMeta = (TxMeta t p d _)}) = (TxSortKey t p d, Nothing, Nothing)
|
|
binDate (ToUpdate u) = either go go u
|
|
where
|
|
go UpdateEntrySet {utSortKey, utIndex} = (utSortKey, Just utIndex, Nothing)
|
|
|
|
type BCKey = CurrencyRId
|
|
|
|
type ABCKey = (AccountRId, BCKey)
|
|
|
|
type EntryBals = M.Map ABCKey Decimal
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- rebalancing
|
|
|
|
-- TODO make sure new values are rounded properly here
|
|
rebalanceTotalEntrySet :: TotalUpdateEntrySet -> State EntryBals [UEBalanced]
|
|
rebalanceTotalEntrySet
|
|
UpdateEntrySet
|
|
{ utFrom0 = (f0@UpdateEntry {ueAcnt = f0Acnt}, f0links)
|
|
, utTo0
|
|
, utFromUnk
|
|
, utToUnk
|
|
, utFromRO
|
|
, utToRO
|
|
, utCurrency
|
|
, utTotalValue
|
|
} =
|
|
do
|
|
(fval, fs, tpairs) <- rebalanceDebit utCurrency utFromRO utFromUnk
|
|
let f0val = utTotalValue - fval
|
|
modify $ mapAdd_ (f0Acnt, utCurrency) f0val
|
|
let tsLinked = tpairs ++ (unlink f0val <$> f0links)
|
|
ts <- rebalanceCredit utCurrency utTotalValue utTo0 utToUnk utToRO tsLinked
|
|
return (f0 {ueValue = StaticValue f0val} : fs ++ ts)
|
|
|
|
rebalanceFullEntrySet :: FullUpdateEntrySet -> State EntryBals [UEBalanced]
|
|
rebalanceFullEntrySet
|
|
UpdateEntrySet
|
|
{ utFrom0
|
|
, utTo0
|
|
, utFromUnk
|
|
, utToUnk
|
|
, utFromRO
|
|
, utToRO
|
|
, utCurrency
|
|
} =
|
|
do
|
|
(ftot, fs, tpairs) <- rebalanceDebit utCurrency rs ls
|
|
ts <- rebalanceCredit utCurrency ftot utTo0 utToUnk utToRO tpairs
|
|
return (fs ++ ts)
|
|
where
|
|
(rs, ls) = case utFrom0 of
|
|
Left x -> (x : utFromRO, utFromUnk)
|
|
Right x -> (utFromRO, x : utFromUnk)
|
|
|
|
rebalanceDebit
|
|
:: BCKey
|
|
-> [UE_RO]
|
|
-> [(UEUnk, [UELink])]
|
|
-> State EntryBals (Decimal, [UEBalanced], [UEBalanced])
|
|
rebalanceDebit k ro linked = do
|
|
(tot, (tpairs, fs)) <-
|
|
fmap (second (partitionEithers . concat)) $
|
|
sumM goFrom $
|
|
L.sortOn idx $
|
|
(Left <$> ro) ++ (Right <$> linked)
|
|
return (tot, fs, tpairs)
|
|
where
|
|
idx = either ueIndex (ueIndex . fst)
|
|
goFrom (Left e) = (,[]) <$> updateFixed k e
|
|
goFrom (Right (e0, es)) = do
|
|
v <- updateUnknown k e0
|
|
let e0' = Right $ e0 {ueValue = StaticValue v}
|
|
let es' = Left . unlink v <$> es
|
|
return (v, e0' : es')
|
|
|
|
unlink :: Decimal -> UELink -> UEBalanced
|
|
unlink v e = e {ueValue = StaticValue $ (-v) *. unLinkScale (ueValue e)}
|
|
|
|
rebalanceCredit
|
|
:: BCKey
|
|
-> Decimal
|
|
-> UEBlank
|
|
-> [UEUnk]
|
|
-> [UE_RO]
|
|
-> [UEBalanced]
|
|
-> State EntryBals [UEBalanced]
|
|
rebalanceCredit k tot t0@UpdateEntry {ueAcnt = t0Acnt} us rs bs = do
|
|
(tval, ts) <-
|
|
fmap (second catMaybes) $
|
|
sumM goTo $
|
|
L.sortOn idx $
|
|
(UETLinked <$> bs)
|
|
++ (UETUnk <$> us)
|
|
++ (UETReadOnly <$> rs)
|
|
let t0val = -(tot + tval)
|
|
modify $ mapAdd_ (t0Acnt, k) t0val
|
|
return (t0 {ueValue = StaticValue t0val} : ts)
|
|
where
|
|
idx = projectUET ueIndex ueIndex ueIndex
|
|
goTo (UETReadOnly e) = (,Nothing) <$> updateFixed k e
|
|
goTo (UETLinked e) = (,Just e) <$> updateFixed k e
|
|
goTo (UETUnk e) = do
|
|
v <- updateUnknown k e
|
|
return (v, Just $ e {ueValue = StaticValue v})
|
|
|
|
data UpdateEntryType a b
|
|
= UETReadOnly UE_RO
|
|
| UETUnk a
|
|
| UETLinked b
|
|
|
|
projectUET :: (UE_RO -> c) -> (a -> c) -> (b -> c) -> UpdateEntryType a b -> c
|
|
projectUET f _ _ (UETReadOnly e) = f e
|
|
projectUET _ f _ (UETUnk e) = f e
|
|
projectUET _ _ f (UETLinked p) = f p
|
|
|
|
updateFixed :: BCKey -> UpdateEntry i StaticValue -> State EntryBals Decimal
|
|
updateFixed k e = do
|
|
let v = unStaticValue $ ueValue e
|
|
modify $ mapAdd_ (ueAcnt e, k) v
|
|
return v
|
|
|
|
updateUnknown :: BCKey -> UpdateEntry i EntryValueUnk -> State EntryBals Decimal
|
|
updateUnknown k e = do
|
|
let key = (ueAcnt e, k)
|
|
curBal <- gets (M.findWithDefault 0 key)
|
|
let v = case ueValue e of
|
|
EVPercent p -> curBal *. p
|
|
EVBalance p -> p - curBal
|
|
modify $ mapAdd_ key v
|
|
return v
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- balancing
|
|
|
|
balancePrimaryEntrySet
|
|
:: (MonadAppError m, MonadFinance m)
|
|
=> PrimaryEntrySet
|
|
-> StateT EntryBals m InsertEntrySet
|
|
balancePrimaryEntrySet
|
|
EntrySet
|
|
{ esFrom = HalfEntrySet {hesPrimary = f0, hesOther = fs}
|
|
, esTo = HalfEntrySet {hesPrimary = t0, hesOther = ts}
|
|
, esCurrency
|
|
, esTotalValue
|
|
} =
|
|
do
|
|
let f0res = resolveAcntAndTags f0
|
|
let t0res = resolveAcntAndTags t0
|
|
let fsres = mapErrors resolveAcntAndTags fs
|
|
let tsres = mapErrors resolveAcntAndTags ts
|
|
let bc = esCurrency
|
|
combineErrorM (combineError f0res fsres (,)) (combineError t0res tsres (,)) $
|
|
\(f0', fs') (t0', ts') -> do
|
|
let balFrom = fmap liftInnerS . balanceDeferred
|
|
fs'' <- balanceTotalEntrySet balFrom bc esTotalValue f0' fs'
|
|
balanceFinal bc (-esTotalValue) fs'' t0' ts'
|
|
|
|
balanceSecondaryEntrySet
|
|
:: (MonadAppError m, MonadFinance m)
|
|
=> SecondayEntrySet
|
|
-> StateT EntryBals m InsertEntrySet
|
|
balanceSecondaryEntrySet
|
|
EntrySet
|
|
{ esFrom = HalfEntrySet {hesPrimary = f0, hesOther = fs}
|
|
, esTo = HalfEntrySet {hesPrimary = t0, hesOther = ts}
|
|
, esCurrency
|
|
} =
|
|
do
|
|
let fsRes = mapErrors resolveAcntAndTags (f0 :| fs)
|
|
let t0Res = resolveAcntAndTags t0
|
|
let tsRes = mapErrors resolveAcntAndTags ts
|
|
combineErrorM fsRes (combineError t0Res tsRes (,)) $ \fs' (t0', ts') -> do
|
|
fs'' <- mapErrors balFrom fs'
|
|
let tot = entrySum (NE.toList fs'')
|
|
balanceFinal bc (-tot) fs'' t0' ts'
|
|
where
|
|
entrySum = sum . fmap (eValue . ieEntry)
|
|
balFrom = balanceEntry (fmap liftInnerS . balanceDeferred) bc
|
|
bc = esCurrency
|
|
|
|
balanceFinal
|
|
:: (MonadAppError m)
|
|
=> BCKey
|
|
-> Decimal
|
|
-> NonEmpty InsertEntry
|
|
-> Entry AccountRId () TagRId
|
|
-> [Entry AccountRId EntryLink TagRId]
|
|
-> StateT EntryBals m InsertEntrySet
|
|
balanceFinal curID tot fs t0 ts = do
|
|
let fv = V.fromList $ NE.toList $ fmap (eValue . ieEntry) fs
|
|
let balTo = balanceLinked fv
|
|
ts' <- balanceTotalEntrySet balTo curID tot t0 ts
|
|
return $
|
|
InsertEntrySet
|
|
{ iesCurrency = curID
|
|
, iesFromEntries = fs
|
|
, iesToEntries = ts'
|
|
}
|
|
|
|
balanceTotalEntrySet
|
|
:: (MonadAppError m)
|
|
=> (ABCKey -> v -> StateT EntryBals m (Decimal, Maybe CachedEntry))
|
|
-> BCKey
|
|
-> Decimal
|
|
-> Entry AccountRId () TagRId
|
|
-> [Entry AccountRId v TagRId]
|
|
-> StateT EntryBals m (NonEmpty InsertEntry)
|
|
balanceTotalEntrySet f k tot e@Entry {eAcnt = acntID} es = do
|
|
es' <- mapErrors (balanceEntry f k) es
|
|
let e0val = tot - entrySum es'
|
|
-- TODO not dry
|
|
modify (mapAdd_ (acntID, k) e0val)
|
|
let e' =
|
|
InsertEntry
|
|
{ ieEntry = e {eValue = e0val, eAcnt = acntID}
|
|
, ieCached = Nothing
|
|
}
|
|
return $ e' :| es'
|
|
where
|
|
entrySum = sum . fmap (eValue . ieEntry)
|
|
|
|
liftInnerS :: Monad m => StateT e Identity a -> StateT e m a
|
|
liftInnerS = mapStateT (return . runIdentity)
|
|
|
|
balanceLinked
|
|
:: MonadAppError m
|
|
=> Vector Decimal
|
|
-> ABCKey
|
|
-> EntryLink
|
|
-> StateT EntryBals m (Decimal, Maybe CachedEntry)
|
|
balanceLinked from k lg = case lg of
|
|
(LinkIndex LinkedNumGetter {lngIndex, lngScale}) -> do
|
|
let i = fromIntegral lngIndex
|
|
upper = EntryIndex $ V.length from
|
|
res = fmap (go lngScale) $ from V.!? i
|
|
case res of
|
|
Just v -> return (v, Just $ CachedLink (EntryIndex $ fromIntegral lngIndex) (LinkScale lngScale))
|
|
Nothing -> throwAppError $ LinkError (EntryIndex i) upper
|
|
(LinkValue d) -> liftInnerS $ balanceDeferred k d
|
|
where
|
|
go s = negate . (*. s)
|
|
|
|
balanceDeferred :: ABCKey -> EntryValue -> State EntryBals (Decimal, Maybe CachedEntry)
|
|
balanceDeferred k e = do
|
|
newval <- findBalance k e
|
|
let d = case e of
|
|
EntryFixed _ -> Nothing
|
|
EntryBalance v -> Just $ CachedBalance v
|
|
EntryPercent v -> Just $ CachedPercent v
|
|
return (newval, d)
|
|
|
|
balanceEntry
|
|
:: (MonadAppError m)
|
|
=> (ABCKey -> v -> StateT EntryBals m (Decimal, Maybe CachedEntry))
|
|
-> BCKey
|
|
-> Entry AccountRId v TagRId
|
|
-> StateT EntryBals m InsertEntry
|
|
balanceEntry f k e@Entry {eValue, eAcnt = acntID} = do
|
|
(newVal, cached) <- f (acntID, k) eValue
|
|
modify (mapAdd_ (acntID, k) newVal)
|
|
return $
|
|
InsertEntry
|
|
{ ieEntry = e {eValue = newVal, eAcnt = acntID}
|
|
, ieCached = cached
|
|
}
|
|
|
|
resolveAcntAndTags
|
|
:: (MonadAppError m, MonadFinance m)
|
|
=> Entry AcntID v TagID
|
|
-> m (Entry AccountRId v TagRId)
|
|
resolveAcntAndTags e@Entry {eAcnt, eTags} = do
|
|
let acntRes = lookupAccountKey eAcnt
|
|
let tagRes = mapErrors lookupTag eTags
|
|
combineError acntRes tagRes $ \a ts -> e {eAcnt = a, eTags = ts}
|
|
|
|
findBalance :: ABCKey -> EntryValue -> State EntryBals Decimal
|
|
findBalance k e = do
|
|
curBal <- gets (M.findWithDefault 0 k)
|
|
return $ case e of
|
|
EntryBalance b -> b - curBal
|
|
EntryPercent p -> curBal *. p
|
|
EntryFixed v -> v
|
|
|
|
--------------------------------------------------------------------------------
|
|
-- transfers
|
|
|
|
expandTransfers
|
|
:: (MonadAppError m, MonadFinance m)
|
|
=> CommitR
|
|
-> DaySpan
|
|
-> [PairedTransfer]
|
|
-> m [Tx CommitR]
|
|
expandTransfers tc bounds = fmap concat . mapErrors (expandTransfer tc bounds)
|
|
|
|
expandTransfer
|
|
:: (MonadAppError m, MonadFinance m)
|
|
=> CommitR
|
|
-> DaySpan
|
|
-> PairedTransfer
|
|
-> m [Tx CommitR]
|
|
expandTransfer tc bounds Transfer {transAmounts, transTo, transCurrency, transFrom} = do
|
|
txs <- mapErrors go transAmounts
|
|
return $ concat txs
|
|
where
|
|
go
|
|
Amount
|
|
{ amtWhen = pat
|
|
, amtValue = TransferValue {tvVal = v, tvType = t}
|
|
, amtDesc = desc
|
|
, amtPriority = pri
|
|
} = do
|
|
cp <- lookupCurrency transCurrency
|
|
let v' = (-v)
|
|
let dec = realFracToDecimalP (cpPrec cp) v'
|
|
let v'' = case t of
|
|
TFixed -> EntryFixed dec
|
|
TPercent -> EntryPercent v'
|
|
TBalance -> EntryBalance dec
|
|
withDates bounds pat $ \day ->
|
|
return
|
|
Tx
|
|
{ txMeta = TxMeta day (fromIntegral pri) (TxDesc desc) tc
|
|
, txPrimary = Right $ entryPair transFrom transTo (cpID cp) desc () v''
|
|
, txOther = []
|
|
}
|
|
|
|
entryPair
|
|
:: TaggedAcnt
|
|
-> TaggedAcnt
|
|
-> CurrencyRId
|
|
-> T.Text
|
|
-> v0
|
|
-> v1
|
|
-> EntrySet v0 v1 v2 v3
|
|
entryPair (TaggedAcnt fa fts) (TaggedAcnt ta tts) curid com totval val1 =
|
|
EntrySet
|
|
{ esCurrency = curid
|
|
, esTotalValue = totval
|
|
, esFrom = halfEntry (AcntID fa) (TagID <$> fts) val1
|
|
, esTo = halfEntry (AcntID ta) (TagID <$> tts) ()
|
|
}
|
|
where
|
|
halfEntry :: AcntID -> [TagID] -> v -> HalfEntrySet v v0
|
|
halfEntry a ts v =
|
|
HalfEntrySet
|
|
{ hesPrimary = Entry {eAcnt = a, eValue = v, eComment = com, eTags = ts}
|
|
, hesOther = []
|
|
}
|
|
|
|
withDates
|
|
:: (MonadFinance m, MonadAppError m)
|
|
=> DaySpan
|
|
-> DatePat
|
|
-> (Day -> m a)
|
|
-> m [a]
|
|
withDates bounds dp f = do
|
|
days <- liftExcept $ expandDatePat bounds dp
|
|
combineErrors $ fmap f days
|
|
|
|
sumM :: (Monad m, Num s) => (a -> m (s, b)) -> [a] -> m (s, [b])
|
|
sumM f = mapAccumM (\s -> fmap (first (+ s)) . f) 0
|
|
|
|
mapAccumM :: (Monad m) => (s -> a -> m (s, b)) -> s -> [a] -> m (s, [b])
|
|
mapAccumM f s = foldM (\(s', ys) -> fmap (second (: ys)) . f s') (s, [])
|
|
|
|
realFracToDecimalP :: (Integral i, RealFrac r) => Precision -> r -> DecimalRaw i
|
|
realFracToDecimalP p = realFracToDecimal (unPrecision p)
|
|
|
|
roundToP :: Integral i => Precision -> DecimalRaw i -> DecimalRaw i
|
|
roundToP p = roundTo (unPrecision p)
|
|
|
|
compileRegex :: Bool -> T.Text -> AppExcept (Text, Regex)
|
|
compileRegex groups pat = case res of
|
|
Right re -> return (pat, re)
|
|
Left _ -> throwError $ AppException [RegexError pat]
|
|
where
|
|
res =
|
|
compile
|
|
(blankCompOpt {newSyntax = True})
|
|
(blankExecOpt {captureGroups = groups})
|
|
pat
|
|
|
|
matchMaybe :: T.Text -> Regex -> AppExcept Bool
|
|
matchMaybe q re = case execute re q of
|
|
Right res -> return $ isJust res
|
|
Left _ -> throwError $ AppException [RegexError "this should not happen"]
|
|
|
|
matchGroupsMaybe :: T.Text -> Regex -> [T.Text]
|
|
matchGroupsMaybe q re = case regexec re q of
|
|
Right Nothing -> []
|
|
Right (Just (_, _, _, xs)) -> xs
|
|
-- this should never fail as regexec always returns Right
|
|
Left _ -> []
|