1 files changed, 98 insertions, 9 deletions

diff --git a/src/client/elm/LoggedIn/Update.elm b/src/client/elm/LoggedIn/Update.elm
index 189d901..8fe8d4c 100644
--- a/src/client/elm/LoggedIn/Update.elm
+++ b/src/client/elm/LoggedIn/Update.elm
@@ -2,9 +2,20 @@ module LoggedIn.Update
   ( update
   ) where
 
+import Dict
+import String
+import Task
+
 import Effects exposing (Effects)
+import Http exposing (Error(..))
+import Date
 
 import Model exposing (Model)
+import Model.Translations exposing (getMessage)
+import Model.Payment exposing (Payment, PaymentFrequency(..), deletePayment)
+
+import Server
+import LoggedData
 
 import LoggedIn.Action as LoggedInAction
 import LoggedIn.Model as LoggedInModel
@@ -12,18 +23,96 @@ import LoggedIn.Model as LoggedInModel
 import LoggedIn.Home.Action as HomeAction
 import LoggedIn.Home.Update as HomeUpdate
 
-type Action = HomeAction HomeAction.Action
+import LoggedIn.Home.Account.Action as AccountAction
+
+import LoggedIn.Home.AddPayment.Action as AddPaymentAction
+import LoggedIn.Home.AddPayment.Update as AddPaymentUpdate
+
+import Utils.Tuple as Tuple
+import Utils.Effects as Effects
 
 update : Model -> LoggedInAction.Action -> LoggedInModel.Model -> (LoggedInModel.Model, Effects LoggedInAction.Action)
 update model action loggedIn =
-  case action of
+  let loggedData = LoggedData.build model loggedIn
+  in  case action of
+
+        LoggedInAction.NoOp ->
+          (loggedIn, Effects.none)
+
+        LoggedInAction.HomeAction homeAction ->
+          case HomeUpdate.update loggedData homeAction loggedIn.home of
+            (home, effects) ->
+              ( { loggedIn | home = home }
+              , Effects.map LoggedInAction.HomeAction effects
+              )
+
+        LoggedInAction.AddPayment name cost frequency ->
+          update model (LoggedInAction.HomeAction <| HomeAction.UpdateAdd <| AddPaymentAction.WaitingServer) loggedIn
+            |> Tuple.mapSnd (\effect ->
+                 Server.addPayment name cost frequency
+                   |> Task.map (\paymentId ->
+                        case String.toInt cost of
+                          Err _ ->
+                            LoggedInAction.HomeAction <| HomeAction.UpdateAdd (AddPaymentAction.AddError Nothing (Just (getMessage "CostRequired" loggedData.translations)))
+                          Ok costNumber ->
+                            LoggedInAction.ValidateAddPayment paymentId name costNumber frequency
+                      )
+                   |> flip Task.onError (\err ->
+                       case err of
+                         BadResponse 400 jsonErr ->
+                           case AddPaymentUpdate.addPaymentError model.translations jsonErr of
+                             Just addPaymentAction -> Task.succeed (LoggedInAction.HomeAction <| HomeAction.UpdateAdd addPaymentAction)
+                             Nothing -> Task.succeed LoggedInAction.NoOp
+                         _ ->
+                           Task.succeed LoggedInAction.NoOp
+                      )
+                   |> Effects.task
+                   |> \effect2 -> [effect, effect2]
+                   |> Effects.batch
+               )
 
-    LoggedInAction.NoOp ->
-      (loggedIn, Effects.none)
+        LoggedInAction.ValidateAddPayment paymentId name cost frequency ->
+          update model (LoggedInAction.HomeAction <| HomeAction.UpdateAdd <| AddPaymentAction.Init frequency) loggedIn
+            |> flip Effects.andThen (\loggedIn ->
+                 let newPayment = Payment paymentId (Date.fromTime model.currentTime) name cost loggedIn.me
+                 in  case frequency of
+                       Punctual ->
+                         update model (LoggedInAction.HomeAction <| HomeAction.UpdatePage 1) loggedIn
+                           |> Tuple.mapFst (\loggedIn -> { loggedIn | payments = newPayment :: loggedIn.payments })
+                       Monthly ->
+                         update model (LoggedInAction.HomeAction <| HomeAction.ShowMonthlyDetail) loggedIn
+                           |> Tuple.mapFst (\loggedIn -> { loggedIn | monthlyPayments = newPayment :: loggedIn.monthlyPayments })
+               )
 
-    LoggedInAction.HomeAction homeAction ->
-      case HomeUpdate.update model homeAction loggedIn.home of
-        (home, effects) ->
-          ( { loggedIn | home = home }
-          , Effects.map LoggedInAction.HomeAction effects
+        LoggedInAction.DeletePayment payment frequency ->
+          ( loggedIn
+          , Server.deletePayment payment frequency
+              |> Task.map (always (LoggedInAction.ValidateDeletePayment payment frequency))
+              |> flip Task.onError (always <| Task.succeed LoggedInAction.NoOp)
+              |> Effects.task
           )
+
+        LoggedInAction.ValidateDeletePayment payment frequency ->
+          ( case frequency of
+              Monthly ->
+                { loggedIn | monthlyPayments = deletePayment payment.id loggedIn.monthlyPayments }
+              Punctual ->
+                { loggedIn | payments = deletePayment payment.id loggedIn.payments }
+          , Effects.none
+          )
+
+
+        LoggedInAction.UpdateIncome amount ->
+          ( loggedIn
+          , Server.setIncome amount
+              |> Task.map (\incomeId -> (LoggedInAction.ValidateUpdateIncome incomeId amount))
+              |> flip Task.onError (always <| Task.succeed LoggedInAction.NoOp)
+              |> Effects.task
+          )
+
+        LoggedInAction.ValidateUpdateIncome incomeId amount ->
+          update model (LoggedInAction.HomeAction <| HomeAction.UpdateAccount <| AccountAction.ToggleIncomeEdition) loggedIn
+            |> Tuple.mapFst (\loggedIn ->
+                 let newIncome = { userId = loggedIn.me, creation = model.currentTime, amount = amount }
+                 in  { loggedIn | incomes = Dict.insert incomeId newIncome loggedIn.incomes }
+               )