path: root/assessments/tt/client/src/State.elm

port module State exposing (..)

import Array exposing (Array)
import Browser
import Browser.Navigation as Nav
import Date
import DatePicker
import Http
import Json.Decode as JD
import Json.Decode.Extra as JDE
import Json.Encode as JE
import Json.Encode.Extra as JEE
import Process
import RemoteData exposing (WebData)
import Shared
import Task
import Time
import Url
import Url.Builder as UrlBuilder
import Url.Parser exposing ((</>), Parser, int, map, oneOf, s, string)
import Utils



--------------------------------------------------------------------------------
-- Types
--------------------------------------------------------------------------------


type Msg
    = DoNothing
    | UpdateUsername String
    | UpdateEmail String
    | UpdatePassword String
    | UpdateRole String
    | UpdateAdminTab AdminTab
    | UpdateTripDestination String
    | UpdateTripStartDate DatePicker.Msg
    | UpdateTripEndDate DatePicker.Msg
    | UpdateTripComment String
    | UpdateEditTripDestination String
    | UpdateEditTripComment String
    | ClearErrors
    | ToggleLoginForm
    | PrintPage
    | GoogleSignIn
    | GoogleSignOut
    | UpdateInviteEmail String
    | UpdateInviteRole (Maybe Role)
    | ReceiveTodaysDate Date.Date
    | EditTrip Trip
    | CancelEditTrip
      -- SPA
    | LinkClicked Browser.UrlRequest
    | UrlChanged Url.Url
      -- Outbound network
    | AttemptGetAccounts
    | AttemptGetTrips
    | AttemptSignUp
    | AttemptLogin
    | AttemptLogout
    | AttemptDeleteAccount String
    | AttemptCreateTrip Date.Date Date.Date
    | AttemptDeleteTrip Trip
    | AttemptInviteUser Role
    | AttemptUpdateTrip TripPK Trip
      -- Inbound network
    | GotAccounts (WebData (List Account))
    | GotTrips (WebData (List Trip))
    | GotSignUp (Result Http.Error Session)
    | GotLogin (Result Http.Error Session)
    | GotLogout (Result Http.Error String)
    | GotDeleteAccount (Result Http.Error String)
    | GotCreateTrip (Result Http.Error ())
    | GotDeleteTrip (Result Http.Error ())
    | GotInviteUser (Result Http.Error ())
    | GotUpdateTrip (Result Http.Error ())


type Route
    = Login
    | UserHome
    | ManagerHome
    | AdminHome


type Role
    = User
    | Manager
    | Admin


type alias Account =
    { username : String
    , role : Role
    }


type alias Session =
    { role : Role
    , username : String
    }


type alias Review =
    { rowid : Int
    , content : String
    , rating : Int
    , user : String
    , dateOfVisit : String
    }


type AdminTab
    = Accounts
    | Trips


type LoginTab
    = LoginForm
    | SignUpForm


type alias Trip =
    { username : String
    , destination : String
    , startDate : Date.Date
    , endDate : Date.Date
    , comment : String
    }


type alias TripPK =
    { username : String
    , destination : String
    , startDate : Date.Date
    }


type alias Model =
    { route : Maybe Route
    , url : Url.Url
    , key : Nav.Key
    , session : Maybe Session
    , todaysDate : Maybe Date.Date
    , username : String
    , email : String
    , password : String
    , role : Maybe Role
    , accounts : WebData (List Account)
    , startDatePicker : DatePicker.DatePicker
    , endDatePicker : DatePicker.DatePicker
    , tripDestination : String
    , tripStartDate : Maybe Date.Date
    , tripEndDate : Maybe Date.Date
    , tripComment : String
    , trips : WebData (List Trip)
    , editingTrip : Maybe Trip
    , editTripDestination : String
    , editTripComment : String
    , adminTab : AdminTab
    , loginTab : LoginTab
    , inviteEmail : String
    , inviteRole : Maybe Role
    , inviteResponseStatus : WebData ()
    , updateTripStatus : WebData ()
    , loginError : Maybe Http.Error
    , logoutError : Maybe Http.Error
    , signUpError : Maybe Http.Error
    , deleteUserError : Maybe Http.Error
    , createTripError : Maybe Http.Error
    , deleteTripError : Maybe Http.Error
    , inviteUserError : Maybe Http.Error
    }


allErrors : Model -> List ( Maybe Http.Error, String )
allErrors model =
    [ ( model.loginError, "Error attempting to authenticate" )
    , ( model.logoutError, "Error attempting to log out" )
    , ( model.signUpError, "Error attempting to create your account" )
    , ( model.deleteUserError, "Error attempting to delete a user" )
    , ( model.createTripError, "Error attempting to create a trip" )
    , ( model.inviteUserError, "Error attempting to invite a user" )
    ]



--------------------------------------------------------------------------------
-- Functions
--------------------------------------------------------------------------------


roleToString : Role -> String
roleToString role =
    case role of
        User ->
            "user"

        Manager ->
            "manager"

        Admin ->
            "admin"


endpoint : List String -> List UrlBuilder.QueryParameter -> String
endpoint =
    UrlBuilder.crossOrigin Shared.serverOrigin


encodeRole : Role -> JE.Value
encodeRole x =
    case x of
        User ->
            JE.string "user"

        Manager ->
            JE.string "manager"

        Admin ->
            JE.string "admin"


decodeRole : JD.Decoder Role
decodeRole =
    let
        toRole : String -> JD.Decoder Role
        toRole s =
            case s of
                "user" ->
                    JD.succeed User

                "manager" ->
                    JD.succeed Manager

                "admin" ->
                    JD.succeed Admin

                x ->
                    JD.fail ("Invalid input: " ++ x)
    in
    JD.string |> JD.andThen toRole


decodeSession : JD.Decoder Session
decodeSession =
    JD.map2
        Session
        (JD.field "role" decodeRole)
        (JD.field "username" JD.string)


encodeLoginRequest : String -> String -> JE.Value
encodeLoginRequest username password =
    JE.object
        [ ( "username", JE.string username )
        , ( "password", JE.string password )
        ]


login : String -> String -> Cmd Msg
login username password =
    Utils.postWithCredentials
        { url = endpoint [ "login" ] []
        , body = Http.jsonBody (encodeLoginRequest username password)
        , expect = Http.expectJson GotLogin decodeSession
        }


logout : Cmd Msg
logout =
    Utils.getWithCredentials
        { url = endpoint [ "logout" ] []
        , expect = Http.expectString GotLogout
        }


signUp :
    { username : String
    , email : String
    , password : String
    }
    -> Cmd Msg
signUp { username, email, password } =
    Utils.postWithCredentials
        { url = endpoint [ "accounts" ] []
        , body =
            Http.jsonBody
                (JE.object
                    [ ( "username", JE.string username )
                    , ( "email", JE.string username )
                    , ( "password", JE.string password )
                    , ( "role", JE.string "user" )
                    ]
                )
        , expect = Http.expectJson GotSignUp decodeSession
        }


updateTrip : TripPK -> Trip -> Cmd Msg
updateTrip tripKey trip =
    Utils.putWithCredentials
        { url = endpoint [ "trips" ] []
        , body =
            Http.jsonBody
                (JE.object
                    [ ( "tripKey", encodeTripKey tripKey )
                    , ( "destination", JE.string trip.destination )
                    , ( "startDate", encodeDate trip.startDate )
                    , ( "endDate", encodeDate trip.endDate )
                    , ( "comment", JE.string trip.comment )
                    ]
                )
        , expect = Http.expectWhatever GotUpdateTrip
        }


inviteUser : { email : String, role : Role } -> Cmd Msg
inviteUser { email, role } =
    Utils.postWithCredentials
        { url = endpoint [ "invite" ] []
        , body =
            Http.jsonBody
                (JE.object
                    [ ( "email", JE.string email )
                    , ( "role", encodeRole role )
                    ]
                )
        , expect = Http.expectWhatever GotInviteUser
        }


createTrip :
    { username : String
    , destination : String
    , startDate : Date.Date
    , endDate : Date.Date
    , comment : String
    }
    -> Cmd Msg
createTrip { username, destination, startDate, endDate, comment } =
    Utils.postWithCredentials
        { url = endpoint [ "trips" ] []
        , body =
            Http.jsonBody
                (JE.object
                    [ ( "username", JE.string username )
                    , ( "destination", JE.string destination )
                    , ( "startDate", encodeDate startDate )
                    , ( "endDate", encodeDate endDate )
                    , ( "comment", JE.string comment )
                    ]
                )
        , expect = Http.expectWhatever GotCreateTrip
        }


deleteTrip :
    { username : String
    , destination : String
    , startDate : Date.Date
    }
    -> Cmd Msg
deleteTrip { username, destination, startDate } =
    Utils.deleteWithCredentials
        { url = endpoint [ "trips" ] []
        , body =
            Http.jsonBody
                (JE.object
                    [ ( "username", JE.string username )
                    , ( "destination", JE.string destination )
                    , ( "startDate", encodeDate startDate )
                    ]
                )
        , expect = Http.expectWhatever GotDeleteTrip
        }


deleteAccount : String -> Cmd Msg
deleteAccount username =
    Utils.deleteWithCredentials
        { url = endpoint [ "accounts" ] [ UrlBuilder.string "username" username ]
        , body = Http.emptyBody
        , expect = Http.expectString GotDeleteAccount
        }


decodeReview : JD.Decoder Review
decodeReview =
    JD.map5
        Review
        (JD.field "rowid" JD.int)
        (JD.field "content" JD.string)
        (JD.field "rating" JD.int)
        (JD.field "user" JD.string)
        (JD.field "timestamp" JD.string)


encodeTripKey : TripPK -> JE.Value
encodeTripKey tripKey =
    JE.object
        [ ( "username", JE.string tripKey.username )
        , ( "destination", JE.string tripKey.destination )
        , ( "startDate", encodeDate tripKey.startDate )
        ]


encodeDate : Date.Date -> JE.Value
encodeDate date =
    date |> Date.toIsoString |> JE.string


decodeDate : JD.Decoder Date.Date
decodeDate =
    JD.string |> JD.andThen (Date.fromIsoString >> JDE.fromResult)


fetchTrips : Cmd Msg
fetchTrips =
    Utils.getWithCredentials
        { url = endpoint [ "trips" ] []
        , expect =
            Http.expectJson
                (RemoteData.fromResult >> GotTrips)
                (JD.list
                    (JD.map5
                        Trip
                        (JD.field "username" JD.string)
                        (JD.field "destination" JD.string)
                        (JD.field "startDate" decodeDate)
                        (JD.field "endDate" decodeDate)
                        (JD.field "comment" JD.string)
                    )
                )
        }


fetchAccounts : Cmd Msg
fetchAccounts =
    Utils.getWithCredentials
        { url = endpoint [ "accounts" ] []
        , expect =
            Http.expectJson
                (RemoteData.fromResult >> GotAccounts)
                (JD.list
                    (JD.map2
                        Account
                        (JD.field "username" JD.string)
                        (JD.field "role" decodeRole)
                    )
                )
        }


sleepAndClearErrors : Cmd Msg
sleepAndClearErrors =
    Process.sleep 4000
        |> Task.perform (\_ -> ClearErrors)


isAuthorized : Role -> Route -> Bool
isAuthorized role route =
    case ( role, route ) of
        ( User, _ ) ->
            True

        ( Manager, _ ) ->
            True

        ( Admin, _ ) ->
            True


homeRouteForRole : Role -> String
homeRouteForRole role =
    case role of
        User ->
            "/user"

        Manager ->
            "/manager"

        Admin ->
            "/admin"


routeParser : Parser (Route -> a) a
routeParser =
    oneOf
        [ map Login (s "topic")
        , map UserHome (s "user")
        , map ManagerHome (s "manager")
        , map AdminHome (s "admin")
        ]


{-| Set init to `prod` when going live.
-}
prod : () -> Url.Url -> Nav.Key -> ( Model, Cmd Msg )
prod _ url key =
    let
        ( startDatePicker, startDatePickerCmd ) =
            DatePicker.init

        ( endDatePicker, endDatePickerCmd ) =
            DatePicker.init
    in
    ( { route = Nothing
      , url = url
      , key = key
      , session = Nothing
      , todaysDate = Nothing
      , username = ""
      , email = ""
      , password = ""
      , role = Nothing
      , accounts = RemoteData.NotAsked
      , tripDestination = ""
      , tripStartDate = Nothing
      , tripEndDate = Nothing
      , tripComment = ""
      , trips = RemoteData.NotAsked
      , editingTrip = Nothing
      , editTripDestination = ""
      , editTripComment = ""
      , startDatePicker = startDatePicker
      , endDatePicker = endDatePicker
      , adminTab = Accounts
      , loginTab = LoginForm
      , inviteEmail = ""
      , inviteRole = Nothing
      , inviteResponseStatus = RemoteData.NotAsked
      , updateTripStatus = RemoteData.NotAsked
      , loginError = Nothing
      , logoutError = Nothing
      , signUpError = Nothing
      , deleteUserError = Nothing
      , createTripError = Nothing
      , deleteTripError = Nothing
      , inviteUserError = Nothing
      }
    , Cmd.batch
        [ Cmd.map UpdateTripStartDate startDatePickerCmd
        , Cmd.map UpdateTripEndDate endDatePickerCmd
        , Date.today |> Task.perform ReceiveTodaysDate
        ]
    )


{-| When working on a feature for the UserHome, use this.
-}
userHome : () -> Url.Url -> Nav.Key -> ( Model, Cmd Msg )
userHome flags url key =
    let
        ( model, cmd ) =
            prod flags url key
    in
    ( { model
        | route = Just UserHome
        , session = Just { username = "mimi", role = User }
        , trips =
            RemoteData.Success
                [ { username = "mimi"
                  , destination = "Barcelona"
                  , startDate = Date.fromCalendarDate 2020 Time.Sep 25
                  , endDate = Date.fromCalendarDate 2020 Time.Oct 5
                  , comment = "Blah"
                  }
                , { username = "mimi"
                  , destination = "Paris"
                  , startDate = Date.fromCalendarDate 2021 Time.Jan 1
                  , endDate = Date.fromCalendarDate 2021 Time.Feb 1
                  , comment = "Bon voyage!"
                  }
                ]
      }
    , cmd
    )


managerHome : () -> Url.Url -> Nav.Key -> ( Model, Cmd Msg )
managerHome flags url key =
    let
        ( model, cmd ) =
            prod flags url key
    in
    ( { model
        | route = Just ManagerHome
        , session = Just { username = "bill", role = Manager }
      }
    , cmd
    )


adminHome : () -> Url.Url -> Nav.Key -> ( Model, Cmd Msg )
adminHome flags url key =
    let
        ( model, cmd ) =
            prod flags url key
    in
    ( { model
        | route = Just AdminHome
        , session = Just { username = "wpcarro", role = Admin }
      }
    , cmd
    )


port printPage : () -> Cmd msg


port googleSignIn : () -> Cmd msg


port googleSignOut : () -> Cmd msg


{-| The initial state for the application.
-}
init : () -> Url.Url -> Nav.Key -> ( Model, Cmd Msg )
init flags url key =
    prod flags url key


{-| Now that we have state, we need a function to change the state.
-}
update : Msg -> Model -> ( Model, Cmd Msg )
update msg model =
    case msg of
        DoNothing ->
            ( model, Cmd.none )

        UpdateUsername x ->
            ( { model | username = x }, Cmd.none )

        UpdatePassword x ->
            ( { model | password = x }, Cmd.none )

        UpdateEmail x ->
            ( { model | email = x }, Cmd.none )

        UpdateAdminTab x ->
            ( { model | adminTab = x }, Cmd.none )

        UpdateRole x ->
            let
                maybeRole =
                    case x of
                        "user" ->
                            Just User

                        "manager" ->
                            Just Manager

                        "admin" ->
                            Just Admin

                        _ ->
                            Nothing
            in
            ( { model | role = maybeRole }, Cmd.none )

        UpdateTripDestination x ->
            ( { model | tripDestination = x }, Cmd.none )

        UpdateTripStartDate dpMsg ->
            let
                ( newDatePicker, dateEvent ) =
                    DatePicker.update DatePicker.defaultSettings dpMsg model.startDatePicker

                newDate =
                    case dateEvent of
                        DatePicker.Picked changedDate ->
                            Just changedDate

                        _ ->
                            model.tripStartDate
            in
            ( { model
                | tripStartDate = newDate
                , startDatePicker = newDatePicker
              }
            , Cmd.none
            )

        UpdateTripEndDate dpMsg ->
            let
                ( newDatePicker, dateEvent ) =
                    DatePicker.update DatePicker.defaultSettings dpMsg model.endDatePicker

                newDate =
                    case dateEvent of
                        DatePicker.Picked changedDate ->
                            Just changedDate

                        _ ->
                            model.tripEndDate
            in
            ( { model
                | tripEndDate = newDate
                , endDatePicker = newDatePicker
              }
            , Cmd.none
            )

        UpdateTripComment x ->
            ( { model | tripComment = x }, Cmd.none )

        UpdateEditTripDestination x ->
            ( { model | editTripDestination = x }, Cmd.none )

        UpdateEditTripComment x ->
            ( { model | editTripComment = x }, Cmd.none )

        ClearErrors ->
            ( { model
                | loginError = Nothing
                , logoutError = Nothing
                , signUpError = Nothing
                , deleteUserError = Nothing
                , createTripError = Nothing
              }
            , Cmd.none
            )

        ToggleLoginForm ->
            ( { model
                | loginTab =
                    case model.loginTab of
                        LoginForm ->
                            SignUpForm

                        SignUpForm ->
                            LoginForm
              }
            , Cmd.none
            )

        PrintPage ->
            ( model, printPage () )

        GoogleSignIn ->
            ( model, googleSignIn () )

        GoogleSignOut ->
            ( model, googleSignOut () )

        UpdateInviteEmail x ->
            ( { model | inviteEmail = x }, Cmd.none )

        UpdateInviteRole mRole ->
            ( { model | inviteRole = mRole }, Cmd.none )

        ReceiveTodaysDate date ->
            ( { model | todaysDate = Just date }, Cmd.none )

        EditTrip trip ->
            ( { model
                | editingTrip = Just trip
                , editTripDestination = trip.destination
                , editTripComment = trip.comment
              }
            , Cmd.none
            )

        CancelEditTrip ->
            ( { model
                | editingTrip = Nothing
                , editTripDestination = ""
                , editTripComment = ""
              }
            , Cmd.none
            )

        LinkClicked urlRequest ->
            case urlRequest of
                Browser.Internal url ->
                    ( model, Nav.pushUrl model.key (Url.toString url) )

                Browser.External href ->
                    ( model, Nav.load href )

        UrlChanged url ->
            let
                route =
                    Url.Parser.parse routeParser url
            in
            case route of
                Just UserHome ->
                    ( { model
                        | url = url
                        , route = route
                        , trips = RemoteData.Loading
                      }
                    , fetchTrips
                    )

                Just ManagerHome ->
                    ( { model
                        | url = url
                        , route = route
                        , accounts = RemoteData.Loading
                      }
                    , fetchAccounts
                    )

                Just AdminHome ->
                    ( { model
                        | url = url
                        , route = route
                        , accounts = RemoteData.Loading
                        , trips = RemoteData.Loading
                      }
                    , Cmd.batch
                        [ fetchAccounts
                        , fetchTrips
                        ]
                    )

                _ ->
                    ( { model
                        | url = url
                        , route = route
                      }
                    , Cmd.none
                    )

        -- GET /accounts
        AttemptGetAccounts ->
            ( { model | accounts = RemoteData.Loading }, fetchAccounts )

        GotAccounts xs ->
            ( { model | accounts = xs }, Cmd.none )

        -- DELETE /accounts
        AttemptDeleteAccount username ->
            ( model, deleteAccount username )

        GotDeleteAccount result ->
            case result of
                Ok _ ->
                    ( model, fetchAccounts )

                Err e ->
                    ( { model | deleteUserError = Just e }
                    , sleepAndClearErrors
                    )

        -- POST /trips
        AttemptCreateTrip startDate endDate ->
            ( model
            , case model.session of
                Nothing ->
                    Cmd.none

                Just session ->
                    createTrip
                        { username = session.username
                        , destination = model.tripDestination
                        , startDate = startDate
                        , endDate = endDate
                        , comment = model.tripComment
                        }
            )

        GotCreateTrip result ->
            case result of
                Ok _ ->
                    ( { model
                        | tripDestination = ""
                        , tripStartDate = Nothing
                        , tripEndDate = Nothing
                        , tripComment = ""
                      }
                    , fetchTrips
                    )

                Err e ->
                    ( { model
                        | createTripError = Just e
                        , tripDestination = ""
                        , tripStartDate = Nothing
                        , tripEndDate = Nothing
                        , tripComment = ""
                      }
                    , sleepAndClearErrors
                    )

        -- DELETE /trips
        AttemptDeleteTrip trip ->
            ( model
            , deleteTrip
                { username = trip.username
                , destination = trip.destination
                , startDate = trip.startDate
                }
            )

        GotDeleteTrip result ->
            case result of
                Ok _ ->
                    ( model, fetchTrips )

                Err e ->
                    ( { model | deleteTripError = Just e }
                    , sleepAndClearErrors
                    )

        AttemptInviteUser role ->
            ( { model | inviteResponseStatus = RemoteData.Loading }
            , inviteUser
                { email = model.inviteEmail
                , role = role
                }
            )

        GotInviteUser result ->
            case result of
                Ok _ ->
                    ( { model
                        | inviteEmail = ""
                        , inviteRole = Nothing
                        , inviteResponseStatus = RemoteData.Success ()
                      }
                    , Cmd.none
                    )

                Err e ->
                    ( { model
                        | inviteUserError = Just e
                        , inviteResponseStatus = RemoteData.Failure e
                      }
                    , sleepAndClearErrors
                    )

        -- PATCH /trips
        AttemptUpdateTrip tripKey trip ->
            ( { model | updateTripStatus = RemoteData.Loading }
            , updateTrip tripKey trip
            )

        GotUpdateTrip result ->
            case result of
                Ok _ ->
                    ( { model | updateTripStatus = RemoteData.Success () }
                    , fetchTrips
                    )

                Err e ->
                    ( { model | updateTripStatus = RemoteData.Failure e }
                    , Cmd.none
                    )

        -- POST /accounts
        AttemptSignUp ->
            ( model
            , signUp
                { username = model.username
                , email = model.email
                , password = model.password
                }
            )

        GotSignUp result ->
            case result of
                Ok session ->
                    ( { model | session = Just session }
                    , Nav.pushUrl model.key (homeRouteForRole session.role)
                    )

                Err x ->
                    ( { model | signUpError = Just x }
                    , sleepAndClearErrors
                    )

        -- GET /trips
        AttemptGetTrips ->
            ( { model | trips = RemoteData.Loading }, fetchTrips )

        GotTrips xs ->
            ( { model | trips = xs }, Cmd.none )

        -- POST /login
        AttemptLogin ->
            ( model, login model.username model.password )

        GotLogin result ->
            case result of
                Ok session ->
                    ( { model | session = Just session }
                    , Nav.pushUrl model.key (homeRouteForRole session.role)
                    )

                Err x ->
                    ( { model | loginError = Just x }
                    , sleepAndClearErrors
                    )

        -- GET /logout
        AttemptLogout ->
            ( model, logout )

        GotLogout result ->
            case result of
                Ok _ ->
                    ( { model | session = Nothing }
                    , Nav.pushUrl model.key "/login"
                    )

                Err e ->
                    ( { model | logoutError = Just e }
                    , sleepAndClearErrors
                    )