846 lines
32 KiB
Python
846 lines
32 KiB
Python
# Copyright 2017 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.
|
|
|
|
"""Firebase user management sub module."""
|
|
|
|
import base64
|
|
from collections import defaultdict
|
|
import json
|
|
from urllib import parse
|
|
|
|
import requests
|
|
|
|
from firebase_admin import _auth_utils
|
|
from firebase_admin import _rfc3339
|
|
from firebase_admin import _user_identifier
|
|
from firebase_admin import _user_import
|
|
from firebase_admin._user_import import ErrorInfo
|
|
|
|
|
|
MAX_LIST_USERS_RESULTS = 1000
|
|
MAX_IMPORT_USERS_SIZE = 1000
|
|
B64_REDACTED = base64.b64encode(b'REDACTED')
|
|
|
|
|
|
class Sentinel:
|
|
|
|
def __init__(self, description):
|
|
self.description = description
|
|
|
|
|
|
DELETE_ATTRIBUTE = Sentinel('Value used to delete an attribute from a user profile')
|
|
|
|
|
|
class UserMetadata:
|
|
"""Contains additional metadata associated with a user account."""
|
|
|
|
def __init__(self, creation_timestamp=None, last_sign_in_timestamp=None,
|
|
last_refresh_timestamp=None):
|
|
self._creation_timestamp = _auth_utils.validate_timestamp(
|
|
creation_timestamp, 'creation_timestamp')
|
|
self._last_sign_in_timestamp = _auth_utils.validate_timestamp(
|
|
last_sign_in_timestamp, 'last_sign_in_timestamp')
|
|
self._last_refresh_timestamp = _auth_utils.validate_timestamp(
|
|
last_refresh_timestamp, 'last_refresh_timestamp')
|
|
|
|
@property
|
|
def creation_timestamp(self):
|
|
""" Creation timestamp in milliseconds since the epoch.
|
|
|
|
Returns:
|
|
integer: The user creation timestamp in milliseconds since the epoch.
|
|
"""
|
|
return self._creation_timestamp
|
|
|
|
@property
|
|
def last_sign_in_timestamp(self):
|
|
""" Last sign in timestamp in milliseconds since the epoch.
|
|
|
|
Returns:
|
|
integer: The last sign in timestamp in milliseconds since the epoch.
|
|
"""
|
|
return self._last_sign_in_timestamp
|
|
|
|
@property
|
|
def last_refresh_timestamp(self):
|
|
"""The time at which the user was last active (ID token refreshed).
|
|
|
|
Returns:
|
|
integer: Milliseconds since epoch timestamp, or `None` if the user was
|
|
never active.
|
|
"""
|
|
return self._last_refresh_timestamp
|
|
|
|
|
|
class UserInfo:
|
|
"""A collection of standard profile information for a user.
|
|
|
|
Used to expose profile information returned by an identity provider.
|
|
"""
|
|
|
|
@property
|
|
def uid(self):
|
|
"""Returns the user ID of this user."""
|
|
raise NotImplementedError
|
|
|
|
@property
|
|
def display_name(self):
|
|
"""Returns the display name of this user."""
|
|
raise NotImplementedError
|
|
|
|
@property
|
|
def email(self):
|
|
"""Returns the email address associated with this user."""
|
|
raise NotImplementedError
|
|
|
|
@property
|
|
def phone_number(self):
|
|
"""Returns the phone number associated with this user."""
|
|
raise NotImplementedError
|
|
|
|
@property
|
|
def photo_url(self):
|
|
"""Returns the photo URL of this user."""
|
|
raise NotImplementedError
|
|
|
|
@property
|
|
def provider_id(self):
|
|
"""Returns the ID of the identity provider.
|
|
|
|
This can be a short domain name (e.g. google.com), or the identity of an OpenID
|
|
identity provider.
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
|
|
class UserRecord(UserInfo):
|
|
"""Contains metadata associated with a Firebase user account."""
|
|
|
|
def __init__(self, data):
|
|
super(UserRecord, self).__init__()
|
|
if not isinstance(data, dict):
|
|
raise ValueError('Invalid data argument: {0}. Must be a dictionary.'.format(data))
|
|
if not data.get('localId'):
|
|
raise ValueError('User ID must not be None or empty.')
|
|
self._data = data
|
|
|
|
@property
|
|
def uid(self):
|
|
"""Returns the user ID of this user.
|
|
|
|
Returns:
|
|
string: A user ID string. This value is never None or empty.
|
|
"""
|
|
return self._data.get('localId')
|
|
|
|
@property
|
|
def display_name(self):
|
|
"""Returns the display name of this user.
|
|
|
|
Returns:
|
|
string: A display name string or None.
|
|
"""
|
|
return self._data.get('displayName')
|
|
|
|
@property
|
|
def email(self):
|
|
"""Returns the email address associated with this user.
|
|
|
|
Returns:
|
|
string: An email address string or None.
|
|
"""
|
|
return self._data.get('email')
|
|
|
|
@property
|
|
def phone_number(self):
|
|
"""Returns the phone number associated with this user.
|
|
|
|
Returns:
|
|
string: A phone number string or None.
|
|
"""
|
|
return self._data.get('phoneNumber')
|
|
|
|
@property
|
|
def photo_url(self):
|
|
"""Returns the photo URL of this user.
|
|
|
|
Returns:
|
|
string: A URL string or None.
|
|
"""
|
|
return self._data.get('photoUrl')
|
|
|
|
@property
|
|
def provider_id(self):
|
|
"""Returns the provider ID of this user.
|
|
|
|
Returns:
|
|
string: A constant provider ID value.
|
|
"""
|
|
return 'firebase'
|
|
|
|
@property
|
|
def email_verified(self):
|
|
"""Returns whether the email address of this user has been verified.
|
|
|
|
Returns:
|
|
bool: True if the email has been verified, and False otherwise.
|
|
"""
|
|
return bool(self._data.get('emailVerified'))
|
|
|
|
@property
|
|
def disabled(self):
|
|
"""Returns whether this user account is disabled.
|
|
|
|
Returns:
|
|
bool: True if the user account is disabled, and False otherwise.
|
|
"""
|
|
return bool(self._data.get('disabled'))
|
|
|
|
@property
|
|
def tokens_valid_after_timestamp(self):
|
|
"""Returns the time, in milliseconds since the epoch, before which tokens are invalid.
|
|
|
|
Note: this is truncated to 1 second accuracy.
|
|
|
|
Returns:
|
|
int: Timestamp in milliseconds since the epoch, truncated to the second.
|
|
All tokens issued before that time are considered revoked.
|
|
"""
|
|
valid_since = self._data.get('validSince')
|
|
if valid_since is not None:
|
|
return 1000 * int(valid_since)
|
|
return 0
|
|
|
|
@property
|
|
def user_metadata(self):
|
|
"""Returns additional metadata associated with this user.
|
|
|
|
Returns:
|
|
UserMetadata: A UserMetadata instance. Does not return None.
|
|
"""
|
|
def _int_or_none(key):
|
|
if key in self._data:
|
|
return int(self._data[key])
|
|
return None
|
|
last_refresh_at_millis = None
|
|
last_refresh_at_rfc3339 = self._data.get('lastRefreshAt', None)
|
|
if last_refresh_at_rfc3339:
|
|
last_refresh_at_millis = int(_rfc3339.parse_to_epoch(last_refresh_at_rfc3339) * 1000)
|
|
return UserMetadata(
|
|
_int_or_none('createdAt'), _int_or_none('lastLoginAt'), last_refresh_at_millis)
|
|
|
|
@property
|
|
def provider_data(self):
|
|
"""Returns a list of UserInfo instances.
|
|
|
|
Each object represents an identity from an identity provider that is linked to this user.
|
|
|
|
Returns:
|
|
list: A list of UserInfo objects, which may be empty.
|
|
"""
|
|
providers = self._data.get('providerUserInfo', [])
|
|
return [ProviderUserInfo(entry) for entry in providers]
|
|
|
|
@property
|
|
def custom_claims(self):
|
|
"""Returns any custom claims set on this user account.
|
|
|
|
Returns:
|
|
dict: A dictionary of claims or None.
|
|
"""
|
|
claims = self._data.get('customAttributes')
|
|
if claims:
|
|
parsed = json.loads(claims)
|
|
if parsed != {}:
|
|
return parsed
|
|
return None
|
|
|
|
@property
|
|
def tenant_id(self):
|
|
"""Returns the tenant ID of this user.
|
|
|
|
Returns:
|
|
string: A tenant ID string or None.
|
|
"""
|
|
return self._data.get('tenantId')
|
|
|
|
|
|
class ExportedUserRecord(UserRecord):
|
|
"""Contains metadata associated with a user including password hash and salt."""
|
|
|
|
@property
|
|
def password_hash(self):
|
|
"""The user's password hash as a base64-encoded string.
|
|
|
|
If the Firebase Auth hashing algorithm (SCRYPT) was used to create the user account, this
|
|
is the base64-encoded password hash of the user. If a different hashing algorithm was
|
|
used to create this user, as is typical when migrating from another Auth system, this
|
|
is an empty string. If no password is set, or if the service account doesn't have permission
|
|
to read the password, then this is ``None``.
|
|
"""
|
|
password_hash = self._data.get('passwordHash')
|
|
|
|
# If the password hash is redacted (probably due to missing permissions) then clear it out,
|
|
# similar to how the salt is returned. (Otherwise, it *looks* like a b64-encoded hash is
|
|
# present, which is confusing.)
|
|
if password_hash == B64_REDACTED:
|
|
return None
|
|
return password_hash
|
|
|
|
@property
|
|
def password_salt(self):
|
|
"""The user's password salt as a base64-encoded string.
|
|
|
|
If the Firebase Auth hashing algorithm (SCRYPT) was used to create the user account, this
|
|
is the base64-encoded password salt of the user. If a different hashing algorithm was
|
|
used to create this user, as is typical when migrating from another Auth system, this is
|
|
an empty string. If no password is set, or if the service account doesn't have permission to
|
|
read the password, then this is ``None``.
|
|
"""
|
|
return self._data.get('salt')
|
|
|
|
|
|
class GetUsersResult:
|
|
"""Represents the result of the ``auth.get_users()`` API."""
|
|
|
|
def __init__(self, users, not_found):
|
|
"""Constructs a `GetUsersResult` object.
|
|
|
|
Args:
|
|
users: List of `UserRecord` instances.
|
|
not_found: List of `UserIdentifier` instances.
|
|
"""
|
|
self._users = users
|
|
self._not_found = not_found
|
|
|
|
@property
|
|
def users(self):
|
|
"""Set of `UserRecord` instances, corresponding to the set of users
|
|
that were requested. Only users that were found are listed here. The
|
|
result set is unordered.
|
|
"""
|
|
return self._users
|
|
|
|
@property
|
|
def not_found(self):
|
|
"""Set of `UserIdentifier` instances that were requested, but not
|
|
found.
|
|
"""
|
|
return self._not_found
|
|
|
|
|
|
class ListUsersPage:
|
|
"""Represents a page of user records exported from a Firebase project.
|
|
|
|
Provides methods for traversing the user accounts included in this page, as well as retrieving
|
|
subsequent pages of users. The iterator returned by ``iterate_all()`` can be used to iterate
|
|
through all users in the Firebase project starting from this page.
|
|
"""
|
|
|
|
def __init__(self, download, page_token, max_results):
|
|
self._download = download
|
|
self._max_results = max_results
|
|
self._current = download(page_token, max_results)
|
|
|
|
@property
|
|
def users(self):
|
|
"""A list of ``ExportedUserRecord`` instances available in this page."""
|
|
return [ExportedUserRecord(user) for user in self._current.get('users', [])]
|
|
|
|
@property
|
|
def next_page_token(self):
|
|
"""Page token string for the next page (empty string indicates no more pages)."""
|
|
return self._current.get('nextPageToken', '')
|
|
|
|
@property
|
|
def has_next_page(self):
|
|
"""A boolean indicating whether more pages are available."""
|
|
return bool(self.next_page_token)
|
|
|
|
def get_next_page(self):
|
|
"""Retrieves the next page of user accounts, if available.
|
|
|
|
Returns:
|
|
ListUsersPage: Next page of users, or None if this is the last page.
|
|
"""
|
|
if self.has_next_page:
|
|
return ListUsersPage(self._download, self.next_page_token, self._max_results)
|
|
return None
|
|
|
|
def iterate_all(self):
|
|
"""Retrieves an iterator for user accounts.
|
|
|
|
Returned iterator will iterate through all the user accounts in the Firebase project
|
|
starting from this page. The iterator will never buffer more than one page of users
|
|
in memory at a time.
|
|
|
|
Returns:
|
|
iterator: An iterator of ExportedUserRecord instances.
|
|
"""
|
|
return _UserIterator(self)
|
|
|
|
|
|
class DeleteUsersResult:
|
|
"""Represents the result of the ``auth.delete_users()`` API."""
|
|
|
|
def __init__(self, result, total):
|
|
"""Constructs a `DeleteUsersResult` object.
|
|
|
|
Args:
|
|
result: The proto response, wrapped in a
|
|
`BatchDeleteAccountsResponse` instance.
|
|
total: Total integer number of deletion attempts.
|
|
"""
|
|
errors = result.errors
|
|
self._success_count = total - len(errors)
|
|
self._failure_count = len(errors)
|
|
self._errors = errors
|
|
|
|
@property
|
|
def success_count(self):
|
|
"""Returns the number of users that were deleted successfully (possibly
|
|
zero).
|
|
|
|
Users that did not exist prior to calling `delete_users()` are
|
|
considered to be successfully deleted.
|
|
"""
|
|
return self._success_count
|
|
|
|
@property
|
|
def failure_count(self):
|
|
"""Returns the number of users that failed to be deleted (possibly
|
|
zero).
|
|
"""
|
|
return self._failure_count
|
|
|
|
@property
|
|
def errors(self):
|
|
"""A list of `auth.ErrorInfo` instances describing the errors that
|
|
were encountered during the deletion. Length of this list is equal to
|
|
`failure_count`.
|
|
"""
|
|
return self._errors
|
|
|
|
|
|
class BatchDeleteAccountsResponse:
|
|
"""Represents the results of a `delete_users()` call."""
|
|
|
|
def __init__(self, errors=None):
|
|
"""Constructs a `BatchDeleteAccountsResponse` instance, corresponding to
|
|
the JSON representing the `BatchDeleteAccountsResponse` proto.
|
|
|
|
Args:
|
|
errors: List of dictionaries, with each dictionary representing an
|
|
`ErrorInfo` instance as returned by the server. `None` implies
|
|
an empty list.
|
|
"""
|
|
self.errors = [ErrorInfo(err) for err in errors] if errors else []
|
|
|
|
|
|
class ProviderUserInfo(UserInfo):
|
|
"""Contains metadata regarding how a user is known by a particular identity provider."""
|
|
|
|
def __init__(self, data):
|
|
super(ProviderUserInfo, self).__init__()
|
|
if not isinstance(data, dict):
|
|
raise ValueError('Invalid data argument: {0}. Must be a dictionary.'.format(data))
|
|
if not data.get('rawId'):
|
|
raise ValueError('User ID must not be None or empty.')
|
|
self._data = data
|
|
|
|
@property
|
|
def uid(self):
|
|
return self._data.get('rawId')
|
|
|
|
@property
|
|
def display_name(self):
|
|
return self._data.get('displayName')
|
|
|
|
@property
|
|
def email(self):
|
|
return self._data.get('email')
|
|
|
|
@property
|
|
def phone_number(self):
|
|
return self._data.get('phoneNumber')
|
|
|
|
@property
|
|
def photo_url(self):
|
|
return self._data.get('photoUrl')
|
|
|
|
@property
|
|
def provider_id(self):
|
|
return self._data.get('providerId')
|
|
|
|
|
|
class ActionCodeSettings:
|
|
"""Contains required continue/state URL with optional Android and iOS settings.
|
|
Used when invoking the email action link generation APIs.
|
|
"""
|
|
|
|
def __init__(self, url, handle_code_in_app=None, dynamic_link_domain=None, ios_bundle_id=None,
|
|
android_package_name=None, android_install_app=None, android_minimum_version=None):
|
|
self.url = url
|
|
self.handle_code_in_app = handle_code_in_app
|
|
self.dynamic_link_domain = dynamic_link_domain
|
|
self.ios_bundle_id = ios_bundle_id
|
|
self.android_package_name = android_package_name
|
|
self.android_install_app = android_install_app
|
|
self.android_minimum_version = android_minimum_version
|
|
|
|
|
|
def encode_action_code_settings(settings):
|
|
""" Validates the provided action code settings for email link generation and
|
|
populates the REST api parameters.
|
|
|
|
settings - ``ActionCodeSettings`` object provided to be encoded
|
|
returns - dict of parameters to be passed for link gereration.
|
|
"""
|
|
|
|
parameters = {}
|
|
# url
|
|
if not settings.url:
|
|
raise ValueError("Dynamic action links url is mandatory")
|
|
|
|
try:
|
|
parsed = parse.urlparse(settings.url)
|
|
if not parsed.netloc:
|
|
raise ValueError('Malformed dynamic action links url: "{0}".'.format(settings.url))
|
|
parameters['continueUrl'] = settings.url
|
|
except Exception:
|
|
raise ValueError('Malformed dynamic action links url: "{0}".'.format(settings.url))
|
|
|
|
# handle_code_in_app
|
|
if settings.handle_code_in_app is not None:
|
|
if not isinstance(settings.handle_code_in_app, bool):
|
|
raise ValueError('Invalid value provided for handle_code_in_app: {0}'
|
|
.format(settings.handle_code_in_app))
|
|
parameters['canHandleCodeInApp'] = settings.handle_code_in_app
|
|
|
|
# dynamic_link_domain
|
|
if settings.dynamic_link_domain is not None:
|
|
if not isinstance(settings.dynamic_link_domain, str):
|
|
raise ValueError('Invalid value provided for dynamic_link_domain: {0}'
|
|
.format(settings.dynamic_link_domain))
|
|
parameters['dynamicLinkDomain'] = settings.dynamic_link_domain
|
|
|
|
# ios_bundle_id
|
|
if settings.ios_bundle_id is not None:
|
|
if not isinstance(settings.ios_bundle_id, str):
|
|
raise ValueError('Invalid value provided for ios_bundle_id: {0}'
|
|
.format(settings.ios_bundle_id))
|
|
parameters['iosBundleId'] = settings.ios_bundle_id
|
|
|
|
# android_* attributes
|
|
if (settings.android_minimum_version or settings.android_install_app) \
|
|
and not settings.android_package_name:
|
|
raise ValueError("Android package name is required when specifying other Android settings")
|
|
|
|
if settings.android_package_name is not None:
|
|
if not isinstance(settings.android_package_name, str):
|
|
raise ValueError('Invalid value provided for android_package_name: {0}'
|
|
.format(settings.android_package_name))
|
|
parameters['androidPackageName'] = settings.android_package_name
|
|
|
|
if settings.android_minimum_version is not None:
|
|
if not isinstance(settings.android_minimum_version, str):
|
|
raise ValueError('Invalid value provided for android_minimum_version: {0}'
|
|
.format(settings.android_minimum_version))
|
|
parameters['androidMinimumVersion'] = settings.android_minimum_version
|
|
|
|
if settings.android_install_app is not None:
|
|
if not isinstance(settings.android_install_app, bool):
|
|
raise ValueError('Invalid value provided for android_install_app: {0}'
|
|
.format(settings.android_install_app))
|
|
parameters['androidInstallApp'] = settings.android_install_app
|
|
|
|
return parameters
|
|
|
|
|
|
class UserManager:
|
|
"""Provides methods for interacting with the Google Identity Toolkit."""
|
|
|
|
ID_TOOLKIT_URL = 'https://identitytoolkit.googleapis.com/v1'
|
|
|
|
def __init__(self, http_client, project_id, tenant_id=None):
|
|
self.http_client = http_client
|
|
self.base_url = '{0}/projects/{1}'.format(self.ID_TOOLKIT_URL, project_id)
|
|
if tenant_id:
|
|
self.base_url += '/tenants/{0}'.format(tenant_id)
|
|
|
|
def get_user(self, **kwargs):
|
|
"""Gets the user data corresponding to the provided key."""
|
|
if 'uid' in kwargs:
|
|
key, key_type = kwargs.pop('uid'), 'user ID'
|
|
payload = {'localId' : [_auth_utils.validate_uid(key, required=True)]}
|
|
elif 'email' in kwargs:
|
|
key, key_type = kwargs.pop('email'), 'email'
|
|
payload = {'email' : [_auth_utils.validate_email(key, required=True)]}
|
|
elif 'phone_number' in kwargs:
|
|
key, key_type = kwargs.pop('phone_number'), 'phone number'
|
|
payload = {'phoneNumber' : [_auth_utils.validate_phone(key, required=True)]}
|
|
else:
|
|
raise TypeError('Unsupported keyword arguments: {0}.'.format(kwargs))
|
|
|
|
body, http_resp = self._make_request('post', '/accounts:lookup', json=payload)
|
|
if not body or not body.get('users'):
|
|
raise _auth_utils.UserNotFoundError(
|
|
'No user record found for the provided {0}: {1}.'.format(key_type, key),
|
|
http_response=http_resp)
|
|
return body['users'][0]
|
|
|
|
def get_users(self, identifiers):
|
|
"""Looks up multiple users by their identifiers (uid, email, etc.)
|
|
|
|
Args:
|
|
identifiers: UserIdentifier[]: The identifiers indicating the user
|
|
to be looked up. Must have <= 100 entries.
|
|
|
|
Returns:
|
|
list[dict[string, string]]: List of dicts representing the JSON
|
|
`UserInfo` responses from the server.
|
|
|
|
Raises:
|
|
ValueError: If any of the identifiers are invalid or if more than
|
|
100 identifiers are specified.
|
|
UnexpectedResponseError: If the backend server responds with an
|
|
unexpected message.
|
|
"""
|
|
if not identifiers:
|
|
return []
|
|
if len(identifiers) > 100:
|
|
raise ValueError('`identifiers` parameter must have <= 100 entries.')
|
|
|
|
payload = defaultdict(list)
|
|
for identifier in identifiers:
|
|
if isinstance(identifier, _user_identifier.UidIdentifier):
|
|
payload['localId'].append(identifier.uid)
|
|
elif isinstance(identifier, _user_identifier.EmailIdentifier):
|
|
payload['email'].append(identifier.email)
|
|
elif isinstance(identifier, _user_identifier.PhoneIdentifier):
|
|
payload['phoneNumber'].append(identifier.phone_number)
|
|
elif isinstance(identifier, _user_identifier.ProviderIdentifier):
|
|
payload['federatedUserId'].append({
|
|
'providerId': identifier.provider_id,
|
|
'rawId': identifier.provider_uid
|
|
})
|
|
else:
|
|
raise ValueError(
|
|
'Invalid entry in "identifiers" list. Unsupported type: {}'
|
|
.format(type(identifier)))
|
|
|
|
body, http_resp = self._make_request(
|
|
'post', '/accounts:lookup', json=payload)
|
|
if not http_resp.ok:
|
|
raise _auth_utils.UnexpectedResponseError(
|
|
'Failed to get users.', http_response=http_resp)
|
|
return body.get('users', [])
|
|
|
|
def list_users(self, page_token=None, max_results=MAX_LIST_USERS_RESULTS):
|
|
"""Retrieves a batch of users."""
|
|
if page_token is not None:
|
|
if not isinstance(page_token, str) or not page_token:
|
|
raise ValueError('Page token must be a non-empty string.')
|
|
if not isinstance(max_results, int):
|
|
raise ValueError('Max results must be an integer.')
|
|
if max_results < 1 or max_results > MAX_LIST_USERS_RESULTS:
|
|
raise ValueError(
|
|
'Max results must be a positive integer less than '
|
|
'{0}.'.format(MAX_LIST_USERS_RESULTS))
|
|
|
|
payload = {'maxResults': max_results}
|
|
if page_token:
|
|
payload['nextPageToken'] = page_token
|
|
body, _ = self._make_request('get', '/accounts:batchGet', params=payload)
|
|
return body
|
|
|
|
def create_user(self, uid=None, display_name=None, email=None, phone_number=None,
|
|
photo_url=None, password=None, disabled=None, email_verified=None):
|
|
"""Creates a new user account with the specified properties."""
|
|
payload = {
|
|
'localId': _auth_utils.validate_uid(uid),
|
|
'displayName': _auth_utils.validate_display_name(display_name),
|
|
'email': _auth_utils.validate_email(email),
|
|
'phoneNumber': _auth_utils.validate_phone(phone_number),
|
|
'photoUrl': _auth_utils.validate_photo_url(photo_url),
|
|
'password': _auth_utils.validate_password(password),
|
|
'emailVerified': bool(email_verified) if email_verified is not None else None,
|
|
'disabled': bool(disabled) if disabled is not None else None,
|
|
}
|
|
payload = {k: v for k, v in payload.items() if v is not None}
|
|
body, http_resp = self._make_request('post', '/accounts', json=payload)
|
|
if not body or not body.get('localId'):
|
|
raise _auth_utils.UnexpectedResponseError(
|
|
'Failed to create new user.', http_response=http_resp)
|
|
return body.get('localId')
|
|
|
|
def update_user(self, uid, display_name=None, email=None, phone_number=None,
|
|
photo_url=None, password=None, disabled=None, email_verified=None,
|
|
valid_since=None, custom_claims=None):
|
|
"""Updates an existing user account with the specified properties"""
|
|
payload = {
|
|
'localId': _auth_utils.validate_uid(uid, required=True),
|
|
'email': _auth_utils.validate_email(email),
|
|
'password': _auth_utils.validate_password(password),
|
|
'validSince': _auth_utils.validate_timestamp(valid_since, 'valid_since'),
|
|
'emailVerified': bool(email_verified) if email_verified is not None else None,
|
|
'disableUser': bool(disabled) if disabled is not None else None,
|
|
}
|
|
|
|
remove = []
|
|
if display_name is not None:
|
|
if display_name is DELETE_ATTRIBUTE:
|
|
remove.append('DISPLAY_NAME')
|
|
else:
|
|
payload['displayName'] = _auth_utils.validate_display_name(display_name)
|
|
if photo_url is not None:
|
|
if photo_url is DELETE_ATTRIBUTE:
|
|
remove.append('PHOTO_URL')
|
|
else:
|
|
payload['photoUrl'] = _auth_utils.validate_photo_url(photo_url)
|
|
if remove:
|
|
payload['deleteAttribute'] = remove
|
|
|
|
if phone_number is not None:
|
|
if phone_number is DELETE_ATTRIBUTE:
|
|
payload['deleteProvider'] = ['phone']
|
|
else:
|
|
payload['phoneNumber'] = _auth_utils.validate_phone(phone_number)
|
|
|
|
if custom_claims is not None:
|
|
if custom_claims is DELETE_ATTRIBUTE:
|
|
custom_claims = {}
|
|
json_claims = json.dumps(custom_claims) if isinstance(
|
|
custom_claims, dict) else custom_claims
|
|
payload['customAttributes'] = _auth_utils.validate_custom_claims(json_claims)
|
|
|
|
payload = {k: v for k, v in payload.items() if v is not None}
|
|
body, http_resp = self._make_request('post', '/accounts:update', json=payload)
|
|
if not body or not body.get('localId'):
|
|
raise _auth_utils.UnexpectedResponseError(
|
|
'Failed to update user: {0}.'.format(uid), http_response=http_resp)
|
|
return body.get('localId')
|
|
|
|
def delete_user(self, uid):
|
|
"""Deletes the user identified by the specified user ID."""
|
|
_auth_utils.validate_uid(uid, required=True)
|
|
body, http_resp = self._make_request('post', '/accounts:delete', json={'localId' : uid})
|
|
if not body or not body.get('kind'):
|
|
raise _auth_utils.UnexpectedResponseError(
|
|
'Failed to delete user: {0}.'.format(uid), http_response=http_resp)
|
|
|
|
def delete_users(self, uids, force_delete=False):
|
|
"""Deletes the users identified by the specified user ids.
|
|
|
|
Args:
|
|
uids: A list of strings indicating the uids of the users to be deleted.
|
|
Must have <= 1000 entries.
|
|
force_delete: Optional parameter that indicates if users should be
|
|
deleted, even if they're not disabled. Defaults to False.
|
|
|
|
|
|
Returns:
|
|
BatchDeleteAccountsResponse: Server's proto response, wrapped in a
|
|
python object.
|
|
|
|
Raises:
|
|
ValueError: If any of the identifiers are invalid or if more than 1000
|
|
identifiers are specified.
|
|
UnexpectedResponseError: If the backend server responds with an
|
|
unexpected message.
|
|
"""
|
|
if not uids:
|
|
return BatchDeleteAccountsResponse()
|
|
|
|
if len(uids) > 1000:
|
|
raise ValueError("`uids` paramter must have <= 1000 entries.")
|
|
for uid in uids:
|
|
_auth_utils.validate_uid(uid, required=True)
|
|
|
|
body, http_resp = self._make_request('post', '/accounts:batchDelete',
|
|
json={'localIds': uids, 'force': force_delete})
|
|
if not isinstance(body, dict):
|
|
raise _auth_utils.UnexpectedResponseError(
|
|
'Unexpected response from server while attempting to delete users.',
|
|
http_response=http_resp)
|
|
return BatchDeleteAccountsResponse(body.get('errors', []))
|
|
|
|
def import_users(self, users, hash_alg=None):
|
|
"""Imports the given list of users to Firebase Auth."""
|
|
try:
|
|
if not users or len(users) > MAX_IMPORT_USERS_SIZE:
|
|
raise ValueError(
|
|
'Users must be a non-empty list with no more than {0} elements.'.format(
|
|
MAX_IMPORT_USERS_SIZE))
|
|
if any([not isinstance(u, _user_import.ImportUserRecord) for u in users]):
|
|
raise ValueError('One or more user objects are invalid.')
|
|
except TypeError:
|
|
raise ValueError('users must be iterable')
|
|
|
|
payload = {'users': [u.to_dict() for u in users]}
|
|
if any(['passwordHash' in u for u in payload['users']]):
|
|
if not isinstance(hash_alg, _user_import.UserImportHash):
|
|
raise ValueError('A UserImportHash is required to import users with passwords.')
|
|
payload.update(hash_alg.to_dict())
|
|
body, http_resp = self._make_request('post', '/accounts:batchCreate', json=payload)
|
|
if not isinstance(body, dict):
|
|
raise _auth_utils.UnexpectedResponseError(
|
|
'Failed to import users.', http_response=http_resp)
|
|
return body
|
|
|
|
def generate_email_action_link(self, action_type, email, action_code_settings=None):
|
|
"""Fetches the email action links for types
|
|
|
|
Args:
|
|
action_type: String. Valid values ['VERIFY_EMAIL', 'EMAIL_SIGNIN', 'PASSWORD_RESET']
|
|
email: Email of the user for which the action is performed
|
|
action_code_settings: ``ActionCodeSettings`` object or dict (optional). Defines whether
|
|
the link is to be handled by a mobile app and the additional state information to be
|
|
passed in the deep link, etc.
|
|
Returns:
|
|
link_url: action url to be emailed to the user
|
|
|
|
Raises:
|
|
UnexpectedResponseError: If the backend server responds with an unexpected message
|
|
FirebaseError: If an error occurs while generating the link
|
|
ValueError: If the provided arguments are invalid
|
|
"""
|
|
payload = {
|
|
'requestType': _auth_utils.validate_action_type(action_type),
|
|
'email': _auth_utils.validate_email(email),
|
|
'returnOobLink': True
|
|
}
|
|
|
|
if action_code_settings:
|
|
payload.update(encode_action_code_settings(action_code_settings))
|
|
|
|
body, http_resp = self._make_request('post', '/accounts:sendOobCode', json=payload)
|
|
if not body or not body.get('oobLink'):
|
|
raise _auth_utils.UnexpectedResponseError(
|
|
'Failed to generate email action link.', http_response=http_resp)
|
|
return body.get('oobLink')
|
|
|
|
def _make_request(self, method, path, **kwargs):
|
|
url = '{0}{1}'.format(self.base_url, path)
|
|
try:
|
|
return self.http_client.body_and_response(method, url, **kwargs)
|
|
except requests.exceptions.RequestException as error:
|
|
raise _auth_utils.handle_auth_backend_error(error)
|
|
|
|
|
|
class _UserIterator(_auth_utils.PageIterator):
|
|
|
|
@property
|
|
def items(self):
|
|
return self._current_page.users
|