snapshot of https://github.com/zulip/zulip.git @ 48c69911c7dd4e03b20552eb3bd77ad8151c1357 (2026-09-15)

zerver/lib/create_user.py

@@ -0,0 +1,244 @@
+import re
+from datetime import datetime
+from email.headerregistry import Address
+
+from django.contrib.auth.models import UserManager
+from django.utils.timezone import now as timezone_now
+
+from zerver.lib.i18n import get_default_language_for_new_user
+from zerver.lib.onboarding_steps import copy_onboarding_steps
+from zerver.lib.timezone import canonicalize_timezone
+from zerver.lib.upload import copy_avatar
+from zerver.models import Realm, RealmUserDefault, Stream, UserBaseSettings, UserProfile
+from zerver.models.realms import get_fake_email_domain
+
+
+def copy_default_settings(
+    settings_source: UserProfile | RealmUserDefault, target_profile: UserProfile
+) -> None:
+    # Important note: Code run from here to configure the user's
+    # settings should not send events, as that would cause clients
+    # to throw an exception (we haven't sent the realm_user/add event
+    # yet, so that event will include the updated details of target_profile).
+    #
+    # Note that this function will do at least one save() on target_profile.
+    for settings_name in UserBaseSettings.property_types:
+        if settings_name in ["default_language", "enable_login_emails"] and isinstance(
+            settings_source, RealmUserDefault
+        ):
+            continue
+
+        if settings_name == "email_address_visibility":
+            # For email_address_visibility, the value selected in registration form
+            # is preferred over the realm-level default value and value of source
+            # profile.
+            continue
+        value = getattr(settings_source, settings_name)
+        setattr(target_profile, settings_name, value)
+
+    if isinstance(settings_source, RealmUserDefault):
+        target_profile.save()
+        return
+
+    target_profile.full_name = settings_source.full_name
+    target_profile.timezone = canonicalize_timezone(settings_source.timezone)
+    target_profile.save()
+
+    if settings_source.avatar_source == UserProfile.AVATAR_FROM_USER:
+        from zerver.actions.user_settings import do_change_avatar_fields
+
+        copy_avatar(settings_source, target_profile)
+        do_change_avatar_fields(
+            target_profile,
+            UserProfile.AVATAR_FROM_USER,
+            skip_notify=True,
+            acting_user=target_profile,
+        )
+
+    copy_onboarding_steps(settings_source, target_profile)
+
+
+def get_dummy_email_address_for_display_regex(realm: Realm) -> str:
+    """
+    Returns a regex that matches the format of dummy email addresses we
+    generate for the .email of users with limit email_address_visibility.
+
+    The reason we need a regex is that we want something that we can use both
+    for generating the dummy email addresses and recognizing them together with extraction
+    of the user ID.
+    """
+
+    # We can't directly have (\d+) in the username passed to Address, because it gets
+    # mutated by the underlying logic for escaping special characters.
+    # So we use a trick by using $ as a placeholder which will be preserved, and then
+    # replace it with (\d+) to obtain our intended regex.
+    address_template = Address(username="user$", domain=get_fake_email_domain(realm.host)).addr_spec
+    regex = re.escape(address_template).replace(r"\$", r"(\d+)", 1)
+    return regex
+
+
+def get_display_email_address(user_profile: UserProfile) -> str:
+    if not user_profile.email_address_is_realm_public():
+        # The format of the dummy email address created here needs to stay consistent
+        # with get_dummy_email_address_for_display_regex.
+        return Address(
+            username=f"user{user_profile.id}", domain=get_fake_email_domain(user_profile.realm.host)
+        ).addr_spec
+    return user_profile.delivery_email
+
+
+# create_user_profile is based on Django's User.objects.create_user,
+# except that we don't save to the database so it can used in
+# bulk_creates
+#
+# Only use this for bulk_create -- for normal usage one should use
+# create_user (below) which will also make the Subscription and
+# Recipient objects
+def create_user_profile(
+    realm: Realm,
+    email: str,
+    password: str | None,
+    active: bool,
+    bot_type: int | None,
+    full_name: str,
+    bot_owner: UserProfile | None,
+    is_mirror_dummy: bool,
+    tos_version: str | None,
+    timezone: str,
+    default_language: str,
+    is_deleted: bool = False,
+    force_date_joined: datetime | None = None,
+    is_imported_stub: bool = False,
+    *,
+    email_address_visibility: int,
+) -> UserProfile:
+    if force_date_joined is None:
+        date_joined = timezone_now()
+    else:  # nocoverage
+        date_joined = force_date_joined
+
+    email = UserManager.normalize_email(email)
+
+    user_profile = UserProfile(
+        is_staff=False,
+        is_active=active,
+        full_name=full_name,
+        last_login=date_joined,
+        date_joined=date_joined,
+        realm=realm,
+        is_bot=bool(bot_type),
+        bot_type=bot_type,
+        bot_owner=bot_owner,
+        is_mirror_dummy=is_mirror_dummy,
+        is_deleted=is_deleted,
+        tos_version=tos_version,
+        timezone=timezone,
+        default_language=default_language,
+        delivery_email=email,
+        email_address_visibility=email_address_visibility,
+        is_imported_stub=is_imported_stub,
+    )
+    if bot_type or not active:
+        password = None
+    if user_profile.email_address_is_realm_public():
+        # If emails are visible to everyone, we can set this here and save a DB query
+        user_profile.email = get_display_email_address(user_profile)
+    user_profile.set_password(password)
+    return user_profile
+
+
+def create_user(
+    email: str,
+    password: str | None,
+    realm: Realm,
+    full_name: str,
+    active: bool = True,
+    role: int | None = None,
+    bot_type: int | None = None,
+    bot_owner: UserProfile | None = None,
+    tos_version: str | None = None,
+    timezone: str = "",
+    avatar_source: str | None = None,
+    is_mirror_dummy: bool = False,
+    is_deleted: bool = False,
+    default_language: str | None = None,
+    default_sending_stream: Stream | None = None,
+    default_events_register_stream: Stream | None = None,
+    default_all_public_streams: bool | None = None,
+    source_profile: UserProfile | None = None,
+    force_date_joined: datetime | None = None,
+    enable_marketing_emails: bool | None = None,
+    email_address_visibility: int | None = None,
+) -> UserProfile:
+    realm_user_default = RealmUserDefault.objects.get(realm=realm)
+    if bot_type is None:
+        if email_address_visibility is not None:
+            user_email_address_visibility = email_address_visibility
+        else:
+            user_email_address_visibility = realm_user_default.email_address_visibility
+    else:
+        # There is no privacy motivation for limiting access to bot email addresses,
+        # so we hardcode them to EMAIL_ADDRESS_VISIBILITY_EVERYONE.
+        user_email_address_visibility = UserProfile.EMAIL_ADDRESS_VISIBILITY_EVERYONE
+
+    # Users created via the API or LDAP/SAML syncing code paths will
+    # usually not have a default_language value, and should fall back
+    # to the realm default.
+    if default_language is None:
+        default_language = get_default_language_for_new_user(realm, request=None)
+
+    user_profile = create_user_profile(
+        realm,
+        email,
+        password,
+        active,
+        bot_type,
+        full_name,
+        bot_owner,
+        is_mirror_dummy,
+        tos_version,
+        timezone,
+        default_language,
+        is_deleted,
+        force_date_joined=force_date_joined,
+        email_address_visibility=user_email_address_visibility,
+    )
+    if avatar_source is None:
+        avatar_source = realm.default_avatar_source
+    user_profile.avatar_source = avatar_source
+    user_profile.timezone = timezone
+    user_profile.default_sending_stream = default_sending_stream
+    user_profile.default_events_register_stream = default_events_register_stream
+    if role is not None:
+        user_profile.role = role
+    # Allow the ORM default to be used if not provided
+    if default_all_public_streams is not None:
+        user_profile.default_all_public_streams = default_all_public_streams
+    # If a source profile was specified, we copy settings from that
+    # user.  Note that this is positioned in a way that overrides
+    # other arguments passed in, which is correct for most defaults
+    # like time zone where the source profile likely has a better value
+    # than the guess. As we decide on details like avatars and full
+    # names for this feature, we may want to move it.
+    if source_profile is not None:
+        # copy_default_settings saves the attribute values so a secondary
+        # save is not required.
+        copy_default_settings(source_profile, user_profile)
+    elif bot_type is None:
+        copy_default_settings(realm_user_default, user_profile)
+    else:
+        # This will be executed only for bots.
+        user_profile.save()
+
+    if bot_type is None and enable_marketing_emails is not None:
+        user_profile.enable_marketing_emails = enable_marketing_emails
+        user_profile.save(update_fields=["enable_marketing_emails"])
+
+    if not user_profile.email_address_is_realm_public():
+        # With restricted access to email addresses, we can't generate
+        # the fake email addresses we use for display purposes without
+        # a User ID, which isn't generated until the .save() above.
+        user_profile.email = get_display_email_address(user_profile)
+        user_profile.save(update_fields=["email"])
+
+    return user_profile