Added Entity Support + Minor Bugfixes / Updates

examples/entity_sample.transactions

@@ -0,0 +1,18 @@
+2013-01-01 I began the year with $1000 in my cheque account.
+  Assets:Bankwest:Cheque      $1,000
+  Equity:OpeningBalances      $1,000
+
+2013-01-05 I bought some groceries and paid using the cheque account.
+  Jacob/Expenses:Food:Groceries    $98.53
+  Jacob/Assets:Bankwest:Cheque    -$98.53
+
+2013-01-10 I bought some petrol, and paid using a credit card.
+  John/Expenses:Motor:Fuel    $58.01
+  John/Liabilities:Bankwest:Visa   $58.01 
+
+2013-01-15 I paid my electricity bill.
+  Expenses:Electricity    $280.42
+  Assets:Bankwest:Cheque  -$280.42
+
+# I checked my bank statement on the 1st of Feb, and this is what it said.
+VERIFY-BALANCE 2013-02-01 Assets:Bankwest:Cheque 719.58

examples/unbalanced_entity_sample.transactions

@@ -0,0 +1,18 @@
+2013-01-01 I began the year with $1000 in my cheque account.
+  John/Assets:Bankwest:Cheque      $1,000
+  John/Equity:OpeningBalances      $1,000
+
+2013-01-05 I bought some groceries and paid using the cheque account.
+  Jacob/Expenses:Food:Groceries    $98.53
+  John/Assets:Bankwest:Cheque    -$98.53
+
+2013-01-10 I bought some petrol, and paid using a credit card.
+  Jacob/Expenses:Motor:Fuel    $58.01
+  Liabilities:Bankwest:Visa   $58.01 
+
+2013-01-15 I paid my electricity bill.
+  Expenses:Electricity    $280.42
+  Assets:Bankwest:Cheque  -$280.42
+
+# I checked my bank statement on the 1st of Feb, and this is what it said.
+VERIFY-BALANCE 2013-02-01 Assets:Bankwest:Cheque 621.05

src/fsharp/Ledger/Calculations.fs

@@ -31,6 +31,10 @@ type DateOrderCheck =
     | OK
     | Problem of previous: Transaction * next: Transaction
 
+type EntityVerification =
+    | EntityVerificationPassed
+    | UnbalancedEntities of AccountEntity list
+
 /// Check transactions are in date order. Give two problem transactions if not.
 let checkDateOrder (transactions : Transaction list) =
     let rec helper (previous : Transaction) (transactions : Transaction list) =
@@ -45,6 +49,51 @@ let checkDateOrder (transactions : Transaction list) =
         | [] -> DateOrderCheck.OK
         | (t :: tail) -> (helper t tail)
 
+/// This function will check a list of postings for an uneven number of the entities seen within
+/// for example:
+///
+/// Jacob/Expenses:Motor:Fuel   $58.01
+/// Liabilities:Bankwest:Visa   $58.01
+///
+/// Will result in the following function result:
+/// UnbalancedEntities [(Entity Jacob,true); (Default,true)]
+///
+/// Assuming that they do balanced, like so:
+/// Expenses:Motor:Fuel   $58.01
+/// Liabilities:Bankwest:Visa   $58.01
+///
+/// then the function will return EntityVerificationPassed. Perhaps there is a better way to check for the #
+/// such as keeping a running total and "modding" (%) by 2 to see if there is an even number of entities
+/// I'm keeping it like this because I think the concept of flipping "bits" is neat, although overcomplicated
+let verifyEntitiesInPostings (postings:Posting list) =
+    let errors = postings
+                 |> List.fold (fun (bins:(AccountEntity*bool) list) (elem:Posting) -> 
+                         let entity = elem.account.Entity
+                         let bin = bins |> List.tryFind (fst >> (=) entity)
+                         match bin with
+                         | Some b -> bins |> List.map (fun (entity,b) -> (entity,not b))
+                         | None -> (entity, true) :: bins) []
+                 |> List.filter (snd >> (=) true)
+                 |> List.map (fun (entity,b) -> entity)
+    match errors with
+    | [] -> EntityVerificationPassed
+    | _ -> UnbalancedEntities errors
+
+/// Performs verifyEntitiesInPostings of each transaction's postings in the supplied list
+/// It will then map the results into a tuple of (Transaction*EntityVerification List)
+/// This allows us to refer to the offending transaction in errors, as well as checking each
+/// transaction individually rather than checking the ENTIRE file for unbalanced entities
+/// this allows for a faster tracking of entity issues
+let verifyEntitiesInTransactions (transactions:Transaction list) =
+    transactions
+    |> List.map (fun transaction -> 
+                      (transaction, match verifyEntitiesInPostings transaction.postings with 
+                                    | EntityVerificationPassed -> []
+                                    | UnbalancedEntities entities -> entities))
+    |> List.filter (snd >> (<>) [])
+    // F# never ceases to amaze. This bit basically says "filter all items where the second item in a tuple is not an empty list". 
+    // the equivalent is (fun x -> snd x <> []) would achieve the same result 
+
 /// Is transaction unbalanced?
 let balance (t:Transaction) =
     let signedAmount (p: Posting) =
@@ -66,7 +115,7 @@ let filter (transactions : Transaction list) (first : Date option) (last : Date
 
 // Is a a sub-account of b?
 let isSubAccountOf (a: InputNameAccount) (b: InputNameAccount) =
-    startsWith (canonicalAccountName a) (canonicalAccountName b)
+    startsWith (canonicalAccountName a) (canonicalAccountName b) && a.Entity=b.Entity
 
 /// XXX: affectedBy(Posting/Transaction) should be a method on AccountName, which should be a class. Do we even need these at all?
 let postingAffects (p:Posting) (a: InputNameAccount) =

src/fsharp/Ledger/ExcelOutput.fs

@@ -4,6 +4,7 @@ open InputTypes
 open TextOutput
 open InternalTypes
 open OfficeOpenXml
+open Misc
 
 type Destination = ExcelPackage option
 
@@ -403,10 +404,7 @@ type Excel =
                 for c in (txnNumCol-1)..(txnNumCol+2) do
                     worksheet.Column(c).AutoFit(0.0)
 
-    static member writeLine((line: ReportBalances.Line),
-                            (ws : ExcelWorksheet),
-                            (indent: int),
-                            (nextRow: int)) =
+    static member writeLine((line: ReportBalances.Line),  (ws : ExcelWorksheet), (indent: int), (nextRow: int)) =
       (Excel.setValue (ws.Cells.[nextRow, 1], line.Balance))
       Excel.setValue (ws.Cells.[nextRow, 2+indent], line.Account.AsString)
       if indent <> 0 then
@@ -416,10 +414,7 @@ type Excel =
         ws.Row(nextRow).Collapsed <- true
       rowAfterChildren
 
-    static member writeLines((lines : ReportBalances.Line list),
-                             (ws : ExcelWorksheet),
-                             (indent: int),
-                             (nextRow: int)) =
+    static member writeLines((lines : ReportBalances.Line list), (ws : ExcelWorksheet),  (indent: int), (nextRow: int)) =
         match lines with
             | [] -> nextRow
             | first::rest -> Excel.writeLines(rest, ws, indent, Excel.writeLine(first, ws, indent, nextRow))
@@ -431,91 +426,86 @@ type Excel =
             let worksheet = package.Workbook.Worksheets.Add("Balances")
             (setHeader worksheet.Cells.[1, 1] "Balance")
             (setHeader worksheet.Cells.[1, 2] "Account")
-            Excel.writeLines(report.lines, worksheet, 0, 2) |> ignore
+            Excel.writeLines(report.Lines, worksheet, 0, 2) |> ignore
             worksheet.View.FreezePanes(2, 1)
             worksheet.OutLineSummaryBelow <- false
 
-    static member writeLine((line: ReportChartOfAccounts.Line),
-                            (ws : ExcelWorksheet),
-                            (indent: int),
-                            (nextRow: int)) =
-      Excel.setValue (ws.Cells.[nextRow, 1+indent], line.Account.AsString)
-      if indent <> 0 then
+    static member writeLine((line: ReportChartOfAccounts.Line), (ws : ExcelWorksheet), (indent: int), (nextRow: int)) =
+      Excel.setValue (ws.Cells.[nextRow, 1+indent], line.Account.Name)
+      if indent <> 1 then
         ws.Row(nextRow).OutlineLevel <- (indent)
       // Deliberately avoid collapsing hierarchy. If we're looking, we probably want to
       // emphasise details, and it's easy to manually hide them if that's what is wanted.
       Excel.writeLines (line.SubAccounts, ws, indent+1, nextRow+1)
 
-    static member writeLines((lines : ReportChartOfAccounts.Line list),
-                             (ws : ExcelWorksheet),
-                             (indent: int),
-                             (nextRow: int)) =
-        match lines with
-            | [] -> nextRow
-            | first::rest -> Excel.writeLines(rest, ws, indent, Excel.writeLine(first, ws, indent, nextRow))
+    static member writeLines((lines : ReportChartOfAccounts.Line list), (ws : ExcelWorksheet), (indent: int), (nextRow: int)) =
+      match lines with
+      | [] -> nextRow
+      | first::rest -> Excel.writeLines(rest, ws, indent, Excel.writeLine(first, ws, indent, nextRow))
 
     static member write((report : ReportChartOfAccounts.Report), (destination : Destination)) =
-        match destination with
-            | None -> ()
-            | Some package ->
-                let worksheet = package.Workbook.Worksheets.Add("Chart Of Accounts")
-                (setHeader worksheet.Cells.[1, 1] "Account")
-                Excel.writeLines(report.Lines, worksheet, 0, 2) |> ignore
-                worksheet.View.FreezePanes(2, 1)
-                worksheet.OutLineSummaryBelow <- false
-
-    static member writeLine((line: ReportTransactionList.Line),
-                            (ws : ExcelWorksheet),
-                            (nextRow: int)) =
-
+      match destination with
+      | None -> ()
+      | Some package ->
+          let worksheet = package.Workbook.Worksheets.Add("Chart Of Accounts")
+          (setHeader worksheet.Cells.[1, 1] "Account")
+          report.Lines 
+          |> List.map (fun line -> (line.Account.Entity, line)) 
+          |> List.collapse
+          |> List.fold (fun nextRow (entity,accounts) -> 
+                            Excel.setValue(worksheet.Cells.[nextRow,1], entity.AsString)
+                            Excel.writeLines(accounts, worksheet, 1, nextRow+1)) 2
+          |> ignore
+          worksheet.View.FreezePanes(2, 1)
+          worksheet.OutLineSummaryBelow <- false
+
+    static member writeLine((line: ReportTransactionList.Line), (ws : ExcelWorksheet), (nextRow: int)) =
       let txnCell = ws.Cells.[nextRow, 1]
       let dateCell = ws.Cells.[nextRow, 2]
       let descCell = ws.Cells.[nextRow, 3]
-
+      
       Excel.setValue (txnCell, (sprintf "txn:%d" line.transaction.id))
       txnCell.Style.Border.Top.Style <- OfficeOpenXml.Style.ExcelBorderStyle.Thin
-
+      
       Excel.setValue (dateCell, line.transaction.date)
       dateCell.Style.Font.Bold <- true
       dateCell.Style.Border.Top.Style <- OfficeOpenXml.Style.ExcelBorderStyle.Thin
-
+      
       Excel.setValue (descCell, line.transaction.description)
       descCell.Style.Font.Bold <- true
       descCell.Style.Font.Italic <- true
       descCell.Style.Border.Top.Style <- OfficeOpenXml.Style.ExcelBorderStyle.Thin
-
+      
       line.transaction.postings
       |> List.fold (fun row p ->
                         Excel.setValue (ws.Cells.[row, 2], p.amount)
                         Excel.setValue (ws.Cells.[row, 3], p.account.AsString)
                         row+1) (nextRow+1)
 
 
-    static member writeLines((lines : ReportTransactionList.Line list),
-                             (ws : ExcelWorksheet),
-                             (nextRow: int)) =
-        match lines with
-            | [] -> nextRow
-            | first::rest -> Excel.writeLines(rest, ws, Excel.writeLine(first, ws, nextRow))
+    static member writeLines((lines : ReportTransactionList.Line list), (ws : ExcelWorksheet), (nextRow: int)) =
+      match lines with
+      | [] -> nextRow
+      | first::rest -> Excel.writeLines(rest, ws, Excel.writeLine(first, ws, nextRow))
 
     static member write((report : ReportTransactionList.Report), (destination : Destination)) =
-        match destination with
-            | None -> ()
-            | Some package ->
-                let worksheet = package.Workbook.Worksheets.Add("Transactions")
-
-                match report.first with
-                | Some date -> (setHeader worksheet.Cells.[1, 1] "From:")
-                               (setHeader worksheet.Cells.[1, 2] date)
-                | None -> ()
-                match report.last with
-                | Some date -> (setHeader worksheet.Cells.[2, 1] "To:")
-                               (setHeader worksheet.Cells.[2, 2] date)
-                | None -> ()
-                (setHeader worksheet.Cells.[3, 1] "Transaction#")
-                (setHeader worksheet.Cells.[3, 2] "Date/Amount")
-                (setHeader worksheet.Cells.[3, 3] "Description/Account")
-                worksheet.View.FreezePanes(4, 1)
-                Excel.writeLines(report.lines, worksheet, 4) |> ignore
-                for c in 1..3 do
-                    worksheet.Column(c).AutoFit(0.0)
+      match destination with
+      | None -> ()
+      | Some package ->
+          let worksheet = package.Workbook.Worksheets.Add("Transactions")
+
+          match report.first with
+          | Some date -> (setHeader worksheet.Cells.[1, 1] "From:")
+                         (setHeader worksheet.Cells.[1, 2] date)
+          | None -> ()
+          match report.last with
+          | Some date -> (setHeader worksheet.Cells.[2, 1] "To:")
+                         (setHeader worksheet.Cells.[2, 2] date)
+          | None -> ()
+          (setHeader worksheet.Cells.[3, 1] "Transaction#")
+          (setHeader worksheet.Cells.[3, 2] "Date/Amount")
+          (setHeader worksheet.Cells.[3, 3] "Description/Account")
+          worksheet.View.FreezePanes(4, 1)
+          Excel.writeLines(report.lines, worksheet, 4) |> ignore
+          for c in 1..3 do
+              worksheet.Column(c).AutoFit(0.0)

src/fsharp/Ledger/InputTypes.fs

@@ -9,13 +9,37 @@
 type Date = string
 type Description = string
 
-type InputNameAccount = InputName of string
+type AccountName = string
+
+type AccountEntity = 
+    | Default 
+    | Entity of string
+    with
+    member this.AsString =
+        match this with
+        | Default -> "Default"
+        | Entity e -> e
+
+type InputNameAccount = InputName of (AccountEntity * AccountName)
     with
         member this.AsString =
-            match this with (InputName x) -> x
+            match this with (InputName (entity,name)) -> entity.AsString + "/" + name 
+        member this.Name =
+            match this with (InputName (entity,name)) -> name
+        member this.Entity =
+            match this with (InputName (entity,name)) -> entity
 
 exception BadAccountNameException of name: InputNameAccount * problem: string
 
+exception EntityMismatch of acc1:InputNameAccount * acc2:InputNameAccount
+    with
+        member this.ToString =
+            "Entity Mismatch: " + this.acc1.Entity.AsString + " <> " + this.acc2.Entity.AsString + "\r\n" +
+            "Additional Information: " + this.acc1.AsString + " <> " + this.acc2.AsString + "\r\n" +
+            "Stacktrace: " + this.StackTrace
+
+exception BadEntityNameException of name:InputNameAccount * problem: string
+
 type Amount =
     /// AUD amounts are stored as cents, and converted to dollars on input/output.
     | AUD of int