1 files changed, 40 insertions, 52 deletions

diff --git a/src/client/elm/Update.elm b/src/client/elm/Update.elm
index 5c89d0a..bcbfb6c 100644
--- a/src/client/elm/Update.elm
+++ b/src/client/elm/Update.elm
@@ -1,105 +1,93 @@
-module Update
-  ( routerConfig
-  , update
-  ) where
+module Update exposing
+  ( update
+  , urlUpdate
+  )
 
 import Task
+import Platform.Cmd exposing (Cmd)
+import Navigation
 
-import Effects exposing (Effects)
-import TransitRouter
-import RouteParser
-
-import Route exposing (Route)
+import Page exposing (Page)
 
 import Server
 
-import Action exposing (..)
+import Msg exposing (..)
 
 import Model exposing (Model)
 import Model.Translations exposing (getMessage)
 import Model.View as V
 
 import LoggedIn.Model as LoggedInModel
-import LoggedIn.Action as LoggedInAction
+import LoggedIn.Msg as LoggedInMsg
 import LoggedIn.Update as LoggedInUpdate
 
 import SignIn.Model as SignInModel
-import SignIn.Action as SignInAction
+import SignIn.Msg as SignInMsg
 import SignIn.Update as SignInUpdate
 
 import Utils.Http exposing (errorKey)
 
-routerConfig : TransitRouter.Config Route Action Model
-routerConfig =
-  { mountRoute = \_ _ model -> (model, Effects.none)
-  , getDurations = \_ _ _ -> (50, 200)
-  , actionWrapper = RouterAction
-  , routeDecoder = Maybe.withDefault Route.Home << RouteParser.match Route.matchers
-  }
-
-update : Action -> Model -> (Model, Effects Action)
+update : Msg -> Model -> (Model, Cmd Msg)
 update action model =
   case action of
 
     NoOp ->
-      (model, Effects.none)
+      (model, Cmd.none)
 
     SignIn email ->
-      ( applySignIn model (SignInAction.WaitingServer)
+      ( applySignIn model (SignInMsg.WaitingServer)
       , Server.signIn email
-          |> Task.map (always (UpdateSignIn SignInAction.ValidLogin))
-          |> flip Task.onError (\error ->
-               Task.succeed (UpdateSignIn (SignInAction.ErrorLogin (errorKey error)))
-             )
-          |> Effects.task
+          |> Task.perform
+               (\error -> UpdateSignIn (SignInMsg.ErrorLogin (errorKey error)))
+               (\() -> UpdateSignIn SignInMsg.ValidLogin)
       )
 
     GoLoggedInView init ->
       ( { model | view = V.LoggedInView (LoggedInModel.init init) }
-      , Effects.none
+      , Cmd.none
       )
 
     UpdateTime time ->
-      ({ model | currentTime = time }, Effects.none)
+      ({ model | currentTime = time }, Cmd.none)
 
     GoSignInView ->
-      ({ model | view = V.SignInView (SignInModel.init Nothing) }, Effects.none)
-
-    UpdateSignIn signInAction ->
-      (applySignIn model signInAction, Effects.none)
+      ({ model | view = V.SignInView (SignInModel.init Nothing) }, Cmd.none)
 
-    UpdateLoggedIn loggedInAction ->
-      applyLoggedIn model loggedInAction
+    UpdateSignIn signInMsg ->
+      (applySignIn model signInMsg, Cmd.none)
 
-    RouterAction routeAction ->
-      TransitRouter.update
-        routerConfig
-        routeAction
-        model
+    UpdateLoggedIn loggedInMsg ->
+      applyLoggedIn model loggedInMsg
 
     SignOut ->
       ( model
       , Server.signOut
-          |> Task.map (always GoSignInView)
-          |> flip Task.onError (always <| Task.succeed NoOp)
-          |> Effects.task
+          |> Task.perform (always NoOp) (always GoSignInView)
       )
 
-applySignIn : Model -> SignInAction.Action -> Model
-applySignIn model signInAction =
+applySignIn : Model -> SignInMsg.Msg -> Model
+applySignIn model signInMsg =
   case model.view of
     V.SignInView signInView ->
-      { model | view = V.SignInView (SignInUpdate.update model.translations signInAction signInView) }
+      { model | view = V.SignInView (SignInUpdate.update model.translations signInMsg signInView) }
     _ ->
       model
 
-applyLoggedIn : Model -> LoggedInAction.Action -> (Model, Effects Action)
-applyLoggedIn model loggedInAction =
+applyLoggedIn : Model -> LoggedInMsg.Msg -> (Model, Cmd Msg)
+applyLoggedIn model loggedInMsg =
   case model.view of
     V.LoggedInView loggedInView ->
-      let (loggedInView, effects) = LoggedInUpdate.update model loggedInAction loggedInView
+      let (loggedInView, cmd) = LoggedInUpdate.update model loggedInMsg loggedInView
       in  ( { model | view = V.LoggedInView loggedInView }
-          , Effects.map UpdateLoggedIn effects
+          , Cmd.map UpdateLoggedIn cmd
           )
     _ ->
-      (model, Effects.none)
+      (model, Cmd.none)
+
+urlUpdate : Result String Page -> Model -> (Model, Cmd Msg)
+urlUpdate result model =
+  case Debug.log "urlUpdate" result of
+    Err _ ->
+      (model, Navigation.modifyUrl (Page.toHash model.page))
+    Ok page ->
+      ({ model | page = page }, Cmd.none)