[Bug 1963773][Harmony] login-names separate from email addresses

Bugzilla/Auth.pm

@@ -182,6 +182,10 @@ sub extern_id_used {
     || $self->{_verifier}->extern_id_used;
 }
 
+sub can_change_login {
+  return $_[0]->user_can_create_account;  
+}
+
 sub can_change_email {
   return $_[0]->user_can_create_account;
 }
@@ -474,6 +478,14 @@ Returns:     C<true> if users are allowed to create new Bugzilla accounts,
 
 Description: Whether or not current login system uses extern_id.
 
+=item C<can_change_login>
+
+Description: Whether or not the current login system allows users to
+             change their own login.
+Params:      None
+Returns:     C<true> if users can change their own login,
+             C<false> otherwise.
+
 =item C<can_change_email>
 
 Description: Whether or not the current login system allows users to

Bugzilla/Auth/Verify.pm

@@ -36,15 +36,16 @@ sub create_or_update_user {
   my $dbh = Bugzilla->dbh;
 
   my $extern_id = $params->{extern_id};
-  my $username  = $params->{bz_username} || $params->{username};
+  my $login     = $params->{bz_username} || $params->{username};
+  my $email     = $params->{email};
   my $password  = $params->{password} || '*';
   my $real_name = $params->{realname} || '';
   my $user_id   = $params->{user_id};
 
   # A passed-in user_id always overrides anything else, for determining
   # what account we should return.
   if (!$user_id) {
-    my $username_user_id = login_to_id($username || '');
+    my $login_user_id = login_to_id($login || '');
     my $extern_user_id;
     if ($extern_id) {
       $extern_user_id = $dbh->selectrow_array(
@@ -55,51 +56,52 @@ sub create_or_update_user {
 
     # If we have both a valid extern_id and a valid username, and they are
     # not the same id, then we have a conflict.
-    if ( $username_user_id
+    if ( $login_user_id
       && $extern_user_id
-      && $username_user_id ne $extern_user_id)
+      && $login_user_id ne $extern_user_id)
     {
       my $extern_name = Bugzilla::User->new($extern_user_id)->login;
       return {
         failure => AUTH_ERROR,
         error   => "extern_id_conflict",
         details =>
-          {extern_id => $extern_id, extern_user => $extern_name, username => $username}
+          {extern_id => $extern_id, extern_user => $extern_name, username => $login}
       };
     }
 
     # If we have a valid username, but no valid id,
     # then we have to create the user. This happens when we're
     # passed only a username, and that username doesn't exist already.
-    if ($username && !$username_user_id && !$extern_user_id) {
-      validate_email_syntax($username) || return {
+    if ($login && !$login_user_id && !$extern_user_id) {
+      validate_email_syntax($email) || return {
         failure => AUTH_ERROR,
         error   => 'auth_invalid_email',
-        details => {addr => $username}
+        details => {addr => $login}
       };
 
       # external authentication
       # systems might follow different standards than ours. So in this
 
       # XXX Theoretically this could fail with an error, but the fix for
       # that is too involved to be done right now.
-      my $user
-        = Bugzilla::User->create({
-        login_name => $username, cryptpassword => $password, realname => $real_name
-        });
-      $username_user_id = $user->id;
+      my $user = Bugzilla::User->create({
+        login_name    => $login,
+        email         => $email,	
+	cryptpassword => $password, 
+	realname      => $real_name});
+      $login_user_id = $user->id;
     }
 
     # If we have a valid username id and an extern_id, but no valid
     # extern_user_id, then we have to set the user's extern_id.
-    if ($extern_id && $username_user_id && !$extern_user_id) {
+    if ($extern_id && $login_user_id && !$extern_user_id) {
       $dbh->do('UPDATE profiles SET extern_id = ? WHERE userid = ?',
-        undef, $extern_id, $username_user_id);
-      Bugzilla->memcached->clear({table => 'profiles', id => $username_user_id});
+        undef, $extern_id, $login_user_id);
+      Bugzilla->memcached->clear({table => 'profiles', id => $login_user_id});
     }
 
     # Finally, at this point, one of these will give us a valid user id.
-    $user_id = $extern_user_id || $username_user_id;
+    $user_id = $extern_user_id || $login_user_id;
   }
 
   # If we still don't have a valid user_id, then we weren't passed
@@ -117,13 +119,13 @@ sub create_or_update_user {
   # Now that we have a valid User, we need to see if any data has to be
   # updated.
   my $user_updated = 0;
-  if ($username && lc($user->login) ne lc($username)) {
-    validate_email_syntax($username) || return {
+  if ($email && lc($user->email) ne lc($email)) {
+    validate_email_syntax($email) || return {
       failure => AUTH_ERROR,
       error   => 'auth_invalid_email',
-      details => {addr => $username}
+      details => {addr => $email}
     };
-    $user->set_login($username);
+    $user->set_email($email);
     $user_updated = 1;
   }
   if ($real_name && $user->name ne $real_name) {

Bugzilla/Config/Common.pm

@@ -79,7 +79,7 @@ sub check_regexp {
 sub check_email {
   my ($value) = @_;
   my ($address) = Email::Address::XS->parse($value);
-  if (!$address->is_valid) {
+  if (defined $address && !$address->is_valid) {
     return "must be a valid email address.";
   }
   return "";

Bugzilla/Constants.pm

@@ -166,6 +166,7 @@ use Memoize;
   MAX_SUDO_TOKEN_AGE
   MAX_LOGIN_ATTEMPTS
   LOGIN_LOCKOUT_INTERVAL
+  ACCOUNT_CHANGE_INTERVAL
   MAX_STS_AGE
 
   SAFE_PROTOCOLS
@@ -473,6 +474,10 @@ use constant MAX_LOGIN_ATTEMPTS => 5;
 # account is locked.
 use constant LOGIN_LOCKOUT_INTERVAL => 30;
 
+# The time in minutes a user must wait before they can request another email to
+# create a new account or change their password.
+use constant ACCOUNT_CHANGE_INTERVAL => 10;
+
 # The maximum number of seconds the Strict-Transport-Security header
 # will remain valid. BMO uses one year.
 use constant MAX_STS_AGE => 31536000;

Bugzilla/DB/Schema.pm

@@ -1016,6 +1016,24 @@ use constant ABSTRACT_SCHEMA => {
     ],
   },
 
+  profiles_emails => {
+    FIELDS => [
+      id            => {TYPE => 'MEDIUMSERIAL', NOTNULL => 1, PRIMARYKEY => 1},
+      user_id       => {
+        TYPE             => 'INT3',
+        NOTNULL          => 1,
+        REFERENCES       => {TABLE => 'profiles', COLUMN => 'userid', DELETE => 'CASCADE'}
+      },
+      email            => {TYPE => 'varchar(255)', NOTNULL => 1},
+      is_primary_email => {TYPE => 'BOOLEAN', NOTNULL => 1, DEFAULT => 'FALSE'},
+      display_order    => {TYPE => 'INT1', NOTNULL => 1, DEFAULT => 1},
+    ],
+    INDEXES => [
+      profiles_emails_userid_idx => ['user_id'],
+      profiles_emails_email_idx  => {FIELDS => ['email'], TYPE => 'UNIQUE'},
+    ],
+  },
+
   profile_mfa => {
     FIELDS => [
       id      => {TYPE => 'INTSERIAL', NOTNULL => 1, PRIMARYKEY => 1},

Bugzilla/Install.pm

@@ -26,10 +26,12 @@ use Bugzilla::Error;
 use Bugzilla::Group;
 use Bugzilla::Product;
 use Bugzilla::User;
+use Bugzilla::User::Email;
 use Bugzilla::User::Setting;
 use Bugzilla::Util qw(get_text);
 use Bugzilla::Version;
 
+
 use constant STATUS_WORKFLOW => (
   [undef,         'UNCONFIRMED'],
   [undef,         'CONFIRMED'],
@@ -420,16 +422,17 @@ sub create_admin {
   return if $admin_count;
 
   my %answer    = %{Bugzilla->installation_answers};
-  my $login     = $answer{'ADMIN_EMAIL'};
+  my $login     = $answer{'ADMIN_LOGIN_NAME'};
+  my $email     = $answer{'ADMIN_EMAIL'};
   my $password  = $answer{'ADMIN_PASSWORD'};
   my $full_name = $answer{'ADMIN_REALNAME'};
 
-  if (!$login || !$password || !$full_name) {
+  if (!$login || !$email  || !$password || !$full_name) {
     print "\n" . get_text('install_admin_setup') . "\n\n";
   }
 
   while (!$login) {
-    print get_text('install_admin_get_email') . ' ';
+    print get_text('install_admin_get_login_name') . ' ';
     $login = <STDIN>;
     chomp $login;
     eval { Bugzilla::User->check_login_name_for_creation($login); };
@@ -439,6 +442,17 @@ sub create_admin {
     }
   }
 
+  while (!$email) {
+    print get_text('install_admin_get_email') . ' ';
+    $email = <STDIN>;
+    chomp $email;
+    eval { Bugzilla::User::Email->check_email_for_creation($email); };
+    if ($@) {
+      print $@ . "\n";
+      undef $email;
+    }
+  }
+
   while (!defined $full_name) {
     print get_text('install_admin_get_name') . ' ';
     $full_name = <STDIN>;
@@ -451,8 +465,9 @@ sub create_admin {
 
   my $admin
     = Bugzilla::User->create({
-    login_name => $login, realname => $full_name, cryptpassword => $password
+    login_name => $login, email => $email, realname => $full_name, cryptpassword => $password
     });
+
   make_admin($admin);
 }
 

Bugzilla/Install/DB.pm

@@ -817,7 +817,8 @@ sub update_table_definitions {
   $dbh->bz_alter_column('user_request_log', 'attach_id', {TYPE => 'INT5', NOTNULL => 0});
   _populate_attachment_storage_class();
 
-
+  # Bug 1963773 - [email protected]
+  _copy_valid_emails_to_profiles_emails(); 
   ################################################################
   # New --TABLE-- changes should go *** A B O V E *** this point #
   ################################################################
@@ -4393,6 +4394,64 @@ sub _populate_attachment_storage_class {
   }
 }
 
+sub _copy_valid_emails_to_profiles_emails {
+    my $dbh = Bugzilla->dbh;
+
+    my ($total) = $dbh->selectrow_array("SELECT COUNT(*) FROM profiles");
+    unless ($total) {
+        print "Skipping profiles_emails population: no profiles to process.\n";
+        return;
+    }
+
+    # Check if 'email' column exists in 'profiles'
+    my $columns = $dbh->selectcol_arrayref(
+        "SHOW COLUMNS FROM profiles LIKE 'email'"
+    );
+    my $has_email_column = scalar(@$columns) > 0;
+
+    # Build SELECT statement dynamically
+    my $select_sql = 'SELECT userid, login_name';
+    $select_sql .= ', email' if $has_email_column;
+    $select_sql .= ' FROM profiles';
+
+    my $select_sth = $dbh->prepare($select_sql);
+    my $check_sth  = $dbh->prepare('SELECT 1 FROM profiles_emails WHERE user_id = ?');
+    my $insert_sth = $dbh->prepare('
+        INSERT INTO profiles_emails (user_id, email, is_primary_email, display_order)
+        VALUES (?, ?, 1, 1)
+    ');
+
+    $select_sth->execute();
+
+    while (my $row = $select_sth->fetchrow_hashref) {
+        my $user_id = $row->{userid};
+
+        # Skip if the user already has an entry
+        $check_sth->execute($user_id);
+        next if $check_sth->fetchrow_array;
+
+        my $email = $has_email_column ? $row->{email} : undef;
+        my $login = $row->{login_name};
+
+        my $valid_email;
+        if (defined $email && $email ne '' && validate_email_syntax($email)) {
+            $valid_email = $email;
+        } elsif (defined $login && $login ne '' && validate_email_syntax($login)) {
+            $valid_email = $login;
+        }
+
+        next unless defined $valid_email;
+
+        eval {
+            $insert_sth->execute($user_id, $valid_email);
+        };
+        warn "Failed to insert email for user $user_id: $@" if $@;
+    }
+
+    $select_sth->finish;
+    $check_sth->finish;
+    $insert_sth->finish;
+}
 
 1;