onasty @ 9c8b9eae5400bed303e3892d640786b0cb0b3554

module Pages.Auth exposing (Model, Msg, Variant, page)

import Api

import Api.Auth

import Auth.User

import Data.Credentials exposing (Credentials)

import Effect exposing (Effect)

import Html exposing (Html)

import Html.Attributes as Attr

import Html.Events

import Layouts

import Page exposing (Page)

import Route exposing (Route)

import Route.Path

import Shared

import View exposing (View)

page : Shared.Model -> Route () -> Page Model Msg

page shared _ =

    Page.new

        { init = init shared

        , update = update

        , subscriptions = subscriptions

        , view = view

        }

        |> Page.withLayout (\_ -> Layouts.Header {})

-- INIT

type alias Model =

    { email : String

    , password : String

    , passwordAgain : String

    , isSubmittingForm : Bool

    , formVariant : Variant

    , gotSignedUp : Bool

    , apiError : Maybe Api.Error

    }

init : Shared.Model -> () -> ( Model, Effect Msg )

init shared _ =

    ( { isSubmittingForm = False

      , email = ""

      , password = ""

      , passwordAgain = ""

      , formVariant = SignIn

      , apiError = Nothing

      , gotSignedUp = False

      }

    , case shared.user of

        Auth.User.SignedIn _ ->

            Effect.pushRoutePath Route.Path.Home_

        _ ->

            Effect.none

    )

-- UPDATE

type Msg

    = UserUpdatedInput Field String

    | UserChangedFormVariant Variant

    | UserClickedSubmit

    | UserClickedResendActivationEmail

    | ApiSignInResponded (Result Api.Error Credentials)

    | ApiSignUpResponded (Result Api.Error ())

    | ApiResendVerificationEmail (Result Api.Error ())

type Field

    = Email

    | Password

    | PasswordAgain

type Variant

    = SignIn

    | SignUp

update : Msg -> Model -> ( Model, Effect Msg )

update msg model =

    case msg of

        UserClickedSubmit ->

            ( { model | isSubmittingForm = True, apiError = Nothing }

            , case model.formVariant of

                SignIn ->

                    Api.Auth.signin

                        { onResponse = ApiSignInResponded

                        , email = model.email

                        , password = model.password

                        }

                SignUp ->

                    Api.Auth.signup

                        { onResponse = ApiSignUpResponded

                        , email = model.email

                        , password = model.password

                        }

            )

        UserClickedResendActivationEmail ->

            ( model

            , Api.Auth.resendVerificationEmail

                { onResponse = ApiResendVerificationEmail

                , email = model.email

                , password = model.password

                }

            )

        UserChangedFormVariant variant ->

            ( { model | formVariant = variant }, Effect.none )

        UserUpdatedInput Email email ->

            ( { model | email = email }, Effect.none )

        UserUpdatedInput Password password ->

            ( { model | password = password }, Effect.none )

        UserUpdatedInput PasswordAgain passwordAgain ->

            ( { model | passwordAgain = passwordAgain }, Effect.none )

        ApiSignInResponded (Ok credentials) ->

            ( { model | isSubmittingForm = False }, Effect.signin credentials )

        ApiSignInResponded (Err error) ->

            ( { model | isSubmittingForm = False, apiError = Just error }, Effect.none )

        ApiSignUpResponded (Ok ()) ->

            ( { model | isSubmittingForm = False, gotSignedUp = True }, Effect.none )

        ApiSignUpResponded (Err error) ->

            ( { model | isSubmittingForm = False, apiError = Just error }, Effect.none )

        ApiResendVerificationEmail (Ok ()) ->

            ( { model | apiError = Nothing }, Effect.none )

        ApiResendVerificationEmail (Err err) ->

            ( { model | apiError = Just err }, Effect.none )

-- SUBSCRIPTIONS

subscriptions : Model -> Sub Msg

subscriptions _ =

    Sub.none

-- VIEW

view : Model -> View Msg

view model =

    { title = "Authentication"

    , body =

        [ Html.div [ Attr.class "center" ]

            -- TODO: add oauth buttons

            [ viewBanner model.apiError model.gotSignedUp

            , viewChangeVariant model.formVariant

            , viewForm model

            , viewForgotPassword

            ]

        ]

    }

viewChangeVariant : Variant -> Html Msg

viewChangeVariant variant =

    Html.div [ Attr.class "mb1" ]

        [ Html.button

            [ Attr.disabled (variant == SignIn)

            , Html.Events.onClick (UserChangedFormVariant SignIn)

            ]

            [ Html.text "Sign In" ]

        , Html.button

            [ Attr.disabled (variant == SignUp)

            , Html.Events.onClick (UserChangedFormVariant SignUp)

            ]

            [ Html.text "Sign Up" ]

        ]

viewForm : Model -> Html Msg

viewForm model =

    Html.form [ Html.Events.onSubmit UserClickedSubmit ]

        (case model.formVariant of

            SignIn ->

                [ viewFormInput { field = Email, value = model.email }

                , viewFormInput { field = Password, value = model.password }

                , viewSubmitButton model

                ]

            SignUp ->

                [ viewFormInput { field = Email, value = model.email }

                , viewFormInput { field = Password, value = model.password }

                , viewFormInput { field = PasswordAgain, value = model.passwordAgain }

                , viewSubmitButton model

                ]

        )

viewBanner : Maybe Api.Error -> Bool -> Html Msg

viewBanner maybeError gotSignedUp =

    case ( maybeError, gotSignedUp ) of

        ( Just error, _ ) ->

            Html.div [ Attr.class "box bad" ]

                [ Html.strong [ Attr.class "block titlebar" ] [ Html.text "Error" ]

                , Html.text (Api.errorMessage error)

                ]

        ( Nothing, True ) ->

            Html.div [ Attr.class "box ok" ]

                [ Html.strong [ Attr.class "block titlebar" ] [ Html.text "Successfully signed up!" ]

                , Html.p []

                    [ Html.text "Please check your email to activate your account."

                    , Html.text " If you don't see the email, please check your spam folder."

                    , Html.button [ Html.Events.onClick UserClickedResendActivationEmail ]

                        [ Html.text "Resend activation email"

                        ]

                    ]

                ]

        ( Nothing, False ) ->

            Html.text ""

viewFormInput : { field : Field, value : String } -> Html Msg

viewFormInput opts =

    Html.div [ Attr.class "mb1" ]

        [ Html.label [] [ Html.text (fromFieldToLabel opts.field) ]

        , Html.div []

            [ Html.input

                [ Attr.type_ (fromFieldToInputType opts.field)

                , Attr.value opts.value

                , Html.Events.onInput (UserUpdatedInput opts.field)

                ]

                []

            ]

        ]

viewForgotPassword : Html Msg

viewForgotPassword =

    Html.div []

        [ Html.a

            [ Attr.href "/forgot-password" ]

            [ Html.text "Forgot password?" ]

        ]

viewSubmitButton : Model -> Html Msg

viewSubmitButton model =

    Html.div [ Attr.class "mb1" ]

        [ Html.button

            [ Attr.disabled (isFormDisabled model) ]

            [ Html.text (fromVariantToLabel model.formVariant) ]

        ]

isFormDisabled : Model -> Bool

isFormDisabled model =

    case model.formVariant of

        SignIn ->

            model.isSubmittingForm

                || String.isEmpty model.email

                || String.isEmpty model.password

        SignUp ->

            model.isSubmittingForm

                || String.isEmpty model.email

                || String.isEmpty model.password

                || String.isEmpty model.passwordAgain

                || (model.password /= model.passwordAgain)

fromVariantToLabel : Variant -> String

fromVariantToLabel variant =

    case variant of

        SignIn ->

            "Sign In"

        SignUp ->

            "Sign Up"

fromFieldToLabel : Field -> String

fromFieldToLabel field =

    case field of

        Email ->

            "Email address"

        Password ->

            "Password"

        PasswordAgain ->

            "Password again"

fromFieldToInputType : Field -> String

fromFieldToInputType field =

    case field of

        Email ->

            "email"

        Password ->

            "password"

        PasswordAgain ->

            "password"