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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
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 LoggedIn.Home.Action as LoggedInAction
import LoggedIn.Home.Model as LoggedInModel
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 =
case action of
LoggedInAction.NoOp -> (loggedInModel, Effects.none)
LoggedInAction.UpdateAdd addPaymentAction ->
( { loggedInModel | add = AddPaymentUpdate.update addPaymentAction loggedInModel.add }
, Effects.none
)
LoggedInAction.UpdatePayments payments ->
( { loggedInModel | payments = payments }
, 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
)
LoggedInAction.ToggleEdit id ->
( { loggedInModel | paymentEdition = if loggedInModel.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
)
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 }
, Effects.none
)
LoggedInAction.UpdateMonthly monthlyAction ->
( { loggedInModel | monthly = MonthlyUpdate.update monthlyAction loggedInModel.monthly }
, Effects.none
)
LoggedInAction.UpdateAccount accountAction ->
let (newAccount, accountEffects) = AccountUpdate.update accountAction loggedInModel.account
in ( { loggedInModel | account = newAccount }
, Effects.map LoggedInAction.UpdateAccount accountEffects
)
|
