Bulk get users

Author: rsgowman

src/main/java/com/google/firebase/auth/EmailIdentifier.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2020 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.firebase.auth;
+
+import com.google.firebase.internal.NonNull;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Used for looking up an account by email.
+ *
+ * @see {FirebaseAuth#getUsers}
+ */
+public class EmailIdentifier extends UserIdentifier {
+  private static final String EMAIL_KEY = "email";
+  private final String email;
+
+  public EmailIdentifier(@NonNull String email) {
+    UserRecord.checkEmail(email);
+    this.email = email;
+  }
+
+  @Override
+  public String toString() {
+    return "EmailIdentifier(" + email + ")";
+  }
+
+  @Override
+  void populate(@NonNull Map<String, Object> payload) {
+    if (!payload.containsKey(EMAIL_KEY)) {
+      payload.put(EMAIL_KEY, new ArrayList<String>());
+    }
+    Object emailPayload = payload.get(EMAIL_KEY);
+
+    @SuppressWarnings("unchecked")
+    List<String> emailList = (List<String>)emailPayload;
+
+    emailList.add(email);
+  }
+
+  @Override
+  boolean matches(@NonNull UserRecord userRecord) {
+    return email.equals(userRecord.getEmail());
+  }
+}

src/main/java/com/google/firebase/auth/FirebaseAuth.java

@@ -42,8 +42,11 @@
 import com.google.firebase.internal.Nullable;
 
 import java.io.IOException;
+import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
@@ -600,6 +603,81 @@ protected UserRecord execute() throws FirebaseAuthException {
     };
   }
 
+  /**
+   * Gets the user data corresponding to the specified identifiers.
+   *
+   * <p>There are no ordering guarantees; in particular, the nth entry in the users result list is
+   * not guaranteed to correspond to the nth entry in the input parameters list.
+   *
+   * <p>Only a maximum of 100 identifiers may be supplied. If more than 100 identifiers are
+   * supplied, this method will immediately throw an IllegalArgumentException.
+   *
+   * @param identifiers The identifiers used to indicate which user records should be returned. Must
+   *     have 100 or fewer entries.
+   * @return The corresponding user records.
+   * @throws IllegalArgumentException If any of the identifiers are invalid or if more than 100
+   *     identifiers are specified.
+   * @throws NullPointerException If the identifiers parameter is null.
+   * @throws FirebaseAuthException If an error occurs while retrieving user data.
+   */
+  public GetUsersResult getUsers(@NonNull Collection<UserIdentifier> identifiers)
+      throws FirebaseAuthException {
+    return getUsersOp(identifiers).call();
+  }
+
+  /**
+   * Gets the user data corresponding to the specified identifiers.
+   *
+   * <p>There are no ordering guarantees; in particular, the nth entry in the users result list is
+   * not guaranteed to correspond to the nth entry in the input parameters list.
+   *
+   * <p>Only a maximum of 100 identifiers may be supplied. If more than 100 identifiers are
+   * supplied, this method will immediately throw an IllegalArgumentException.
+   *
+   * @param identifiers The identifiers used to indicate which user records should be returned.
+   *     Must have 100 or fewer entries.
+   * @return An {@code ApiFuture} that resolves to the corresponding user records.
+   * @throws IllegalArgumentException If any of the identifiers are invalid or if more than 100
+   *     identifiers are specified.
+   * @throws NullPointerException If the identifiers parameter is null.
+   */
+  public ApiFuture<GetUsersResult> getUsersAsync(@NonNull Collection<UserIdentifier> identifiers) {
+    return getUsersOp(identifiers).callAsync(firebaseApp);
+  }
+
+  private CallableOperation<GetUsersResult, FirebaseAuthException> getUsersOp(
+      @NonNull final Collection<UserIdentifier> identifiers) {
+    checkNotDestroyed();
+    checkNotNull(identifiers, "identifiers must not be null");
+    checkArgument(identifiers.size() <= FirebaseUserManager.MAX_GET_ACCOUNTS_BATCH_SIZE,
+        "identifiers parameter must have <= " + FirebaseUserManager.MAX_GET_ACCOUNTS_BATCH_SIZE
+        + " entries.");
+
+    final FirebaseUserManager userManager = getUserManager();
+    return new CallableOperation<GetUsersResult, FirebaseAuthException>() {
+      @Override
+      protected GetUsersResult execute() throws FirebaseAuthException {
+        Set<UserRecord> users = userManager.getAccountInfo(identifiers);
+        Set<UserIdentifier> notFound = new HashSet<>();
+        for (UserIdentifier id : identifiers) {
+          if (!isUserFound(id, users)) {
+            notFound.add(id);
+          }
+        }
+        return new GetUsersResult(users, notFound);
+      }
+    };
+  }
+
+  private boolean isUserFound(UserIdentifier id, Collection<UserRecord> userRecords) {
+    for (UserRecord userRecord : userRecords) {
+      if (id.matches(userRecord)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Gets a page of users starting from the specified {@code pageToken}. Page size will be
    * limited to 1000 users.

src/main/java/com/google/firebase/auth/FirebaseUserManager.java

@@ -50,8 +50,12 @@
 import com.google.firebase.internal.SdkUtils;
 
 import java.io.IOException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * FirebaseUserManager provides methods for interacting with the Google Identity Toolkit via its
@@ -86,6 +90,7 @@ class FirebaseUserManager {
       .put("INVALID_DYNAMIC_LINK_DOMAIN", "invalid-dynamic-link-domain")
       .build();
 
+  static final int MAX_GET_ACCOUNTS_BATCH_SIZE = 100;
   static final int MAX_LIST_USERS_RESULTS = 1000;
   static final int MAX_IMPORT_USERS = 1000;
 
@@ -171,6 +176,37 @@ UserRecord getUserByPhoneNumber(String phoneNumber) throws FirebaseAuthException
     return new UserRecord(response.getUsers().get(0), jsonFactory);
   }
 
+  /**
+   * @pre identifiers != null
+   * @pre identifiers.size() <= MAX_GET_ACCOUNTS_BATCH_SIZE
+   */
+  Set<UserRecord> getAccountInfo(@NonNull Collection<UserIdentifier> identifiers)
+      throws FirebaseAuthException {
+    if (identifiers.isEmpty()) {
+      return new HashSet<UserRecord>();
+    }
+
+    Map<String, Object> payload = new HashMap<>();
+    for (UserIdentifier id : identifiers) {
+      id.populate(payload);
+    }
+
+    GetAccountInfoResponse response = post(
+        "/accounts:lookup", payload, GetAccountInfoResponse.class);
+
+    if (response == null) {
+      throw new FirebaseAuthException(INTERNAL_ERROR, "Failed to parse server response");
+    }
+
+    Set<UserRecord> results = new HashSet<>();
+    if (response.getUsers() != null) {
+      for (GetAccountInfoResponse.User user : response.getUsers()) {
+        results.add(new UserRecord(user, jsonFactory));
+      }
+    }
+    return results;
+  }
+
   String createUser(CreateRequest request) throws FirebaseAuthException {
     GenericJson response = post(
         "/accounts", request.getProperties(), GenericJson.class);

src/main/java/com/google/firebase/auth/GetUsersResult.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2020 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.firebase.auth;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.firebase.internal.NonNull;
+import java.util.Set;
+
+/**
+ * Represents the result of the {@link FirebaseAuth#getUsersAsync(Collection)} API.
+ */
+public final class GetUsersResult {
+  private Set<UserRecord> users;
+  private Set<UserIdentifier> notFound;
+
+  GetUsersResult(@NonNull Set<UserRecord> users, @NonNull Set<UserIdentifier> notFound) {
+    this.users = checkNotNull(users);
+    this.notFound = checkNotNull(notFound);
+  }
+
+  /**
+   * Set of user records, corresponding to the set of users that were requested. Only users
+   * that were found are listed here. The result set is unordered.
+   */
+  @NonNull
+  public Set<UserRecord> getUsers() {
+    return this.users;
+  }
+
+  /**
+   * Set of identifiers that were requested, but not found.
+   */
+  @NonNull
+  Set<UserIdentifier> getNotFound() {
+    return this.notFound;
+  }
+}

src/main/java/com/google/firebase/auth/PhoneIdentifier.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2020 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.firebase.auth;
+
+import com.google.firebase.internal.NonNull;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Used for looking up an account by phone number.
+ *
+ * @see {FirebaseAuth#getUsers}
+ */
+public class PhoneIdentifier extends UserIdentifier {
+  private static final String PHONE_NUMBER_KEY = "phoneNumber";
+  private final String phoneNumber;
+
+  public PhoneIdentifier(@NonNull String phoneNumber) {
+    UserRecord.checkPhoneNumber(phoneNumber);
+    this.phoneNumber = phoneNumber;
+  }
+
+  @Override
+  public String toString() {
+    return "PhoneIdentifier(" + phoneNumber + ")";
+  }
+
+  @Override
+  void populate(@NonNull Map<String, Object> payload) {
+    if (!payload.containsKey(PHONE_NUMBER_KEY)) {
+      payload.put(PHONE_NUMBER_KEY, new ArrayList<String>());
+    }
+    Object phoneNumberPayload = payload.get(PHONE_NUMBER_KEY);
+
+    @SuppressWarnings("unchecked")
+    List<String> phoneNumberList = (List<String>)phoneNumberPayload;
+
+    phoneNumberList.add(phoneNumber);
+  }
+
+  @Override
+  boolean matches(@NonNull UserRecord userRecord) {
+    return phoneNumber.equals(userRecord.getPhoneNumber());
+  }
+}

src/main/java/com/google/firebase/auth/ProviderIdentifier.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2020 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.firebase.auth;
+
+import com.google.firebase.internal.NonNull;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Used for looking up an account by phone number.
+ *
+ * @see {FirebaseAuth#getUsers}
+ */
+public class ProviderIdentifier extends UserIdentifier {
+  private static final String FEDERATED_USER_ID_KEY = "federatedUserId";
+  private final String providerId;
+  private final String providerUid;
+
+  public ProviderIdentifier(@NonNull String providerId, @NonNull String providerUid) {
+    UserRecord.checkProvider(providerId, providerUid);
+    this.providerId = providerId;
+    this.providerUid = providerUid;
+  }
+
+  @Override
+  public String toString() {
+    return "ProviderIdentifier(" + providerId + ", " + providerUid + ")";
+  }
+
+  @Override
+  void populate(@NonNull Map<String, Object> payload) {
+    if (!payload.containsKey(FEDERATED_USER_ID_KEY)) {
+      payload.put(FEDERATED_USER_ID_KEY, new HashMap<String, Object>());
+    }
+    Object federatedUserIdPayload = payload.get(FEDERATED_USER_ID_KEY);
+
+    @SuppressWarnings("unchecked")
+    Map<String, Object> federatedUserIdMap = (Map<String, Object>)federatedUserIdPayload;
+
+    federatedUserIdMap.put("providerId", providerId);
+    federatedUserIdMap.put("rawId", providerUid);
+  }
+
+  @Override
+  boolean matches(@NonNull UserRecord userRecord) {
+    for (UserInfo userInfo : userRecord.getProviderData()) {
+      if (providerId.equals(userInfo.getProviderId()) && providerUid.equals(userInfo.getUid())) {
+        return true;
+      }
+    }
+    return false;
+  }
+}