From 869bab77e93e2a6c776a4b1fc35ef0fd5df22f5f Mon Sep 17 00:00:00 2001
From: Joris
Date: Sun, 27 Mar 2016 17:36:33 +0200
Subject: Compute payers client side rather than server side

---
 src/client/elm/Model/Payer.elm | 78 ++++++++++++++++++------------------------
 1 file changed, 34 insertions(+), 44 deletions(-)

(limited to 'src/client/elm/Model/Payer.elm')

diff --git a/src/client/elm/Model/Payer.elm b/src/client/elm/Model/Payer.elm
index f39a612..9ae1dfa 100644
--- a/src/client/elm/Model/Payer.elm
+++ b/src/client/elm/Model/Payer.elm
@@ -2,8 +2,6 @@ module Model.Payer
   ( Payers
   , Payer
   , ExceedingPayer
-  , payersDecoder
-  , updatePayers
   , getOrderedExceedingPayers
   ) where
 
@@ -12,8 +10,10 @@ import Dict exposing (..)
 import List
 import Maybe
 import Time exposing (Time)
+import Date
 
-import Model.User exposing (UserId, userIdDecoder)
+import Model.Payment exposing (Payments, totalPayments)
+import Model.User exposing (Users, UserId, userIdDecoder)
 import Model.Income exposing (..)
 
 import Utils.Dict exposing (mapValues)
@@ -27,54 +27,22 @@ type alias Payer =
   , incomes : List Income
   }
 
-payersDecoder : Decoder Payers
-payersDecoder = Json.map Dict.fromList (list payerDecoder)
-
-payerDecoder : Decoder (UserId, Payer)
-payerDecoder =
-  object2 (,)
-    ("userId" := userIdDecoder)
-    (object3 Payer
-      ("preIncomePaymentSum" := int)
-      ("postIncomePaymentSum" := int)
-      ("incomes" := list incomeDecoder))
-
-updatePayers : Payers -> UserId -> Time -> Int -> Payers
-updatePayers payers userId creation amountDiff =
-  payers
-    |> Dict.update userId (\mbPayer ->
-       case mbPayer of
-         Just payer ->
-           let postIncome =
-                payersIncomeDefinedForAll payers
-                  |> Maybe.map (\date -> creation > date)
-                  |> Maybe.withDefault False
-           in  if postIncome
-                 then
-                   Just { payer | postIncomePaymentSum = payer.postIncomePaymentSum + amountDiff }
-                 else
-                   Just { payer | preIncomePaymentSum = payer.preIncomePaymentSum + amountDiff }
-         Nothing ->
-           Nothing
-    )
-
 type alias ExceedingPayer =
   { userId : UserId
   , amount : Int
   }
 
-getOrderedExceedingPayers : Time -> Payers -> List ExceedingPayer
-getOrderedExceedingPayers currentTime payers =
-  let exceedingPayersOnPreIncome =
+getOrderedExceedingPayers : Time -> Users -> Incomes -> Payments -> List ExceedingPayer
+getOrderedExceedingPayers currentTime users incomes payments =
+  let payers = getPayers currentTime users incomes payments
+      exceedingPayersOnPreIncome =
         payers
           |> mapValues .preIncomePaymentSum
           |> Dict.toList
           |> exceedingPayersFromAmounts
-  in  case payersIncomeDefinedForAll payers of
+  in  case incomeDefinedForAll (Dict.keys users) incomes of
         Just since ->
-          let postPaymentPayers =
-                payers
-                  |> mapValues (getPostPaymentPayer currentTime since)
+          let postPaymentPayers = mapValues (getPostPaymentPayer currentTime since) payers
               mbMaxRatio =
                 postPaymentPayers
                   |> Dict.toList
@@ -91,9 +59,31 @@ getOrderedExceedingPayers currentTime payers =
         Nothing ->
           exceedingPayersOnPreIncome
 
-payersIncomeDefinedForAll : Payers -> Maybe Time
-payersIncomeDefinedForAll payers =
-  incomeDefinedForAll (List.map (.incomes << snd) << Dict.toList <| payers)
+getPayers : Time -> Users -> Incomes -> Payments -> Payers
+getPayers currentTime users incomes payments =
+  let incomesDefined = incomeDefinedForAll (Dict.keys users) incomes
+  in  Dict.keys users
+        |> List.map (\userId ->
+             ( userId
+             , { preIncomePaymentSum =
+                   totalPayments
+                     (\p -> (Date.toTime p.creation) < (Maybe.withDefault currentTime incomesDefined))
+                     userId
+                     payments
+               , postIncomePaymentSum =
+                   totalPayments
+                     (\p ->
+                       case incomesDefined of
+                         Nothing -> False
+                         Just t -> (Date.toTime p.creation) >= t
+                     )
+                     userId
+                     payments
+               , incomes = List.filter ((==) userId << .userId) (Dict.values incomes)
+               }
+             )
+           )
+        |> Dict.fromList
 
 exceedingPayersFromAmounts : List (UserId, Int) -> List ExceedingPayer
 exceedingPayersFromAmounts userAmounts =
-- 
cgit v1.2.3