lib/Hcompta/Format/Ledger.hs

   1 {-# LANGUAGE DeriveDataTypeable #-}
   2 {-# LANGUAGE FlexibleInstances #-}
   3 {-# LANGUAGE MultiParamTypeClasses #-}
   4 {-# LANGUAGE NamedFieldPuns #-}
   5 {-# LANGUAGE OverloadedStrings #-}
   6 {-# LANGUAGE TupleSections #-}
   7 {-# LANGUAGE TypeFamilies #-}
   8 module Hcompta.Format.Ledger where
   9
  10 -- import           Control.Applicative (Const(..))
  11 import           Data.Data (Data(..))
  12 -- import qualified Data.Foldable as Data.Foldable
  13 import           Data.Functor.Compose (Compose(..))
  14 import qualified Data.List
  15 import           Data.Map.Strict (Map)
  16 import qualified Data.Map.Strict as Data.Map
  17 import           Data.Text (Text)
  18 import           Data.Typeable (Typeable)
  19 import           Text.Parsec.Pos (SourcePos, initialPos)
  20
  21 import           Hcompta.Account (Account)
  22 import           Hcompta.Amount (Amount)
  23 import qualified Hcompta.Amount as Amount
  24 -- import           Hcompta.Balance (Balance(..))
  25 import qualified Hcompta.Balance as Balance
  26 import           Hcompta.Date (Date)
  27 import qualified Hcompta.Date as Date
  28 import qualified Hcompta.Filter as Filter
  29 -- import           Hcompta.Lib.Consable
  30 import           Hcompta.Lib.Parsec ()
  31 -- import           Hcompta.GL (GL(..))
  32 import qualified Hcompta.GL as GL
  33 import qualified Hcompta.Journal as Journal
  34
  35 type Code = Text
  36 type Description = Text
  37 type Status = Bool
  38 type Comment = Text
  39
  40 -- * The 'Journal' type
  41
  42 data Monoid ts => Journal ts
  43  =  Journal
  44  { journal_file           :: FilePath
  45  , journal_includes       :: [Journal ts]
  46  , journal_last_read_time :: Date
  47  , journal_transactions   :: !ts
  48  , journal_unit_styles    :: Map Amount.Unit Amount.Style
  49  } deriving (Data, Eq, Show, Typeable)
  50
  51 journal :: Monoid ts => Journal ts
  52 journal =
  53         Journal
  54          { journal_file = mempty
  55          , journal_includes = mempty
  56          , journal_last_read_time = Date.nil
  57          , journal_transactions = mempty
  58          , journal_unit_styles = mempty
  59          }
  60
  61 -- * The 'Transaction' type
  62
  63 data Transaction
  64  =   Transaction
  65  { transaction_code                      :: Code
  66  , transaction_comments_before           :: [Comment]
  67  , transaction_comments_after            :: [Comment]
  68  , transaction_dates                     :: (Date, [Date])
  69  , transaction_description               :: Description
  70  , transaction_postings                  :: Posting_by_Account
  71  , transaction_virtual_postings          :: Posting_by_Account
  72  , transaction_balanced_virtual_postings :: Posting_by_Account
  73  , transaction_sourcepos                 :: SourcePos
  74  , transaction_status                    :: Status
  75  , transaction_tags                      :: Tag_by_Name
  76  } deriving (Data, Eq, Show, Typeable)
  77
  78 transaction :: Transaction
  79 transaction =
  80         Transaction
  81          { transaction_code = ""
  82          , transaction_comments_before = []
  83          , transaction_comments_after = []
  84          , transaction_dates = (Date.nil, [])
  85          , transaction_description = ""
  86          , transaction_postings = mempty
  87          , transaction_virtual_postings = mempty
  88          , transaction_balanced_virtual_postings = mempty
  89          , transaction_sourcepos = initialPos ""
  90          , transaction_status = False
  91          , transaction_tags = mempty
  92          }
  93
  94 instance Filter.Transaction Transaction where
  95         type Transaction_Posting  Transaction = Posting
  96         type Transaction_Postings Transaction = Compose [] (Compose (Map Account) [])
  97         transaction_date        = fst . transaction_dates
  98         transaction_description = transaction_description
  99         transaction_postings t  =
 100                 Compose
 101                  [ Compose $ transaction_postings t
 102                  , Compose $ transaction_virtual_postings t
 103                  , Compose $ transaction_balanced_virtual_postings t
 104                  ]
 105         transaction_tags        = transaction_tags
 106
 107 instance Journal.Transaction Transaction where
 108         transaction_date = fst . transaction_dates
 109
 110 instance GL.Transaction Transaction where
 111         type Transaction_Posting  Transaction = Posting
 112         type Transaction_Postings Transaction = Compose [] (Compose (Map Account) [])
 113         transaction_date = fst . transaction_dates
 114         transaction_postings t =
 115                 Compose
 116                  [ Compose $ transaction_postings t
 117                  , Compose $ transaction_virtual_postings t
 118                  , Compose $ transaction_balanced_virtual_postings t
 119                  ]
 120         transaction_postings_filter f t =
 121                 t{ transaction_postings =
 122                         Data.Map.mapMaybe
 123                          (\p -> case filter f p of
 124                                  [] -> Nothing
 125                                  ps -> Just ps)
 126                          (transaction_postings t)
 127                  , transaction_virtual_postings =
 128                         Data.Map.mapMaybe
 129                          (\p -> case filter f p of
 130                                  [] -> Nothing
 131                                  ps -> Just ps)
 132                          (transaction_virtual_postings t)
 133                  , transaction_balanced_virtual_postings =
 134                         Data.Map.mapMaybe
 135                          (\p -> case filter f p of
 136                                  [] -> Nothing
 137                                  ps -> Just ps)
 138                          (transaction_balanced_virtual_postings t)
 139                  }
 140
 141 -- | Return a 'Data.Map.Map' associating
 142 --   the given 'Transaction's with their respective 'Date'.
 143 transaction_by_Date :: [Transaction] -> (Compose (Map Date) []) Transaction
 144 transaction_by_Date =
 145         Compose .
 146         Data.Map.fromListWith (flip (++)) .
 147         Data.List.map (\t -> (fst $ transaction_dates t, [t]))
 148
 149 -- * The 'Posting' type
 150
 151 data Posting
 152  =   Posting
 153  { posting_account   :: Account
 154  , posting_amounts   :: Map Amount.Unit Amount
 155  , posting_comments  :: [Comment]
 156  , posting_dates     :: [Date]
 157  , posting_sourcepos :: SourcePos
 158  , posting_status    :: Bool
 159  , posting_tags      :: Tag_by_Name
 160  } deriving (Data, Eq, Show, Typeable)
 161
 162 data Posting_Type
 163  =   Posting_Type_Regular
 164  |   Posting_Type_Virtual
 165  |   Posting_Type_Virtual_Balanced
 166  deriving (Data, Eq, Read, Show, Typeable)
 167
 168 posting :: Account -> Posting
 169 posting acct =
 170         Posting
 171          { posting_account = acct
 172          , posting_amounts = Data.Map.empty
 173          , posting_comments = []
 174          , posting_dates = []
 175          , posting_status = False
 176          , posting_sourcepos = initialPos ""
 177          , posting_tags = Data.Map.empty
 178          }
 179
 180 instance
 181  Balance.Posting Posting where
 182         type Posting_Amount Posting = Amount.Sum Amount
 183         posting_account = posting_account
 184         posting_amounts = Data.Map.map Amount.sum . posting_amounts
 185         posting_set_amounts amounts p =
 186                 p { posting_amounts=Data.Map.map Amount.sum_balance amounts }
 187
 188 instance Filter.Posting Posting where
 189         type Posting_Amount Posting = Amount
 190         posting_account = posting_account
 191         posting_amounts = posting_amounts
 192
 193 instance GL.Posting Posting where
 194         type Posting_Amount Posting = Amount.Sum (Map Amount.Unit Amount)
 195         posting_account = posting_account
 196         posting_amount  = Amount.sum . posting_amounts
 197
 198 -- ** The 'Posting' mappings
 199
 200 type Posting_by_Account
 201  = Map Account [Posting]
 202
 203 type Posting_by_Amount_and_Account
 204  = Map Amount.By_Unit Posting_by_Account
 205
 206 type Posting_by_Signs_and_Account
 207  = Map Amount.Signs Posting_by_Account
 208
 209 -- | Return a Data.'Data.Map.Map' associating the given 'Posting's with their respective 'Account'.
 210 posting_by_Account :: [Posting] -> Posting_by_Account
 211 posting_by_Account =
 212         Data.Map.fromListWith (flip (++)) .
 213         Data.List.map
 214          (\p -> (posting_account p, [p]))
 215
 216 posting_by_Amount_and_Account :: Posting_by_Account -> Posting_by_Amount_and_Account
 217 posting_by_Amount_and_Account =
 218         Data.Map.foldlWithKey
 219          (flip (\acct ->
 220                 Data.List.foldl
 221                  (flip (\p ->
 222                         Data.Map.insertWith
 223                          (Data.Map.unionWith (++))
 224                          (posting_amounts p)
 225                          (Data.Map.singleton acct [p])))))
 226          Data.Map.empty
 227
 228 posting_by_Signs_and_Account :: Posting_by_Account -> Posting_by_Signs_and_Account
 229 posting_by_Signs_and_Account =
 230         Data.Map.foldlWithKey
 231          (flip (\acct ->
 232                 Data.List.foldl
 233                  (flip (\p ->
 234                         Data.Map.insertWith
 235                          (Data.Map.unionWith (++))
 236                          (Amount.signs $ posting_amounts p)
 237                          (Data.Map.singleton acct [p])))))
 238          Data.Map.empty
 239
 240 -- * The 'Tag' type
 241
 242 type Tag = (Tag_Name, Tag_Value)
 243 type Tag_Name = Text
 244 type Tag_Value = Text
 245
 246 type Tag_by_Name = Map Tag_Name [Tag_Value]
 247
 248 -- | Return a 'Data.Map.Map' associating the 'Value's of the given 'Tag's with their respective 'Name'.
 249 tag_by_Name :: [Tag] -> Tag_by_Name
 250 tag_by_Name =
 251         Data.Map.fromListWith (flip (++)) .
 252         Data.List.map (\(n, v) -> (n, [v]))