1 files changed, 22 insertions, 107 deletions

diff --git a/src/client/elm/LoggedIn/Home/Update.elm b/src/client/elm/LoggedIn/Home/Update.elm
index ee0a7c3..b43ebb7 100644
--- a/src/client/elm/LoggedIn/Home/Update.elm
+++ b/src/client/elm/LoggedIn/Home/Update.elm
@@ -2,136 +2,51 @@ module LoggedIn.Home.Update
   ( update
   ) where
 
-import Date
-import Dict
-import Debug
-import Task
-import String
-
 import Effects exposing (Effects)
-import Http exposing (Error(..))
 
-import Server
+import LoggedData exposing (LoggedData)
 
-import LoggedIn.Home.Action as LoggedInAction
-import LoggedIn.Home.Model as LoggedInModel
+import LoggedIn.Home.Action as HomeAction
+import LoggedIn.Home.Model as HomeModel
 
 import LoggedIn.Home.Account.Action as AccountAction
 import LoggedIn.Home.Account.Update as AccountUpdate
 
-import LoggedIn.Home.AddPayment.Action as AddPaymentAction
-import LoggedIn.Home.AddPayment.Model as AddPaymentModel
 import LoggedIn.Home.AddPayment.Update as AddPaymentUpdate
 
-import LoggedIn.Home.Monthly.Action as MonthlyAction
-import LoggedIn.Home.Monthly.Model as MonthlyModel
-import LoggedIn.Home.Monthly.Update as MonthlyUpdate
-
-import Model exposing (Model)
-import Model.User exposing (UserId)
-import Model.Payment exposing (..)
-import Model.Translations exposing (Translations, getMessage)
-
-update : Model -> LoggedInAction.Action -> LoggedInModel.Model -> (LoggedInModel.Model, Effects LoggedInAction.Action)
-update model action loggedInModel =
+update : LoggedData -> HomeAction.Action -> HomeModel.Model -> (HomeModel.Model, Effects HomeAction.Action)
+update loggedData action homeModel =
   case action of
 
-    LoggedInAction.NoOp -> (loggedInModel, Effects.none)
-
-    LoggedInAction.UpdateAdd addPaymentAction ->
-      ( { loggedInModel | add = AddPaymentUpdate.update addPaymentAction loggedInModel.add }
-      , Effects.none
-      )
+    HomeAction.NoOp -> (homeModel, Effects.none)
 
-    LoggedInAction.UpdatePayments payments ->
-      ( { loggedInModel | payments = payments }
+    HomeAction.UpdateAdd addPaymentAction ->
+      ( { homeModel | add = AddPaymentUpdate.update addPaymentAction homeModel.add }
       , Effects.none
       )
 
-    LoggedInAction.AddPayment name cost frequency ->
-      ( { loggedInModel | add = AddPaymentUpdate.update AddPaymentAction.WaitingServer loggedInModel.add }
-      , Server.addPayment name cost frequency
-          |> Task.map (\paymentId ->
-               case String.toInt cost of
-                 Err _ ->
-                   LoggedInAction.UpdateAdd (AddPaymentAction.AddError Nothing (Just (getMessage "CostRequired" model.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.UpdateAdd addPaymentAction)
-                    Nothing -> Task.succeed LoggedInAction.NoOp
-                _ ->
-                  Task.succeed LoggedInAction.NoOp
-             )
-          |> Effects.task
-      )
-
-    LoggedInAction.ValidateAddPayment paymentId name cost frequency ->
-      let newPayment = Payment paymentId (Date.fromTime model.currentTime) name cost loggedInModel.account.me
-          newAdd = AddPaymentModel.init frequency
-      in  case frequency of
-            Punctual ->
-              ( { loggedInModel
-                | currentPage = 1
-                , add = newAdd
-                , account = loggedInModel.account
-                , payments = newPayment :: loggedInModel.payments
-                }
-              , Effects.none
-              )
-            Monthly ->
-              ( { loggedInModel
-                | add = newAdd
-                , monthly = MonthlyUpdate.update (MonthlyAction.AddPayment newPayment) loggedInModel.monthly
-                }
-              , Effects.none
-              )
+    HomeAction.UpdateAccount accountAction ->
+      let (newAccount, accountEffects) = AccountUpdate.update loggedData accountAction homeModel.account
+      in  ( { homeModel | account = newAccount }
+          , Effects.map HomeAction.UpdateAccount accountEffects
+          )
 
-    LoggedInAction.ToggleEdit id ->
-      ( { loggedInModel | paymentEdition = if loggedInModel.paymentEdition == Just id then Nothing else Just id }
+    HomeAction.ToggleEdit id ->
+      ( { homeModel | paymentEdition = if homeModel.paymentEdition == Just id then Nothing else Just id }
       , Effects.none
       )
 
-    LoggedInAction.DeletePayment payment frequency ->
-      ( loggedInModel
-      , Server.deletePayment payment frequency
-          |> Task.map (always (LoggedInAction.ValidateDeletePayment payment frequency))
-          |> flip Task.onError (always <| Task.succeed LoggedInAction.NoOp)
-          |> Effects.task
+    HomeAction.UpdatePage page ->
+      ( { homeModel | currentPage = page }
+      , Effects.none
       )
 
-    LoggedInAction.ValidateDeletePayment payment frequency ->
-      case frequency of
-        Monthly ->
-          ( { loggedInModel
-            | monthly = MonthlyUpdate.update (MonthlyAction.DeletePayment payment) loggedInModel.monthly
-            }
-          , Effects.none
-          )
-        Punctual ->
-          ( { loggedInModel
-            | account = loggedInModel.account
-            , payments = deletePayment payment.id loggedInModel.payments
-            }
-          , Effects.none
-          )
-
-    LoggedInAction.UpdatePage page ->
-      ( { loggedInModel | currentPage = page }
+    HomeAction.ShowMonthlyDetail ->
+      ( { homeModel | monthlyDetail = True }
       , Effects.none
       )
 
-    LoggedInAction.UpdateMonthly monthlyAction ->
-      ( { loggedInModel | monthly = MonthlyUpdate.update monthlyAction loggedInModel.monthly }
+    HomeAction.ToggleMonthlyDetail ->
+      ( { homeModel | monthlyDetail = not homeModel.monthlyDetail }
       , Effects.none
       )
-
-    LoggedInAction.UpdateAccount accountAction ->
-      let (newAccount, accountEffects) = AccountUpdate.update accountAction loggedInModel.account
-      in  ( { loggedInModel | account = newAccount }
-          , Effects.map LoggedInAction.UpdateAccount accountEffects
-          )