@axinom/mosaic-user-auth

import { TokenResponse, useUserService } from '@axinom/mosaic-user-auth';

const {getToken} = useUserService();
const [tokenResponse, setTokenResponse] = useState<TokenResponse | null>(
    null,
  );
setTokenResponse(await getToken());

import { TokenResponse, useUserService } from '@axinom/mosaic-user-auth';

const {getToken, addTokenChangedHandler} = useUserService();
const [tokenResponse, setTokenResponse] = useState<TokenResponse | null>(
    null,
  );
useEffect(() => {
    (async () => {
      setTokenResponse(await getToken());
    })();
  }, [addTokenChangedHandler, getToken]);

import { TokenResponse, useUserService } from '@axinom/mosaic-user-auth';

const {getToken, removeTokenChangedHandler} = useUserService();
const [tokenResponse, setTokenResponse] = useState<TokenResponse | null>(
    null,
  );
useEffect(() => {
    (async () => {
      setTokenResponse(await getToken());
    })();
  }, [removeTokenChangedHandler, getToken]);

import { IdpConfiguration, useUserService } from '@axinom/mosaic-user-auth';

const { getIdpConfigurations } = useUserService();
const [idpConfigurations, setIDPConfigurations] = useState<
    IdpConfiguration[]
  >([]);

useEffect(() => {
    (async () => {
      const idpConfigs = await getIdpConfigurations(
        `app.ottstream.com`,
      );
      setIDPConfigurations(idpConfigs);
    })();
  }, [getIdpConfigurations]);

import { useUserService } from '@axinom/mosaic-user-auth';

const { logoutUser } = useUserService();

await logoutUser();

import { useUserService } from '@axinom/mosaic-user-auth';

const { initiateUserSignUp } = useUserService();

const signUpResponse = await initiateUserSignUp(`app.ottstream.com/signup`, {email, password});

import { useUserService } from '@axinom/mosaic-user-auth';

const { checkUserSignUpOTP } = useUserService();

const { isOtpValid } = await checkUserSignUpOTP('app.ottstream.com', { signUpOtp });

import { useUserService } from '@axinom/mosaic-user-auth';

const { completeUserSignUp } = useUserService();

const completeUserSignUpResponse = await completeUserSignUp({signUpOtp, password});

import { useUserService } from '@axinom/mosaic-user-auth';

const { signIn } = useUserService();

const handlesSignIn = async(event: React.FormEvent<HTMLFormElement>): Promise<void> => {
    event.preventDefault();
    const signInResponse = await signIn({
      email: email,
      password: password
    });
    if (signInResponse.code === SignInResponseCode.SUCCESS) {
      window.location.assign('/');
    } else {
      setError(`Unable to Sign In. ${signInResponse.details?.error ?? signInResponse.message}`)
    }
  }

import { useUserService } from '@axinom/mosaic-user-auth';

const { initiateResetPassword } = useUserService();

const initiatePasswordReset = async(event: React.FormEvent<HTMLFormElement>): Promise<void> => {
  event.preventDefault();
  const initiatePasswordResetResponse = await initiateResetPassword(`${ottstream_APP_BASE_URL}/reset-password`, email);
  if (initiatePasswordResetResponse.code === PasswordResponseCode.SUCCESS) {
    window.location.assign('/complete-reset-password');
  } else {
    setError(initiatePasswordResetResponse.message ?? 'Error resetting password.');
  }
}

import { useUserService } from '@axinom/mosaic-user-auth';

const { checkResetPasswordOTP } = useUserService();

const { isOtpValid } = await checkResetPasswordOTP('app.ottstream.com', { resetOtp });

import { useUserService } from '@axinom/mosaic-user-auth';

const { completeResetPassword } = useUserService();

const completePasswordReset = async(event: React.FormEvent<HTMLFormElement>): Promise<void> => {
  event.preventDefault();
  const completePasswordResetResponse = await completeResetPassword({newPassword: password, resetOtp: otp});
  if (completePasswordResetResponse.code === PasswordResponseCode.SUCCESS) {
    window.location.assign('/login');
  } else {
    setError(completePasswordResetResponse.message ?? 'Error resetting password.');
  }
}

import { useUserService } from '@axinom/mosaic-user-auth';

const { setActiveProfile } = useUserService();

const handleSelectProfileClick = async (profileId: string) => {
  await setActiveProfile(profileId);
  history.replace('/');
};

import { useUserService } from '@axinom/mosaic-user-auth';

const { getUserProfile } = useUserService();

const userProfile = await getUserProfile(profileId);

import { useUserService } from '@axinom/mosaic-user-auth';

const { getUserProfiles } = useUserService();

const userProfiles = await getUserProfiles();

import { useUserService } from '@axinom/mosaic-user-auth';

const { createUserProfile } = useUserService();

const handleAddProfileClick = async () => {
  await createUserProfile(displayName);
};

import { useUserService } from '@axinom/mosaic-user-auth';

const { updateUserProfile } = useUserService();

const [userProfiles, setUserProfiles] = useState<UserProfile[] | undefined>(
    undefined,
  );

const handleEditProfileClick = async (userProfileToUpdate: UserProfile) => {
  const profileIndex = userProfiles?.findIndex(
    (profile) => profile.id === userProfileToUpdate.id,
  );

  if (profileIndex !== undefined) {
    const updatedUserProfiles = [...(userProfiles ?? [])];
    updatedUserProfiles[profileIndex] = {
      ...updatedUserProfiles[profileIndex],
      ...userProfileToUpdate,
      profilePictureUrl: `https://avatars.dicebear.com/api/bottts/${tokenResponse?.userToken?.userId}-${userProfileToUpdate.displayName}.svg`,
    };

    setUserProfiles(updatedUserProfiles);
  }

  await updateUserProfile(userProfileToUpdate);
};

import { useUserService } from '@axinom/mosaic-user-auth';

const { updateUserProfile } = useUserService();

const [userProfiles, setUserProfiles] = useState<UserProfile[] | undefined>(
    undefined,
  );

const handleDeleteProfileClick = async (profileIdToDelete: string) => {
  setUserProfiles(
    userProfiles?.filter((profile) => profile.id !== profileIdToDelete),
  );

  await deleteUserProfile(profileIdToDelete);
};

import { useUserService } from '@axinom/mosaic-user-auth';

const { authenticateEndUserApplication } = useUserService();

const {endUserApplicationToken} = await authenticateEndUserApplication({tenantId, environmentId, applicationId, applicationKey});