aboutsummaryrefslogtreecommitdiff
path: root/src/client/elm/Update/LoggedIn/Account.elm
blob: 1773b9abbd05cc3c30ebc004270a9388e278151d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
module Update.LoggedIn.Account
  ( updateAccount
  ) where

import Maybe
import Dict
import Task

import Effects exposing (Effects)

import Server

import Model.Payer exposing (updatePayers)
import Model.Action.AccountAction exposing (..)
import Model.View.LoggedIn.Account exposing (..)

import Utils.Maybe exposing (isJust)

updateAccount : AccountAction -> Account -> (Account, Effects AccountAction)
updateAccount action account =
  case action of

    NoOp ->
      (account, Effects.none)

    ToggleDetail ->
      ( { account | visibleDetail = not account.visibleDetail }
      , Effects.none
      )

    UpdatePayer userId creation amountDiff ->
      ( { account | payers = updatePayers account.payers userId creation amountDiff }
      , Effects.none
      )

    ToggleIncomeEdition ->
      ( { account | incomeEdition =
          if isJust account.incomeEdition
            then Nothing
            else Just (initIncomeEdition (Maybe.withDefault 0 (getCurrentIncome account)))
      }
      , Effects.none
      )

    UpdateIncomeEdition income ->
      case account.incomeEdition of
        Just incomeEdition ->
          ( { account | incomeEdition = Just { incomeEdition | income = income } }
          , Effects.none
          )
        Nothing ->
          ( account
          , Effects.none
          )

    UpdateEditionError error ->
      case account.incomeEdition of
        Just incomeEdition ->
          ( { account | incomeEdition = Just { incomeEdition | error = Just error } }
          , Effects.none
          )
        Nothing ->
          ( account
          , Effects.none
          )

    UpdateIncome currentTime amount ->
      ( account
      , Server.setIncome currentTime amount
          |> Task.map (always (ValidateUpdateIncome currentTime amount))
          |> flip Task.onError (always <| Task.succeed NoOp)
          |> Effects.task
      )

    ValidateUpdateIncome currentTime amount ->
      ( { account
        | payers =
            account.payers
              |> Dict.update account.me (\mbPayer ->
                case mbPayer of
                  Just payer ->
                    Just
                      { payer
                      | incomes = payer.incomes ++ [{ creation = currentTime, amount = amount }]
                      }
                  Nothing ->
                    Nothing
              )
        , incomeEdition = Nothing
        }
      , Effects.none
      )