signInByOtp method

@override Future<AuthResponse<T>> signInByOtp(OtpAuthenticator authenticator, { bool storeToken = false, })

Implementation

@override
Future<AuthResponse<T>> signInByOtp(
  OtpAuthenticator authenticator, {
  bool storeToken = false,
}) async {
  final token = authenticator.token;
  final code = authenticator.smsCode;
  if (!AuthValidator.isValidToken(token)) {
    return emit(AuthResponse.failure(
      msg.token,
      provider: AuthProviders.phone,
      type: AuthType.phone,
    ));
  } else if (!AuthValidator.isValidSmsCode(code)) {
    return emit(AuthResponse.failure(
      msg.otp,
      provider: AuthProviders.phone,
      type: AuthType.phone,
    ));
  } else {
    try {
      emit(const AuthResponse.loading(AuthProviders.phone, AuthType.phone));
      final credential = authenticator.credential;
      final response = await authHandler.signInWithCredential(
        credential: credential,
      );
      if (response.isSuccessful) {
        final result = response.data?.user;
        if (result != null) {
          final user = authenticator.copy(
            id: result.uid,
            accessToken: storeToken ? credential.accessToken : null,
            idToken: storeToken && credential.token != null
                ? "${credential.token}"
                : null,
            email: result.email,
            name: result.displayName,
            phone: result.phoneNumber,
            photo: result.photoURL,
            provider: AuthProviders.phone.name,
            loggedIn: true,
            loggedInTime: Entity.generateTimeMills,
            verified: true,
          );
          return _update(
            id: user.id,
            creates: user.source,
            updates: {
              ...user.extra ?? {},
              AuthKeys.i.loggedIn: true,
              AuthKeys.i.loggedInTime: Entity.generateTimeMills,
            },
          ).then((value) {
            return emit(AuthResponse.authenticated(
              value,
              msg: msg.signInWithPhone.done,
              provider: AuthProviders.phone,
              type: AuthType.phone,
            ));
          });
        } else {
          return emit(AuthResponse.failure(
            msg.authorization,
            provider: AuthProviders.phone,
            type: AuthType.phone,
          ));
        }
      } else {
        return emit(AuthResponse.failure(
          response.exception,
          provider: AuthProviders.phone,
          type: AuthType.phone,
        ));
      }
    } catch (_) {
      return emit(AuthResponse.failure(
        msg.signInWithPhone.failure ?? _,
        provider: AuthProviders.phone,
        type: AuthType.phone,
      ));
    }
  }
}