aswi20220x00-gitlab/webapp/contexts/LoggedUserContext.tsx @ ee3e7185

import React, { createContext, useEffect, useState } from 'react';
import moment, { Moment } from 'moment';
import { getTokenData, loginUser, logoutUser } from '../utils/login';
import { useRouter } from 'next/router';
import { ERole } from '../api';

interface ILoggedUserProvider {
    login: (email: string, password: string) => Promise<boolean>;
    logout: () => Promise<boolean>;

    tokenExpiration?: Moment | null;
    setTokenExpiration?: (newTokenExpiration: Moment | null) => void;

    role?: ERole | undefined;
    setRole?: (newRoles: ERole | undefined) => void;

    refreshData?: () => Promise<void>;
}

export const LoggedUserContext = createContext<ILoggedUserProvider>({
    login: async (username: string, password: string): Promise<boolean> => {
        return false;
    },
    logout: async (): Promise<boolean> => {
        return false;
    },
});

const LoggedUserProvider = (props: { children: any }) => {
    const [role, setRole] = useState<ERole>();
    const [tokenExpiration, setTokenExpiration] = useState<Moment | null>(null);
    const router = useRouter();

    useEffect(() => {
        loadData();
    }, []);

    async function loadData() {
        const tokenData = await getTokenData();
        if (!tokenData) {
            setRole(undefined);
            setTokenExpiration(null);
        } else {
            setRole(tokenData.role);
            setTokenExpiration(moment(tokenData.expiration));
        }
    }

    async function login(username: string, password: string): Promise<boolean> {
        const res = await loginUser(username, password);
        if (!res) {
            return false;
        }

        await loadData();

        return true;
    }

    async function logout(): Promise<boolean> {
        const res = await logoutUser();

        if (res) {
            setRole(undefined);
        }
        await router.push('/');
        return res;
    }

    return (
        <LoggedUserContext.Provider
            value={{
                tokenExpiration,
                setTokenExpiration,
                role,
                setRole,
                refreshData: loadData,
                login,
                logout,
            }}
        >
            {props.children}
        </LoggedUserContext.Provider>
    );
};

export default LoggedUserProvider;