Disable database handle statement caching to fix Internal Server Errors
[WebKit-https.git] / Websites / bugs.webkit.org / Bugzilla / User.pm
1 # -*- Mode: perl; indent-tabs-mode: nil -*-
2 #
3 # The contents of this file are subject to the Mozilla Public
4 # License Version 1.1 (the "License"); you may not use this file
5 # except in compliance with the License. You may obtain a copy of
6 # the License at http://www.mozilla.org/MPL/
7 #
8 # Software distributed under the License is distributed on an "AS
9 # IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
10 # implied. See the License for the specific language governing
11 # rights and limitations under the License.
12 #
13 # The Original Code is the Bugzilla Bug Tracking System.
14 #
15 # The Initial Developer of the Original Code is Netscape Communications
16 # Corporation. Portions created by Netscape are
17 # Copyright (C) 1998 Netscape Communications Corporation. All
18 # Rights Reserved.
19 #
20 # Contributor(s): Myk Melez <myk@mozilla.org>
21 #                 Erik Stambaugh <erik@dasbistro.com>
22 #                 Bradley Baetz <bbaetz@acm.org>
23 #                 Joel Peshkin <bugreport@peshkin.net> 
24 #                 Byron Jones <bugzilla@glob.com.au>
25 #                 Shane H. W. Travis <travis@sedsystems.ca>
26 #                 Max Kanat-Alexander <mkanat@bugzilla.org>
27 #                 Gervase Markham <gerv@gerv.net>
28 #                 Lance Larsh <lance.larsh@oracle.com>
29 #                 Justin C. De Vries <judevries@novell.com>
30 #                 Dennis Melentyev <dennis.melentyev@infopulse.com.ua>
31 #                 Frédéric Buclin <LpSolit@gmail.com>
32 #                 Mads Bondo Dydensborg <mbd@dbc.dk>
33
34 ################################################################################
35 # Module Initialization
36 ################################################################################
37
38 # Make it harder for us to do dangerous things in Perl.
39 use strict;
40
41 # This module implements utilities for dealing with Bugzilla users.
42 package Bugzilla::User;
43
44 use Bugzilla::Error;
45 use Bugzilla::Util;
46 use Bugzilla::Constants;
47 use Bugzilla::Search::Recent;
48 use Bugzilla::User::Setting;
49 use Bugzilla::Product;
50 use Bugzilla::Classification;
51 use Bugzilla::Field;
52 use Bugzilla::Group;
53
54 use DateTime::TimeZone;
55 use List::Util qw(max);
56 use Scalar::Util qw(blessed);
57 use Storable qw(dclone);
58 use URI;
59 use URI::QueryParam;
60
61 use base qw(Bugzilla::Object Exporter);
62 @Bugzilla::User::EXPORT = qw(is_available_username
63     login_to_id user_id_to_login validate_password
64     USER_MATCH_MULTIPLE USER_MATCH_FAILED USER_MATCH_SUCCESS
65     MATCH_SKIP_CONFIRM
66 );
67
68 #####################################################################
69 # Constants
70 #####################################################################
71
72 use constant USER_MATCH_MULTIPLE => -1;
73 use constant USER_MATCH_FAILED   => 0;
74 use constant USER_MATCH_SUCCESS  => 1;
75
76 use constant MATCH_SKIP_CONFIRM  => 1;
77
78 use constant DEFAULT_USER => {
79     'userid'         => 0,
80     'realname'       => '',
81     'login_name'     => '',
82     'showmybugslink' => 0,
83     'disabledtext'   => '',
84     'disable_mail'   => 0,
85     'is_enabled'     => 1, 
86 };
87
88 use constant DB_TABLE => 'profiles';
89
90 # XXX Note that Bugzilla::User->name does not return the same thing
91 # that you passed in for "name" to new(). That's because historically
92 # Bugzilla::User used "name" for the realname field. This should be
93 # fixed one day.
94 use constant DB_COLUMNS => (
95     'profiles.userid',
96     'profiles.login_name',
97     'profiles.realname',
98     'profiles.mybugslink AS showmybugslink',
99     'profiles.disabledtext',
100     'profiles.disable_mail',
101     'profiles.extern_id',
102     'profiles.is_enabled', 
103 );
104 use constant NAME_FIELD => 'login_name';
105 use constant ID_FIELD   => 'userid';
106 use constant LIST_ORDER => NAME_FIELD;
107
108 use constant VALIDATORS => {
109     cryptpassword => \&_check_password,
110     disable_mail  => \&_check_disable_mail,
111     disabledtext  => \&_check_disabledtext,
112     login_name    => \&check_login_name_for_creation,
113     realname      => \&_check_realname,
114     extern_id     => \&_check_extern_id,
115     is_enabled    => \&_check_is_enabled, 
116 };
117
118 sub UPDATE_COLUMNS {
119     my $self = shift;
120     my @cols = qw(
121         disable_mail
122         disabledtext
123         login_name
124         realname
125         extern_id
126         is_enabled
127     );
128     push(@cols, 'cryptpassword') if exists $self->{cryptpassword};
129     return @cols;
130 };
131
132 use constant VALIDATOR_DEPENDENCIES => {
133     is_enabled => ['disabledtext'], 
134 };
135
136 use constant EXTRA_REQUIRED_FIELDS => qw(is_enabled);
137
138 ################################################################################
139 # Functions
140 ################################################################################
141
142 sub new {
143     my $invocant = shift;
144     my $class = ref($invocant) || $invocant;
145     my ($param) = @_;
146
147     my $user = DEFAULT_USER;
148     bless ($user, $class);
149     return $user unless $param;
150
151     if (ref($param) eq 'HASH') {
152         if (defined $param->{extern_id}) {
153             $param = { condition => 'extern_id = ?' , values => [$param->{extern_id}] };
154             $_[0] = $param;
155         }
156     }
157     return $class->SUPER::new(@_);
158 }
159
160 sub super_user {
161     my $invocant = shift;
162     my $class = ref($invocant) || $invocant;
163     my ($param) = @_;
164
165     my $user = dclone(DEFAULT_USER);
166     $user->{groups} = [Bugzilla::Group->get_all];
167     $user->{bless_groups} = [Bugzilla::Group->get_all];
168     bless $user, $class;
169     return $user;
170 }
171
172 sub update {
173     my $self = shift;
174     my $changes = $self->SUPER::update(@_);
175     my $dbh = Bugzilla->dbh;
176
177     if (exists $changes->{login_name}) {
178         # If we changed the login, silently delete any tokens.
179         $dbh->do('DELETE FROM tokens WHERE userid = ?', undef, $self->id);
180         # And rederive regex groups
181         $self->derive_regexp_groups();
182     }
183
184     # Logout the user if necessary.
185     Bugzilla->logout_user($self) 
186         if (exists $changes->{login_name} || exists $changes->{disabledtext}
187             || exists $changes->{cryptpassword});
188
189     # XXX Can update profiles_activity here as soon as it understands
190     #     field names like login_name.
191     
192     return $changes;
193 }
194
195 ################################################################################
196 # Validators
197 ################################################################################
198
199 sub _check_disable_mail { return $_[1] ? 1 : 0; }
200 sub _check_disabledtext { return trim($_[1]) || ''; }
201
202 # Check whether the extern_id is unique.
203 sub _check_extern_id {
204     my ($invocant, $extern_id) = @_;
205     $extern_id = trim($extern_id);
206     return undef unless defined($extern_id) && $extern_id ne "";
207     if (!ref($invocant) || $invocant->extern_id ne $extern_id) {
208         my $existing_login = $invocant->new({ extern_id => $extern_id });
209         if ($existing_login) {
210             ThrowUserError( 'extern_id_exists',
211                             { extern_id => $extern_id,
212                               existing_login_name => $existing_login->login });
213         }
214     }
215     return $extern_id;
216 }
217
218 # This is public since createaccount.cgi needs to use it before issuing
219 # a token for account creation.
220 sub check_login_name_for_creation {
221     my ($invocant, $name) = @_;
222     $name = trim($name);
223     $name || ThrowUserError('user_login_required');
224     validate_email_syntax($name)
225         || ThrowUserError('illegal_email_address', { addr => $name });
226
227     # Check the name if it's a new user, or if we're changing the name.
228     if (!ref($invocant) || $invocant->login ne $name) {
229         is_available_username($name) 
230             || ThrowUserError('account_exists', { email => $name });
231     }
232
233     return $name;
234 }
235
236 sub _check_password {
237     my ($self, $pass) = @_;
238
239     # If the password is '*', do not encrypt it or validate it further--we 
240     # are creating a user who should not be able to log in using DB 
241     # authentication.
242     return $pass if $pass eq '*';
243
244     validate_password($pass);
245     my $cryptpassword = bz_crypt($pass);
246     return $cryptpassword;
247 }
248
249 sub _check_realname { return trim($_[1]) || ''; }
250
251 sub _check_is_enabled {
252     my ($invocant, $is_enabled, undef, $params) = @_;
253     # is_enabled is set automatically on creation depending on whether 
254     # disabledtext is empty (enabled) or not empty (disabled).
255     # When updating the user, is_enabled is set by calling set_disabledtext().
256     # Any value passed into this validator is ignored.
257     my $disabledtext = ref($invocant) ? $invocant->disabledtext : $params->{disabledtext};
258     return $disabledtext ? 0 : 1;
259 }
260
261 ################################################################################
262 # Mutators
263 ################################################################################
264
265 sub set_disable_mail { $_[0]->set('disable_mail', $_[1]); }
266 sub set_extern_id    { $_[0]->set('extern_id', $_[1]); }
267
268 sub set_login {
269     my ($self, $login) = @_;
270     $self->set('login_name', $login);
271     delete $self->{identity};
272     delete $self->{nick};
273 }
274
275 sub set_name {
276     my ($self, $name) = @_;
277     $self->set('realname', $name);
278     delete $self->{identity};
279 }
280
281 sub set_password { $_[0]->set('cryptpassword', $_[1]); }
282
283 sub set_disabledtext {
284     $_[0]->set('disabledtext', $_[1]);
285     $_[0]->set('is_enabled', $_[1] ? 0 : 1);
286 }
287
288 ################################################################################
289 # Methods
290 ################################################################################
291
292 # Accessors for user attributes
293 sub name  { $_[0]->{realname};   }
294 sub login { $_[0]->{login_name}; }
295 sub extern_id { $_[0]->{extern_id}; }
296 sub email { $_[0]->login . Bugzilla->params->{'emailsuffix'}; }
297 sub disabledtext { $_[0]->{'disabledtext'}; }
298 sub is_enabled { $_[0]->{'is_enabled'} ? 1 : 0; }
299 sub showmybugslink { $_[0]->{showmybugslink}; }
300 sub email_disabled { $_[0]->{disable_mail}; }
301 sub email_enabled { !($_[0]->{disable_mail}); }
302 sub cryptpassword {
303     my $self = shift;
304     # We don't store it because we never want it in the object (we
305     # don't want to accidentally dump even the hash somewhere).
306     my ($pw) = Bugzilla->dbh->selectrow_array(
307         'SELECT cryptpassword FROM profiles WHERE userid = ?',
308         undef, $self->id);
309     return $pw;
310 }
311
312 sub set_authorizer {
313     my ($self, $authorizer) = @_;
314     $self->{authorizer} = $authorizer;
315 }
316 sub authorizer {
317     my ($self) = @_;
318     if (!$self->{authorizer}) {
319         require Bugzilla::Auth;
320         $self->{authorizer} = new Bugzilla::Auth();
321     }
322     return $self->{authorizer};
323 }
324
325 # Generate a string to identify the user by name + login if the user
326 # has a name or by login only if she doesn't.
327 sub identity {
328     my $self = shift;
329
330     return "" unless $self->id;
331
332     if (!defined $self->{identity}) {
333         $self->{identity} = 
334           $self->name ? $self->name . " <" . $self->login. ">" : $self->login;
335     }
336
337     return $self->{identity};
338 }
339
340 sub nick {
341     my $self = shift;
342
343     return "" unless $self->id;
344
345     if (!defined $self->{nick}) {
346         $self->{nick} = (split(/@/, $self->login, 2))[0];
347     }
348
349     return $self->{nick};
350 }
351
352 sub queries {
353     my $self = shift;
354     return $self->{queries} if defined $self->{queries};
355     return [] unless $self->id;
356
357     my $dbh = Bugzilla->dbh;
358     my $query_ids = $dbh->selectcol_arrayref(
359         'SELECT id FROM namedqueries WHERE userid = ?', undef, $self->id);
360     require Bugzilla::Search::Saved;
361     $self->{queries} = Bugzilla::Search::Saved->new_from_list($query_ids);
362
363     # We preload link_in_footer from here as this information is always requested.
364     # This only works if the user object represents the current logged in user.
365     Bugzilla::Search::Saved::preload($self->{queries}) if $self->id == Bugzilla->user->id;
366
367     return $self->{queries};
368 }
369
370 sub queries_subscribed {
371     my $self = shift;
372     return $self->{queries_subscribed} if defined $self->{queries_subscribed};
373     return [] unless $self->id;
374
375     # Exclude the user's own queries.
376     my @my_query_ids = map($_->id, @{$self->queries});
377     my $query_id_string = join(',', @my_query_ids) || '-1';
378
379     # Only show subscriptions that we can still actually see. If a
380     # user changes the shared group of a query, our subscription
381     # will remain but we won't have access to the query anymore.
382     my $subscribed_query_ids = Bugzilla->dbh->selectcol_arrayref(
383         "SELECT lif.namedquery_id
384            FROM namedqueries_link_in_footer lif
385                 INNER JOIN namedquery_group_map ngm
386                 ON ngm.namedquery_id = lif.namedquery_id
387           WHERE lif.user_id = ? 
388                 AND lif.namedquery_id NOT IN ($query_id_string)
389                 AND " . $self->groups_in_sql,
390           undef, $self->id);
391     require Bugzilla::Search::Saved;
392     $self->{queries_subscribed} =
393         Bugzilla::Search::Saved->new_from_list($subscribed_query_ids);
394     return $self->{queries_subscribed};
395 }
396
397 sub queries_available {
398     my $self = shift;
399     return $self->{queries_available} if defined $self->{queries_available};
400     return [] unless $self->id;
401
402     # Exclude the user's own queries.
403     my @my_query_ids = map($_->id, @{$self->queries});
404     my $query_id_string = join(',', @my_query_ids) || '-1';
405
406     my $avail_query_ids = Bugzilla->dbh->selectcol_arrayref(
407         'SELECT namedquery_id FROM namedquery_group_map
408           WHERE '  . $self->groups_in_sql . "
409                 AND namedquery_id NOT IN ($query_id_string)");
410     require Bugzilla::Search::Saved;
411     $self->{queries_available} =
412         Bugzilla::Search::Saved->new_from_list($avail_query_ids);
413     return $self->{queries_available};
414 }
415
416 sub tags {
417     my $self = shift;
418     my $dbh = Bugzilla->dbh;
419
420     if (!defined $self->{tags}) {
421         # We must use LEFT JOIN instead of INNER JOIN as we may be
422         # in the process of inserting a new tag to some bugs,
423         # in which case there are no bugs with this tag yet.
424         $self->{tags} = $dbh->selectall_hashref(
425             'SELECT name, id, COUNT(bug_id) AS bug_count
426                FROM tag
427           LEFT JOIN bug_tag ON bug_tag.tag_id = tag.id
428               WHERE user_id = ? ' . $dbh->sql_group_by('id', 'name'),
429             'name', undef, $self->id);
430     }
431     return $self->{tags};
432 }
433
434 ##########################
435 # Saved Recent Bug Lists #
436 ##########################
437
438 sub recent_searches {
439     my $self = shift;
440     $self->{recent_searches} ||= 
441         Bugzilla::Search::Recent->match({ user_id => $self->id });
442     return $self->{recent_searches};
443 }
444
445 sub recent_search_containing {
446     my ($self, $bug_id) = @_;
447     my $searches = $self->recent_searches;
448
449     foreach my $search (@$searches) {
450         return $search if grep($_ == $bug_id, @{ $search->bug_list });
451     }
452
453     return undef;
454 }
455
456 sub recent_search_for {
457     my ($self, $bug) = @_;
458     my $params = Bugzilla->input_params;
459     my $cgi = Bugzilla->cgi;
460
461     if ($self->id) {
462         # First see if there's a list_id parameter in the query string.
463         my $list_id = $params->{list_id};
464         if (!$list_id) {
465             # If not, check for "list_id" in the query string of the referer.
466             my $referer = $cgi->referer;
467             if ($referer) {
468                 my $uri = URI->new($referer);
469                 if ($uri->path =~ /buglist\.cgi$/) {
470                     $list_id = $uri->query_param('list_id')
471                                || $uri->query_param('regetlastlist');
472                 }
473             }
474         }
475
476         if ($list_id && $list_id ne 'cookie') {
477             # If we got a bad list_id (either some other user's or an expired
478             # one) don't crash, just don't return that list.
479             my $search = Bugzilla::Search::Recent->check_quietly(
480                 { id => $list_id });
481             return $search if $search;
482         }
483
484         # If there's no list_id, see if the current bug's id is contained
485         # in any of the user's saved lists.
486         my $search = $self->recent_search_containing($bug->id);
487         return $search if $search;
488     }
489
490     # Finally (or always, if we're logged out), if there's a BUGLIST cookie
491     # and the selected bug is in the list, then return the cookie as a fake
492     # Search::Recent object.
493     if (my $list = $cgi->cookie('BUGLIST')) {
494         # Also split on colons, which was used as a separator in old cookies.
495         my @bug_ids = split(/[:-]/, $list);
496         if (grep { $_ == $bug->id } @bug_ids) {
497             my $search = Bugzilla::Search::Recent->new_from_cookie(\@bug_ids);
498             return $search;
499         }
500     }
501
502     return undef;
503 }
504
505 sub save_last_search {
506     my ($self, $params) = @_;
507     my ($bug_ids, $order, $vars, $list_id) = 
508         @$params{qw(bugs order vars list_id)};
509
510     my $cgi = Bugzilla->cgi;
511     if ($order) {
512         $cgi->send_cookie(-name => 'LASTORDER',
513                           -value => $order,
514                           -expires => 'Fri, 01-Jan-2038 00:00:00 GMT');
515     }
516
517     return if !@$bug_ids;
518
519     my $search;
520     if ($self->id) {
521         on_main_db {
522             if ($list_id) {
523                 $search = Bugzilla::Search::Recent->check_quietly({ id => $list_id });
524             }
525
526             if ($search) {
527                 if (join(',', @{$search->bug_list}) ne join(',', @$bug_ids)) {
528                     $search->set_bug_list($bug_ids);
529                 }
530                 if (!$search->list_order || $order ne $search->list_order) {
531                     $search->set_list_order($order);
532                 }
533                 $search->update();
534             }
535             else {
536                 # If we already have an existing search with a totally
537                 # identical bug list, then don't create a new one. This
538                 # prevents people from writing over their whole 
539                 # recent-search list by just refreshing a saved search
540                 # (which doesn't have list_id in the header) over and over.
541                 my $list_string = join(',', @$bug_ids);
542                 my $existing_search = Bugzilla::Search::Recent->match({
543                     user_id => $self->id, bug_list => $list_string });
544            
545                 if (!scalar(@$existing_search)) {
546                     $search = Bugzilla::Search::Recent->create({
547                         user_id    => $self->id,
548                         bug_list   => $bug_ids,
549                         list_order => $order });
550                 }
551                 else {
552                     $search = $existing_search->[0];
553                 }
554             }
555         };
556         delete $self->{recent_searches};
557     }
558     # Logged-out users use a cookie to store a single last search. We don't
559     # override that cookie with the logged-in user's latest search, because
560     # if they did one search while logged out and another while logged in,
561     # they may still want to navigate through the search they made while
562     # logged out.
563     else {
564         my $bug_list = join('-', @$bug_ids);
565         if (length($bug_list) < 4000) {
566             $cgi->send_cookie(-name => 'BUGLIST',
567                               -value => $bug_list,
568                               -expires => 'Fri, 01-Jan-2038 00:00:00 GMT');
569         }
570         else {
571             $cgi->remove_cookie('BUGLIST');
572             $vars->{'toolong'} = 1;
573         }
574     }
575     return $search;
576 }
577
578 sub settings {
579     my ($self) = @_;
580
581     return $self->{'settings'} if (defined $self->{'settings'});
582
583     # IF the user is logged in
584     # THEN get the user's settings
585     # ELSE get default settings
586     if ($self->id) {
587         $self->{'settings'} = get_all_settings($self->id);
588     } else {
589         $self->{'settings'} = get_defaults();
590     }
591
592     return $self->{'settings'};
593 }
594
595 sub setting {
596     my ($self, $name) = @_;
597     return $self->settings->{$name}->{'value'};
598 }
599
600 sub timezone {
601     my $self = shift;
602
603     if (!defined $self->{timezone}) {
604         my $tz = $self->setting('timezone');
605         if ($tz eq 'local') {
606             # The user wants the local timezone of the server.
607             $self->{timezone} = Bugzilla->local_timezone;
608         }
609         else {
610             $self->{timezone} = DateTime::TimeZone->new(name => $tz);
611         }
612     }
613     return $self->{timezone};
614 }
615
616 sub flush_queries_cache {
617     my $self = shift;
618
619     delete $self->{queries};
620     delete $self->{queries_subscribed};
621     delete $self->{queries_available};
622 }
623
624 sub groups {
625     my $self = shift;
626
627     return $self->{groups} if defined $self->{groups};
628     return [] unless $self->id;
629
630     my $dbh = Bugzilla->dbh;
631     my $groups_to_check = $dbh->selectcol_arrayref(
632         q{SELECT DISTINCT group_id
633             FROM user_group_map
634            WHERE user_id = ? AND isbless = 0}, undef, $self->id);
635
636     my $rows = $dbh->selectall_arrayref(
637         "SELECT DISTINCT grantor_id, member_id
638            FROM group_group_map
639           WHERE grant_type = " . GROUP_MEMBERSHIP);
640
641     my %group_membership;
642     foreach my $row (@$rows) {
643         my ($grantor_id, $member_id) = @$row; 
644         push (@{ $group_membership{$member_id} }, $grantor_id);
645     }
646     
647     # Let's walk the groups hierarchy tree (using FIFO)
648     # On the first iteration it's pre-filled with direct groups 
649     # membership. Later on, each group can add its own members into the
650     # FIFO. Circular dependencies are eliminated by checking
651     # $checked_groups{$member_id} hash values.
652     # As a result, %groups will have all the groups we are the member of.
653     my %checked_groups;
654     my %groups;
655     while (scalar(@$groups_to_check) > 0) {
656         # Pop the head group from FIFO
657         my $member_id = shift @$groups_to_check;
658         
659         # Skip the group if we have already checked it
660         if (!$checked_groups{$member_id}) {
661             # Mark group as checked
662             $checked_groups{$member_id} = 1;
663             
664             # Add all its members to the FIFO check list
665             # %group_membership contains arrays of group members 
666             # for all groups. Accessible by group number.
667             my $members = $group_membership{$member_id};
668             my @new_to_check = grep(!$checked_groups{$_}, @$members);
669             push(@$groups_to_check, @new_to_check);
670
671             $groups{$member_id} = 1;
672         }
673     }
674
675     $self->{groups} = Bugzilla::Group->new_from_list([keys %groups]);
676
677     return $self->{groups};
678 }
679
680 # It turns out that calling ->id on objects a few hundred thousand
681 # times is pretty slow. (It showed up as a significant time contributor
682 # when profiling xt/search.t.) So we cache the group ids separately from
683 # groups for functions that need the group ids.
684 sub _group_ids {
685     my ($self) = @_;
686     $self->{group_ids} ||= [map { $_->id } @{ $self->groups }];
687     return $self->{group_ids};
688 }
689
690 sub groups_as_string {
691     my $self = shift;
692     my $ids = $self->_group_ids;
693     return scalar(@$ids) ? join(',', @$ids) : '-1';
694 }
695
696 sub groups_in_sql {
697     my ($self, $field) = @_;
698     $field ||= 'group_id';
699     my $ids = $self->_group_ids;
700     $ids = [-1] if !scalar @$ids;
701     return Bugzilla->dbh->sql_in($field, $ids);
702 }
703
704 sub bless_groups {
705     my $self = shift;
706
707     return $self->{'bless_groups'} if defined $self->{'bless_groups'};
708     return [] unless $self->id;
709
710     if ($self->in_group('editusers')) {
711         # Users having editusers permissions may bless all groups.
712         $self->{'bless_groups'} = [Bugzilla::Group->get_all];
713         return $self->{'bless_groups'};
714     }
715
716     my $dbh = Bugzilla->dbh;
717
718     # Get all groups for the user where:
719     #    + They have direct bless privileges
720     #    + They are a member of a group that inherits bless privs.
721     my @group_ids = map {$_->id} @{ $self->groups };
722     @group_ids = (-1) if !@group_ids;
723     my $query =
724         'SELECT DISTINCT groups.id
725            FROM groups, user_group_map, group_group_map AS ggm
726           WHERE user_group_map.user_id = ?
727                 AND ( (user_group_map.isbless = 1
728                        AND groups.id=user_group_map.group_id)
729                      OR (groups.id = ggm.grantor_id
730                          AND ggm.grant_type = ' . GROUP_BLESS . '
731                          AND ' . $dbh->sql_in('ggm.member_id', \@group_ids)
732                      . ') )';
733
734     # If visibilitygroups are used, restrict the set of groups.
735     if (Bugzilla->params->{'usevisibilitygroups'}) {
736         return [] if !$self->visible_groups_as_string;
737         # Users need to see a group in order to bless it.
738         $query .= " AND "
739             . $dbh->sql_in('groups.id', $self->visible_groups_inherited);
740     }
741
742     my $ids = $dbh->selectcol_arrayref($query, undef, $self->id);
743     return $self->{'bless_groups'} = Bugzilla::Group->new_from_list($ids);
744 }
745
746 sub in_group {
747     my ($self, $group, $product_id) = @_;
748     $group = $group->name if blessed $group;
749     if (scalar grep($_->name eq $group, @{ $self->groups })) {
750         return 1;
751     }
752     elsif ($product_id && detaint_natural($product_id)) {
753         # Make sure $group exists on a per-product basis.
754         return 0 unless (grep {$_ eq $group} PER_PRODUCT_PRIVILEGES);
755
756         $self->{"product_$product_id"} = {} unless exists $self->{"product_$product_id"};
757         if (!defined $self->{"product_$product_id"}->{$group}) {
758             my $dbh = Bugzilla->dbh;
759             my $in_group = $dbh->selectrow_array(
760                            "SELECT 1
761                               FROM group_control_map
762                              WHERE product_id = ?
763                                    AND $group != 0
764                                    AND " . $self->groups_in_sql . ' ' .
765                               $dbh->sql_limit(1),
766                              undef, $product_id);
767
768             $self->{"product_$product_id"}->{$group} = $in_group ? 1 : 0;
769         }
770         return $self->{"product_$product_id"}->{$group};
771     }
772     # If we come here, then the user is not in the requested group.
773     return 0;
774 }
775
776 sub in_group_id {
777     my ($self, $id) = @_;
778     return grep($_->id == $id, @{ $self->groups }) ? 1 : 0;
779 }
780
781 sub get_products_by_permission {
782     my ($self, $group) = @_;
783     # Make sure $group exists on a per-product basis.
784     return [] unless (grep {$_ eq $group} PER_PRODUCT_PRIVILEGES);
785
786     my $product_ids = Bugzilla->dbh->selectcol_arrayref(
787                           "SELECT DISTINCT product_id
788                              FROM group_control_map
789                             WHERE $group != 0
790                               AND " . $self->groups_in_sql);
791
792     # No need to go further if the user has no "special" privs.
793     return [] unless scalar(@$product_ids);
794     my %product_map = map { $_ => 1 } @$product_ids;
795
796     # We will restrict the list to products the user can see.
797     my $selectable_products = $self->get_selectable_products;
798     my @products = grep { $product_map{$_->id} } @$selectable_products;
799     return \@products;
800 }
801
802 sub can_see_user {
803     my ($self, $otherUser) = @_;
804     my $query;
805
806     if (Bugzilla->params->{'usevisibilitygroups'}) {
807         # If the user can see no groups, then no users are visible either.
808         my $visibleGroups = $self->visible_groups_as_string() || return 0;
809         $query = qq{SELECT COUNT(DISTINCT userid)
810                     FROM profiles, user_group_map
811                     WHERE userid = ?
812                     AND user_id = userid
813                     AND isbless = 0
814                     AND group_id IN ($visibleGroups)
815                    };
816     } else {
817         $query = qq{SELECT COUNT(userid)
818                     FROM profiles
819                     WHERE userid = ?
820                    };
821     }
822     return Bugzilla->dbh->selectrow_array($query, undef, $otherUser->id);
823 }
824
825 sub can_edit_product {
826     my ($self, $prod_id) = @_;
827     my $dbh = Bugzilla->dbh;
828
829     my $has_external_groups =
830       $dbh->selectrow_array('SELECT 1
831                                FROM group_control_map
832                               WHERE product_id = ?
833                                 AND canedit != 0
834                                 AND group_id NOT IN(' . $self->groups_as_string . ')',
835                              undef, $prod_id);
836
837     return !$has_external_groups;
838 }
839
840 sub can_see_bug {
841     my ($self, $bug_id) = @_;
842     return @{ $self->visible_bugs([$bug_id]) } ? 1 : 0;
843 }
844
845 sub visible_bugs {
846     my ($self, $bugs) = @_;
847     # Allow users to pass in Bug objects and bug ids both.
848     my @bug_ids = map { blessed $_ ? $_->id : $_ } @$bugs;
849
850     # We only check the visibility of bugs that we haven't
851     # checked yet.
852     # Bugzilla::Bug->update automatically removes updated bugs
853     # from the cache to force them to be checked again.
854     my $visible_cache = $self->{_visible_bugs_cache} ||= {};
855     my @check_ids = grep(!exists $visible_cache->{$_}, @bug_ids);
856
857     if (@check_ids) {
858         my $dbh = Bugzilla->dbh;
859         my $user_id = $self->id;
860         my $sth;
861         # Speed up the can_see_bug case.
862         # WEBKIT_CHANGES: Disable statement caching
863         #if (scalar(@check_ids) == 1) {
864         #    $sth = $self->{_sth_one_visible_bug};
865         #}
866         $sth ||= $dbh->prepare(
867             # This checks for groups that the bug is in that the user
868             # *isn't* in. Then, in the Perl code below, we check if
869             # the user can otherwise access the bug (for example, by being
870             # the assignee or QA Contact).
871             #
872             # The DISTINCT exists because the bug could be in *several*
873             # groups that the user isn't in, but they will all return the
874             # same result for bug_group_map.bug_id (so DISTINCT filters
875             # out duplicate rows).
876             "SELECT DISTINCT bugs.bug_id, reporter, assigned_to, qa_contact,
877                     reporter_accessible, cclist_accessible, cc.who,
878                     bug_group_map.bug_id
879                FROM bugs
880                     LEFT JOIN cc
881                               ON cc.bug_id = bugs.bug_id
882                                  AND cc.who = $user_id
883                     LEFT JOIN bug_group_map 
884                               ON bugs.bug_id = bug_group_map.bug_id
885                                  AND bug_group_map.group_id NOT IN ("
886                                      . $self->groups_as_string . ')
887               WHERE bugs.bug_id IN (' . join(',', ('?') x @check_ids) . ')
888                     AND creation_ts IS NOT NULL ');
889         # WEBKIT_CHANGES: Disable statement caching
890         #if (scalar(@check_ids) == 1) {
891         #    $self->{_sth_one_visible_bug} = $sth;
892         #}
893
894         $sth->execute(@check_ids);
895         my $use_qa_contact = Bugzilla->params->{'useqacontact'};
896         while (my $row = $sth->fetchrow_arrayref) {
897             my ($bug_id, $reporter, $owner, $qacontact, $reporter_access, 
898                 $cclist_access, $isoncclist, $missinggroup) = @$row;
899             $visible_cache->{$bug_id} ||= 
900                 ((($reporter == $user_id) && $reporter_access)
901                  || ($use_qa_contact
902                      && $qacontact && ($qacontact == $user_id))
903                  || ($owner == $user_id)
904                  || ($isoncclist && $cclist_access)
905                  || !$missinggroup) ? 1 : 0;
906         }
907     }
908
909     return [grep { $visible_cache->{blessed $_ ? $_->id : $_} } @$bugs];
910 }
911
912 sub clear_product_cache {
913     my $self = shift;
914     delete $self->{enterable_products};
915     delete $self->{selectable_products};
916     delete $self->{selectable_classifications};
917 }
918
919 sub can_see_product {
920     my ($self, $product_name) = @_;
921
922     return scalar(grep {$_->name eq $product_name} @{$self->get_selectable_products});
923 }
924
925 sub get_selectable_products {
926     my $self = shift;
927     my $class_id = shift;
928     my $class_restricted = Bugzilla->params->{'useclassification'} && $class_id;
929
930     if (!defined $self->{selectable_products}) {
931         my $query = "SELECT id " .
932                     "  FROM products " .
933                  "LEFT JOIN group_control_map " .
934                         "ON group_control_map.product_id = products.id " .
935                       " AND group_control_map.membercontrol = " . CONTROLMAPMANDATORY .
936                       " AND group_id NOT IN(" . $self->groups_as_string . ") " .
937                   "   WHERE group_id IS NULL " .
938                   "ORDER BY name";
939
940         my $prod_ids = Bugzilla->dbh->selectcol_arrayref($query);
941         $self->{selectable_products} = Bugzilla::Product->new_from_list($prod_ids);
942     }
943
944     # Restrict the list of products to those being in the classification, if any.
945     if ($class_restricted) {
946         return [grep {$_->classification_id == $class_id} @{$self->{selectable_products}}];
947     }
948     # If we come here, then we want all selectable products.
949     return $self->{selectable_products};
950 }
951
952 sub get_selectable_classifications {
953     my ($self) = @_;
954
955     if (!defined $self->{selectable_classifications}) {
956         my $products = $self->get_selectable_products;
957         my %class_ids = map { $_->classification_id => 1 } @$products;
958
959         $self->{selectable_classifications} = Bugzilla::Classification->new_from_list([keys %class_ids]);
960     }
961     return $self->{selectable_classifications};
962 }
963
964 sub can_enter_product {
965     my ($self, $input, $warn) = @_;
966     my $dbh = Bugzilla->dbh;
967     $warn ||= 0;
968
969     $input = trim($input) if !ref $input;
970     if (!defined $input or $input eq '') {
971         return unless $warn == THROW_ERROR;
972         ThrowUserError('object_not_specified',
973                        { class => 'Bugzilla::Product' });
974     }
975
976     if (!scalar @{ $self->get_enterable_products }) {
977         return unless $warn == THROW_ERROR;
978         ThrowUserError('no_products');
979     }
980
981     my $product = blessed($input) ? $input 
982                                   : new Bugzilla::Product({ name => $input });
983     my $can_enter =
984       $product && grep($_->name eq $product->name,
985                        @{ $self->get_enterable_products });
986
987     return $product if $can_enter;
988
989     return 0 unless $warn == THROW_ERROR;
990
991     # Check why access was denied. These checks are slow,
992     # but that's fine, because they only happen if we fail.
993
994     # We don't just use $product->name for error messages, because if it
995     # changes case from $input, then that's a clue that the product does
996     # exist but is hidden.
997     my $name = blessed($input) ? $input->name : $input;
998
999     # The product could not exist or you could be denied...
1000     if (!$product || !$product->user_has_access($self)) {
1001         ThrowUserError('entry_access_denied', { product => $name });
1002     }
1003     # It could be closed for bug entry...
1004     elsif (!$product->is_active) {
1005         ThrowUserError('product_disabled', { product => $product });
1006     }
1007     # It could have no components...
1008     elsif (!@{$product->components}
1009            || !grep { $_->is_active } @{$product->components})
1010     {
1011         ThrowUserError('missing_component', { product => $product });
1012     }
1013     # It could have no versions...
1014     elsif (!@{$product->versions}
1015            || !grep { $_->is_active } @{$product->versions})
1016     {
1017         ThrowUserError ('missing_version', { product => $product });
1018     }
1019
1020     die "can_enter_product reached an unreachable location.";
1021 }
1022
1023 sub get_enterable_products {
1024     my $self = shift;
1025     my $dbh = Bugzilla->dbh;
1026
1027     if (defined $self->{enterable_products}) {
1028         return $self->{enterable_products};
1029     }
1030
1031      # All products which the user has "Entry" access to.
1032      my $enterable_ids = $dbh->selectcol_arrayref(
1033            'SELECT products.id FROM products
1034          LEFT JOIN group_control_map
1035                    ON group_control_map.product_id = products.id
1036                       AND group_control_map.entry != 0
1037                       AND group_id NOT IN (' . $self->groups_as_string . ')
1038             WHERE group_id IS NULL
1039                   AND products.isactive = 1');
1040
1041     if (scalar @$enterable_ids) {
1042         # And all of these products must have at least one component
1043         # and one version.
1044         $enterable_ids = $dbh->selectcol_arrayref(
1045             'SELECT DISTINCT products.id FROM products
1046               WHERE ' . $dbh->sql_in('products.id', $enterable_ids) .
1047               ' AND products.id IN (SELECT DISTINCT components.product_id
1048                                       FROM components
1049                                      WHERE components.isactive = 1)
1050                 AND products.id IN (SELECT DISTINCT versions.product_id
1051                                       FROM versions
1052                                      WHERE versions.isactive = 1)');
1053     }
1054
1055     $self->{enterable_products} =
1056          Bugzilla::Product->new_from_list($enterable_ids);
1057     return $self->{enterable_products};
1058 }
1059
1060 sub can_access_product {
1061     my ($self, $product) = @_;
1062     my $product_name = blessed($product) ? $product->name : $product;
1063     return scalar(grep {$_->name eq $product_name} @{$self->get_accessible_products});
1064 }
1065
1066 sub get_accessible_products {
1067     my $self = shift;
1068     
1069     # Map the objects into a hash using the ids as keys
1070     my %products = map { $_->id => $_ }
1071                        @{$self->get_selectable_products},
1072                        @{$self->get_enterable_products};
1073     
1074     return [ sort { $a->name cmp $b->name } values %products ];
1075 }
1076
1077 sub check_can_admin_product {
1078     my ($self, $product_name) = @_;
1079
1080     # First make sure the product name is valid.
1081     my $product = Bugzilla::Product->check($product_name);
1082
1083     ($self->in_group('editcomponents', $product->id)
1084        && $self->can_see_product($product->name))
1085          || ThrowUserError('product_admin_denied', {product => $product->name});
1086
1087     # Return the validated product object.
1088     return $product;
1089 }
1090
1091 sub check_can_admin_flagtype {
1092     my ($self, $flagtype_id) = @_;
1093
1094     my $flagtype = Bugzilla::FlagType->check({ id => $flagtype_id });
1095     my $can_fully_edit = 1;
1096
1097     if (!$self->in_group('editcomponents')) {
1098         my $products = $self->get_products_by_permission('editcomponents');
1099         # You need editcomponents privs for at least one product to have
1100         # a chance to edit the flagtype.
1101         scalar(@$products)
1102           || ThrowUserError('auth_failure', {group  => 'editcomponents',
1103                                              action => 'edit',
1104                                              object => 'flagtypes'});
1105         my $can_admin = 0;
1106         my $i = $flagtype->inclusions_as_hash;
1107         my $e = $flagtype->exclusions_as_hash;
1108
1109         # If there is at least one product for which the user doesn't have
1110         # editcomponents privs, then don't allow him to do everything with
1111         # this flagtype, independently of whether this product is in the
1112         # exclusion list or not.
1113         my %product_ids;
1114         map { $product_ids{$_->id} = 1 } @$products;
1115         $can_fully_edit = 0 if grep { !$product_ids{$_} } keys %$i;
1116
1117         unless ($e->{0}->{0}) {
1118             foreach my $product (@$products) {
1119                 my $id = $product->id;
1120                 next if $e->{$id}->{0};
1121                 # If we are here, the product has not been explicitly excluded.
1122                 # Check whether it's explicitly included, or at least one of
1123                 # its components.
1124                 $can_admin = ($i->{0}->{0} || $i->{$id}->{0}
1125                               || scalar(grep { !$e->{$id}->{$_} } keys %{$i->{$id}}));
1126                 last if $can_admin;
1127             }
1128         }
1129         $can_admin || ThrowUserError('flag_type_not_editable', { flagtype => $flagtype });
1130     }
1131     return wantarray ? ($flagtype, $can_fully_edit) : $flagtype;
1132 }
1133
1134 sub can_request_flag {
1135     my ($self, $flag_type) = @_;
1136
1137     return ($self->can_set_flag($flag_type)
1138             || !$flag_type->request_group_id
1139             || $self->in_group_id($flag_type->request_group_id)) ? 1 : 0;
1140 }
1141
1142 sub can_set_flag {
1143     my ($self, $flag_type) = @_;
1144
1145     return (!$flag_type->grant_group_id
1146             || $self->in_group_id($flag_type->grant_group_id)) ? 1 : 0;
1147 }
1148
1149 sub direct_group_membership {
1150     my $self = shift;
1151     my $dbh = Bugzilla->dbh;
1152
1153     if (!$self->{'direct_group_membership'}) {
1154         my $gid = $dbh->selectcol_arrayref('SELECT id
1155                                               FROM groups
1156                                         INNER JOIN user_group_map
1157                                                 ON groups.id = user_group_map.group_id
1158                                              WHERE user_id = ?
1159                                                AND isbless = 0',
1160                                              undef, $self->id);
1161         $self->{'direct_group_membership'} = Bugzilla::Group->new_from_list($gid);
1162     }
1163     return $self->{'direct_group_membership'};
1164 }
1165
1166
1167 # visible_groups_inherited returns a reference to a list of all the groups
1168 # whose members are visible to this user.
1169 sub visible_groups_inherited {
1170     my $self = shift;
1171     return $self->{visible_groups_inherited} if defined $self->{visible_groups_inherited};
1172     return [] unless $self->id;
1173     my @visgroups = @{$self->visible_groups_direct};
1174     @visgroups = @{Bugzilla::Group->flatten_group_membership(@visgroups)};
1175     $self->{visible_groups_inherited} = \@visgroups;
1176     return $self->{visible_groups_inherited};
1177 }
1178
1179 # visible_groups_direct returns a reference to a list of all the groups that
1180 # are visible to this user.
1181 sub visible_groups_direct {
1182     my $self = shift;
1183     my @visgroups = ();
1184     return $self->{visible_groups_direct} if defined $self->{visible_groups_direct};
1185     return [] unless $self->id;
1186
1187     my $dbh = Bugzilla->dbh;
1188     my $sth;
1189    
1190     if (Bugzilla->params->{'usevisibilitygroups'}) {
1191         $sth = $dbh->prepare("SELECT DISTINCT grantor_id
1192                                  FROM group_group_map
1193                                 WHERE " . $self->groups_in_sql('member_id') . "
1194                                   AND grant_type=" . GROUP_VISIBLE);
1195     }
1196     else {
1197         # All groups are visible if usevisibilitygroups is off.
1198         $sth = $dbh->prepare('SELECT id FROM groups');
1199     }
1200     $sth->execute();
1201
1202     while (my ($row) = $sth->fetchrow_array) {
1203         push @visgroups,$row;
1204     }
1205     $self->{visible_groups_direct} = \@visgroups;
1206
1207     return $self->{visible_groups_direct};
1208 }
1209
1210 sub visible_groups_as_string {
1211     my $self = shift;
1212     return join(', ', @{$self->visible_groups_inherited()});
1213 }
1214
1215 # This function defines the groups a user may share a query with.
1216 # More restrictive sites may want to build this reference to a list of group IDs
1217 # from bless_groups instead of mirroring visible_groups_inherited, perhaps.
1218 sub queryshare_groups {
1219     my $self = shift;
1220     my @queryshare_groups;
1221
1222     return $self->{queryshare_groups} if defined $self->{queryshare_groups};
1223
1224     if ($self->in_group(Bugzilla->params->{'querysharegroup'})) {
1225         # We want to be allowed to share with groups we're in only.
1226         # If usevisibilitygroups is on, then we need to restrict this to groups
1227         # we may see.
1228         if (Bugzilla->params->{'usevisibilitygroups'}) {
1229             foreach(@{$self->visible_groups_inherited()}) {
1230                 next unless $self->in_group_id($_);
1231                 push(@queryshare_groups, $_);
1232             }
1233         }
1234         else {
1235             @queryshare_groups = @{ $self->_group_ids };
1236         }
1237     }
1238
1239     return $self->{queryshare_groups} = \@queryshare_groups;
1240 }
1241
1242 sub queryshare_groups_as_string {
1243     my $self = shift;
1244     return join(', ', @{$self->queryshare_groups()});
1245 }
1246
1247 sub derive_regexp_groups {
1248     my ($self) = @_;
1249
1250     my $id = $self->id;
1251     return unless $id;
1252
1253     my $dbh = Bugzilla->dbh;
1254
1255     my $sth;
1256
1257     # add derived records for any matching regexps
1258
1259     $sth = $dbh->prepare("SELECT id, userregexp, user_group_map.group_id
1260                             FROM groups
1261                        LEFT JOIN user_group_map
1262                               ON groups.id = user_group_map.group_id
1263                              AND user_group_map.user_id = ?
1264                              AND user_group_map.grant_type = ?");
1265     $sth->execute($id, GRANT_REGEXP);
1266
1267     my $group_insert = $dbh->prepare(q{INSERT INTO user_group_map
1268                                        (user_id, group_id, isbless, grant_type)
1269                                        VALUES (?, ?, 0, ?)});
1270     my $group_delete = $dbh->prepare(q{DELETE FROM user_group_map
1271                                        WHERE user_id = ?
1272                                          AND group_id = ?
1273                                          AND isbless = 0
1274                                          AND grant_type = ?});
1275     while (my ($group, $regexp, $present) = $sth->fetchrow_array()) {
1276         if (($regexp ne '') && ($self->login =~ m/$regexp/i)) {
1277             $group_insert->execute($id, $group, GRANT_REGEXP) unless $present;
1278         } else {
1279             $group_delete->execute($id, $group, GRANT_REGEXP) if $present;
1280         }
1281     }
1282 }
1283
1284 sub product_responsibilities {
1285     my $self = shift;
1286     my $dbh = Bugzilla->dbh;
1287
1288     return $self->{'product_resp'} if defined $self->{'product_resp'};
1289     return [] unless $self->id;
1290
1291     my $list = $dbh->selectall_arrayref('SELECT components.product_id, components.id
1292                                            FROM components
1293                                            LEFT JOIN component_cc
1294                                            ON components.id = component_cc.component_id
1295                                           WHERE components.initialowner = ?
1296                                              OR components.initialqacontact = ?
1297                                              OR component_cc.user_id = ?',
1298                                   {Slice => {}}, ($self->id, $self->id, $self->id));
1299
1300     unless ($list) {
1301         $self->{'product_resp'} = [];
1302         return $self->{'product_resp'};
1303     }
1304
1305     my @prod_ids = map {$_->{'product_id'}} @$list;
1306     my $products = Bugzilla::Product->new_from_list(\@prod_ids);
1307     # We cannot |use| it, because Component.pm already |use|s User.pm.
1308     require Bugzilla::Component;
1309     my @comp_ids = map {$_->{'id'}} @$list;
1310     my $components = Bugzilla::Component->new_from_list(\@comp_ids);
1311
1312     my @prod_list;
1313     # @$products is already sorted alphabetically.
1314     foreach my $prod (@$products) {
1315         # We use @components instead of $prod->components because we only want
1316         # components where the user is either the default assignee or QA contact.
1317         push(@prod_list, {product    => $prod,
1318                           components => [grep {$_->product_id == $prod->id} @$components]});
1319     }
1320     $self->{'product_resp'} = \@prod_list;
1321     return $self->{'product_resp'};
1322 }
1323
1324 sub can_bless {
1325     my $self = shift;
1326
1327     if (!scalar(@_)) {
1328         # If we're called without an argument, just return 
1329         # whether or not we can bless at all.
1330         return scalar(@{ $self->bless_groups }) ? 1 : 0;
1331     }
1332
1333     # Otherwise, we're checking a specific group
1334     my $group_id = shift;
1335     return grep($_->id == $group_id, @{ $self->bless_groups }) ? 1 : 0;
1336 }
1337
1338 sub match {
1339     # Generates a list of users whose login name (email address) or real name
1340     # matches a substring or wildcard.
1341     # This is also called if matches are disabled (for error checking), but
1342     # in this case only the exact match code will end up running.
1343
1344     # $str contains the string to match, while $limit contains the
1345     # maximum number of records to retrieve.
1346     my ($str, $limit, $exclude_disabled) = @_;
1347     my $user = Bugzilla->user;
1348     my $dbh = Bugzilla->dbh;
1349
1350     $str = trim($str);
1351
1352     my @users = ();
1353     return \@users if $str =~ /^\s*$/;
1354
1355     # The search order is wildcards, then exact match, then substring search.
1356     # Wildcard matching is skipped if there is no '*', and exact matches will
1357     # not (?) have a '*' in them.  If any search comes up with something, the
1358     # ones following it will not execute.
1359
1360     # first try wildcards
1361     my $wildstr = $str;
1362
1363     # Do not do wildcards if there is no '*' in the string.
1364     if ($wildstr =~ s/\*/\%/g && $user->id) {
1365         # Build the query.
1366         trick_taint($wildstr);
1367         my $query  = "SELECT DISTINCT userid FROM profiles ";
1368         if (Bugzilla->params->{'usevisibilitygroups'}) {
1369             $query .= "INNER JOIN user_group_map
1370                                ON user_group_map.user_id = profiles.userid ";
1371         }
1372         $query .= "WHERE ("
1373             . $dbh->sql_istrcmp('login_name', '?', "LIKE") . " OR " .
1374               $dbh->sql_istrcmp('realname', '?', "LIKE") . ") ";
1375         if (Bugzilla->params->{'usevisibilitygroups'}) {
1376             $query .= "AND isbless = 0 " .
1377                       "AND group_id IN(" .
1378                       join(', ', (-1, @{$user->visible_groups_inherited})) . ") ";
1379         }
1380         $query    .= " AND is_enabled = 1 " if $exclude_disabled;
1381         $query    .= $dbh->sql_limit($limit) if $limit;
1382
1383         # Execute the query, retrieve the results, and make them into
1384         # User objects.
1385         my $user_ids = $dbh->selectcol_arrayref($query, undef, ($wildstr, $wildstr));
1386         @users = @{Bugzilla::User->new_from_list($user_ids)};
1387     }
1388     else {    # try an exact match
1389         # Exact matches don't care if a user is disabled.
1390         trick_taint($str);
1391         my $user_id = $dbh->selectrow_array('SELECT userid FROM profiles
1392                                              WHERE ' . $dbh->sql_istrcmp('login_name', '?'),
1393                                              undef, $str);
1394
1395         push(@users, new Bugzilla::User($user_id)) if $user_id;
1396     }
1397
1398     # then try substring search
1399     if (!scalar(@users) && length($str) >= 3 && $user->id) {
1400         trick_taint($str);
1401
1402         my $query   = "SELECT DISTINCT userid FROM profiles ";
1403         if (Bugzilla->params->{'usevisibilitygroups'}) {
1404             $query .= "INNER JOIN user_group_map
1405                                ON user_group_map.user_id = profiles.userid ";
1406         }
1407         $query     .= " WHERE (" .
1408                 $dbh->sql_iposition('?', 'login_name') . " > 0" . " OR " .
1409                 $dbh->sql_iposition('?', 'realname') . " > 0) ";
1410         if (Bugzilla->params->{'usevisibilitygroups'}) {
1411             $query .= " AND isbless = 0" .
1412                       " AND group_id IN(" .
1413                 join(', ', (-1, @{$user->visible_groups_inherited})) . ") ";
1414         }
1415         $query     .= " AND is_enabled = 1 " if $exclude_disabled;
1416         $query     .= $dbh->sql_limit($limit) if $limit;
1417         my $user_ids = $dbh->selectcol_arrayref($query, undef, ($str, $str));
1418         @users = @{Bugzilla::User->new_from_list($user_ids)};
1419     }
1420     return \@users;
1421 }
1422
1423 sub match_field {
1424     my $fields       = shift;   # arguments as a hash
1425     my $data         = shift || Bugzilla->input_params; # hash to look up fields in
1426     my $behavior     = shift || 0; # A constant that tells us how to act
1427     my $matches      = {};      # the values sent to the template
1428     my $matchsuccess = 1;       # did the match fail?
1429     my $need_confirm = 0;       # whether to display confirmation screen
1430     my $match_multiple = 0;     # whether we ever matched more than one user
1431     my @non_conclusive_fields;  # fields which don't have a unique user.
1432
1433     my $params = Bugzilla->params;
1434
1435     # prepare default form values
1436
1437     # Fields can be regular expressions matching multiple form fields
1438     # (f.e. "requestee-(\d+)"), so expand each non-literal field
1439     # into the list of form fields it matches.
1440     my $expanded_fields = {};
1441     foreach my $field_pattern (keys %{$fields}) {
1442         # Check if the field has any non-word characters.  Only those fields
1443         # can be regular expressions, so don't expand the field if it doesn't
1444         # have any of those characters.
1445         if ($field_pattern =~ /^\w+$/) {
1446             $expanded_fields->{$field_pattern} = $fields->{$field_pattern};
1447         }
1448         else {
1449             my @field_names = grep(/$field_pattern/, keys %$data);
1450
1451             foreach my $field_name (@field_names) {
1452                 $expanded_fields->{$field_name} = 
1453                   { type => $fields->{$field_pattern}->{'type'} };
1454                 
1455                 # The field is a requestee field; in order for its name 
1456                 # to show up correctly on the confirmation page, we need 
1457                 # to find out the name of its flag type.
1458                 if ($field_name =~ /^requestee(_type)?-(\d+)$/) {
1459                     my $flag_type;
1460                     if ($1) {
1461                         require Bugzilla::FlagType;
1462                         $flag_type = new Bugzilla::FlagType($2);
1463                     }
1464                     else {
1465                         require Bugzilla::Flag;
1466                         my $flag = new Bugzilla::Flag($2);
1467                         $flag_type = $flag->type if $flag;
1468                     }
1469                     if ($flag_type) {
1470                         $expanded_fields->{$field_name}->{'flag_type'} = $flag_type;
1471                     }
1472                     else {
1473                         # No need to look for a valid requestee if the flag(type)
1474                         # has been deleted (may occur in race conditions).
1475                         delete $expanded_fields->{$field_name};
1476                         delete $data->{$field_name};
1477                     }
1478                 }
1479             }
1480         }
1481     }
1482     $fields = $expanded_fields;
1483
1484     foreach my $field (keys %{$fields}) {
1485         next unless defined $data->{$field};
1486
1487         #Concatenate login names, so that we have a common way to handle them.
1488         my $raw_field;
1489         if (ref $data->{$field}) {
1490             $raw_field = join(",", @{$data->{$field}});
1491         }
1492         else {
1493             $raw_field = $data->{$field};
1494         }
1495         $raw_field = clean_text($raw_field || '');
1496
1497         # Now we either split $raw_field by spaces/commas and put the list
1498         # into @queries, or in the case of fields which only accept single
1499         # entries, we simply use the verbatim text.
1500         my @queries;
1501         if ($fields->{$field}->{'type'} eq 'single') {
1502             @queries = ($raw_field);
1503             # We will repopulate it later if a match is found, else it must
1504             # be set to an empty string so that the field remains defined.
1505             $data->{$field} = '';
1506         }
1507         elsif ($fields->{$field}->{'type'} eq 'multi') {
1508             @queries =  split(/[,;]+/, $raw_field);
1509             # We will repopulate it later if a match is found, else it must
1510             # be undefined.
1511             delete $data->{$field};
1512         }
1513         else {
1514             # bad argument
1515             ThrowCodeError('bad_arg',
1516                            { argument => $fields->{$field}->{'type'},
1517                              function =>  'Bugzilla::User::match_field',
1518                            });
1519         }
1520
1521         # Tolerate fields that do not exist (in case you specify
1522         # e.g. the QA contact, and it's currently not in use).
1523         next unless (defined $raw_field && $raw_field ne '');
1524
1525         my $limit = 0;
1526         if ($params->{'maxusermatches'}) {
1527             $limit = $params->{'maxusermatches'} + 1;
1528         }
1529
1530         my @logins;
1531         for my $query (@queries) {
1532             $query = trim($query);
1533             next if $query eq '';
1534
1535             my $users = match(
1536                 $query,   # match string
1537                 $limit,   # match limit
1538                 1         # exclude_disabled
1539             );
1540
1541             # here is where it checks for multiple matches
1542             if (scalar(@{$users}) == 1) { # exactly one match
1543                 push(@logins, @{$users}[0]->login);
1544
1545                 # skip confirmation for exact matches
1546                 next if (lc(@{$users}[0]->login) eq lc($query));
1547
1548                 $matches->{$field}->{$query}->{'status'} = 'success';
1549                 $need_confirm = 1 if $params->{'confirmuniqueusermatch'};
1550
1551             }
1552             elsif ((scalar(@{$users}) > 1)
1553                     && ($params->{'maxusermatches'} != 1)) {
1554                 $need_confirm = 1;
1555                 $match_multiple = 1;
1556                 push(@non_conclusive_fields, $field);
1557
1558                 if (($params->{'maxusermatches'})
1559                    && (scalar(@{$users}) > $params->{'maxusermatches'}))
1560                 {
1561                     $matches->{$field}->{$query}->{'status'} = 'trunc';
1562                     pop @{$users};  # take the last one out
1563                 }
1564                 else {
1565                     $matches->{$field}->{$query}->{'status'} = 'success';
1566                 }
1567
1568             }
1569             else {
1570                 # everything else fails
1571                 $matchsuccess = 0; # fail
1572                 push(@non_conclusive_fields, $field);
1573                 $matches->{$field}->{$query}->{'status'} = 'fail';
1574                 $need_confirm = 1;  # confirmation screen shows failures
1575             }
1576
1577             $matches->{$field}->{$query}->{'users'}  = $users;
1578         }
1579
1580         # If no match or more than one match has been found for a field
1581         # expecting only one match (type eq "single"), we set it back to ''
1582         # so that the caller of this function can still check whether this
1583         # field was defined or not (and it was if we came here).
1584         if ($fields->{$field}->{'type'} eq 'single') {
1585             $data->{$field} = $logins[0] || '';
1586         }
1587         elsif (scalar @logins) {
1588             $data->{$field} = \@logins;
1589         }
1590     }
1591
1592     my $retval;
1593     if (!$matchsuccess) {
1594         $retval = USER_MATCH_FAILED;
1595     }
1596     elsif ($match_multiple) {
1597         $retval = USER_MATCH_MULTIPLE;
1598     }
1599     else {
1600         $retval = USER_MATCH_SUCCESS;
1601     }
1602
1603     # Skip confirmation if we were told to, or if we don't need to confirm.
1604     if ($behavior == MATCH_SKIP_CONFIRM || !$need_confirm) {
1605         return wantarray ? ($retval, \@non_conclusive_fields) : $retval;
1606     }
1607
1608     my $template = Bugzilla->template;
1609     my $cgi = Bugzilla->cgi;
1610     my $vars = {};
1611
1612     $vars->{'script'}        = $cgi->url(-relative => 1); # for self-referencing URLs
1613     $vars->{'fields'}        = $fields; # fields being matched
1614     $vars->{'matches'}       = $matches; # matches that were made
1615     $vars->{'matchsuccess'}  = $matchsuccess; # continue or fail
1616     $vars->{'matchmultiple'} = $match_multiple;
1617
1618     print $cgi->header();
1619
1620     $template->process("global/confirm-user-match.html.tmpl", $vars)
1621       || ThrowTemplateError($template->error());
1622     exit;
1623
1624 }
1625
1626 # Changes in some fields automatically trigger events. The field names are
1627 # from the fielddefs table.
1628 our %names_to_events = (
1629     'resolution'              => EVT_OPENED_CLOSED,
1630     'keywords'                => EVT_KEYWORD,
1631     'cc'                      => EVT_CC,
1632     'bug_severity'            => EVT_PROJ_MANAGEMENT,
1633     'priority'                => EVT_PROJ_MANAGEMENT,
1634     'bug_status'              => EVT_PROJ_MANAGEMENT,
1635     'target_milestone'        => EVT_PROJ_MANAGEMENT,
1636     'attachments.description' => EVT_ATTACHMENT_DATA,
1637     'attachments.mimetype'    => EVT_ATTACHMENT_DATA,
1638     'attachments.ispatch'     => EVT_ATTACHMENT_DATA,
1639     'dependson'               => EVT_DEPEND_BLOCK,
1640     'blocked'                 => EVT_DEPEND_BLOCK);
1641
1642 # Returns true if the user wants mail for a given bug change.
1643 # Note: the "+" signs before the constants suppress bareword quoting.
1644 sub wants_bug_mail {
1645     my $self = shift;
1646     my ($bug, $relationship, $fieldDiffs, $comments, $dep_mail, $changer) = @_;
1647
1648     # Make a list of the events which have happened during this bug change,
1649     # from the point of view of this user.    
1650     my %events;    
1651     foreach my $change (@$fieldDiffs) {
1652         my $fieldName = $change->{field_name};
1653         # A change to any of the above fields sets the corresponding event
1654         if (defined($names_to_events{$fieldName})) {
1655             $events{$names_to_events{$fieldName}} = 1;
1656         }
1657         else {
1658             # Catch-all for any change not caught by a more specific event
1659             $events{+EVT_OTHER} = 1;            
1660         }
1661
1662         # If the user is in a particular role and the value of that role
1663         # changed, we need the ADDED_REMOVED event.
1664         if (($fieldName eq "assigned_to" && $relationship == REL_ASSIGNEE) ||
1665             ($fieldName eq "qa_contact" && $relationship == REL_QA))
1666         {
1667             $events{+EVT_ADDED_REMOVED} = 1;
1668         }
1669         
1670         if ($fieldName eq "cc") {
1671             my $login = $self->login;
1672             my $inold = ($change->{old} =~ /^(.*,\s*)?\Q$login\E(,.*)?$/);
1673             my $innew = ($change->{new} =~ /^(.*,\s*)?\Q$login\E(,.*)?$/);
1674             if ($inold != $innew)
1675             {
1676                 $events{+EVT_ADDED_REMOVED} = 1;
1677             }
1678         }
1679     }
1680
1681     if (!$bug->lastdiffed) {
1682         # Notify about new bugs.
1683         $events{+EVT_BUG_CREATED} = 1;
1684
1685         # You role is new if the bug itself is.
1686         # Only makes sense for the assignee, QA contact and the CC list.
1687         if ($relationship == REL_ASSIGNEE
1688             || $relationship == REL_QA
1689             || $relationship == REL_CC)
1690         {
1691             $events{+EVT_ADDED_REMOVED} = 1;
1692         }
1693     }
1694
1695     if (grep { $_->type == CMT_ATTACHMENT_CREATED } @$comments) {
1696         $events{+EVT_ATTACHMENT} = 1;
1697     }
1698     elsif (defined($$comments[0])) {
1699         $events{+EVT_COMMENT} = 1;
1700     }
1701     
1702     # Dependent changed bugmails must have an event to ensure the bugmail is
1703     # emailed.
1704     if ($dep_mail) {
1705         $events{+EVT_DEPEND_BLOCK} = 1;
1706     }
1707
1708     my @event_list = keys %events;
1709     
1710     my $wants_mail = $self->wants_mail(\@event_list, $relationship);
1711
1712     # The negative events are handled separately - they can't be incorporated
1713     # into the first wants_mail call, because they are of the opposite sense.
1714     # 
1715     # We do them separately because if _any_ of them are set, we don't want
1716     # the mail.
1717     if ($wants_mail && $changer && ($self->id == $changer->id)) {
1718         $wants_mail &= $self->wants_mail([EVT_CHANGED_BY_ME], $relationship);
1719     }    
1720     
1721     if ($wants_mail && $bug->bug_status eq 'UNCONFIRMED') {
1722         $wants_mail &= $self->wants_mail([EVT_UNCONFIRMED], $relationship);
1723     }
1724     
1725     return $wants_mail;
1726 }
1727
1728 # Returns true if the user wants mail for a given set of events.
1729 sub wants_mail {
1730     my $self = shift;
1731     my ($events, $relationship) = @_;
1732     
1733     # Don't send any mail, ever, if account is disabled 
1734     # XXX Temporary Compatibility Change 1 of 2:
1735     # This code is disabled for the moment to make the behaviour like the old
1736     # system, which sent bugmail to disabled accounts.
1737     # return 0 if $self->{'disabledtext'};
1738     
1739     # No mail if there are no events
1740     return 0 if !scalar(@$events);
1741
1742     # If a relationship isn't given, default to REL_ANY.
1743     if (!defined($relationship)) {
1744         $relationship = REL_ANY;
1745     }
1746
1747     # Skip DB query if relationship is explicit
1748     return 1 if $relationship == REL_GLOBAL_WATCHER;
1749
1750     my $wants_mail = grep { $self->mail_settings->{$relationship}{$_} } @$events;
1751     return $wants_mail ? 1 : 0;
1752 }
1753
1754 sub mail_settings {
1755     my $self = shift;
1756     my $dbh = Bugzilla->dbh;
1757
1758     if (!defined $self->{'mail_settings'}) {
1759         my $data =
1760           $dbh->selectall_arrayref('SELECT relationship, event FROM email_setting
1761                                     WHERE user_id = ?', undef, $self->id);
1762         my %mail;
1763         # The hash is of the form $mail{$relationship}{$event} = 1.
1764         $mail{$_->[0]}{$_->[1]} = 1 foreach @$data;
1765
1766         $self->{'mail_settings'} = \%mail;
1767     }
1768     return $self->{'mail_settings'};
1769 }
1770
1771 sub has_audit_entries {
1772     my $self = shift;
1773     my $dbh = Bugzilla->dbh;
1774
1775     if (!exists $self->{'has_audit_entries'}) {
1776         $self->{'has_audit_entries'} =
1777             $dbh->selectrow_array('SELECT 1 FROM audit_log WHERE user_id = ? ' .
1778                                    $dbh->sql_limit(1), undef, $self->id);
1779     }
1780     return $self->{'has_audit_entries'};
1781 }
1782
1783 sub is_insider {
1784     my $self = shift;
1785
1786     if (!defined $self->{'is_insider'}) {
1787         my $insider_group = Bugzilla->params->{'insidergroup'};
1788         $self->{'is_insider'} =
1789             ($insider_group && $self->in_group($insider_group)) ? 1 : 0;
1790     }
1791     return $self->{'is_insider'};
1792 }
1793
1794 sub is_global_watcher {
1795     my $self = shift;
1796
1797     if (!defined $self->{'is_global_watcher'}) {
1798         my @watchers = split(/[,;]+/, Bugzilla->params->{'globalwatchers'});
1799         $self->{'is_global_watcher'} = scalar(grep { $_ eq $self->login } @watchers) ? 1 : 0;
1800     }
1801     return  $self->{'is_global_watcher'};
1802 }
1803
1804 sub is_timetracker {
1805     my $self = shift;
1806
1807     if (!defined $self->{'is_timetracker'}) {
1808         my $tt_group = Bugzilla->params->{'timetrackinggroup'};
1809         $self->{'is_timetracker'} =
1810             ($tt_group && $self->in_group($tt_group)) ? 1 : 0;
1811     }
1812     return $self->{'is_timetracker'};
1813 }
1814
1815 sub get_userlist {
1816     my $self = shift;
1817
1818     return $self->{'userlist'} if defined $self->{'userlist'};
1819
1820     my $dbh = Bugzilla->dbh;
1821     my $query  = "SELECT DISTINCT login_name, realname,";
1822     if (Bugzilla->params->{'usevisibilitygroups'}) {
1823         $query .= " COUNT(group_id) ";
1824     } else {
1825         $query .= " 1 ";
1826     }
1827     $query     .= "FROM profiles ";
1828     if (Bugzilla->params->{'usevisibilitygroups'}) {
1829         $query .= "LEFT JOIN user_group_map " .
1830                   "ON user_group_map.user_id = userid AND isbless = 0 " .
1831                   "AND group_id IN(" .
1832                   join(', ', (-1, @{$self->visible_groups_inherited})) . ")";
1833     }
1834     $query    .= " WHERE is_enabled = 1 ";
1835     $query    .= $dbh->sql_group_by('userid', 'login_name, realname');
1836
1837     my $sth = $dbh->prepare($query);
1838     $sth->execute;
1839
1840     my @userlist;
1841     while (my($login, $name, $visible) = $sth->fetchrow_array) {
1842         push @userlist, {
1843             login => $login,
1844             identity => $name ? "$name <$login>" : $login,
1845             visible => $visible,
1846         };
1847     }
1848     @userlist = sort { lc $$a{'identity'} cmp lc $$b{'identity'} } @userlist;
1849
1850     $self->{'userlist'} = \@userlist;
1851     return $self->{'userlist'};
1852 }
1853
1854 sub create {
1855     my $invocant = shift;
1856     my $class = ref($invocant) || $invocant;
1857     my $dbh = Bugzilla->dbh;
1858
1859     $dbh->bz_start_transaction();
1860
1861     my $user = $class->SUPER::create(@_);
1862
1863     # Turn on all email for the new user
1864     require Bugzilla::BugMail;
1865     my %relationships = Bugzilla::BugMail::relationships();
1866     foreach my $rel (keys %relationships) {
1867         foreach my $event (POS_EVENTS, NEG_EVENTS) {
1868             # These "exceptions" define the default email preferences.
1869             # 
1870             # We enable mail unless the change was made by the user, or it's
1871             # just a CC list addition and the user is not the reporter.
1872             next if ($event == EVT_CHANGED_BY_ME);
1873             next if (($event == EVT_CC) && ($rel != REL_REPORTER));
1874
1875             $dbh->do('INSERT INTO email_setting (user_id, relationship, event)
1876                       VALUES (?, ?, ?)', undef, ($user->id, $rel, $event));
1877         }
1878     }
1879
1880     foreach my $event (GLOBAL_EVENTS) {
1881         $dbh->do('INSERT INTO email_setting (user_id, relationship, event)
1882                   VALUES (?, ?, ?)', undef, ($user->id, REL_ANY, $event));
1883     }
1884
1885     $user->derive_regexp_groups();
1886
1887     # Add the creation date to the profiles_activity table.
1888     # $who is the user who created the new user account, i.e. either an
1889     # admin or the new user himself.
1890     my $who = Bugzilla->user->id || $user->id;
1891     my $creation_date_fieldid = get_field_id('creation_ts');
1892
1893     $dbh->do('INSERT INTO profiles_activity
1894                           (userid, who, profiles_when, fieldid, newvalue)
1895                    VALUES (?, ?, NOW(), ?, NOW())',
1896                    undef, ($user->id, $who, $creation_date_fieldid));
1897
1898     $dbh->bz_commit_transaction();
1899
1900     # Return the newly created user account.
1901     return $user;
1902 }
1903
1904 ###########################
1905 # Account Lockout Methods #
1906 ###########################
1907
1908 sub account_is_locked_out {
1909     my $self = shift;
1910     my $login_failures = scalar @{ $self->account_ip_login_failures };
1911     return $login_failures >= MAX_LOGIN_ATTEMPTS ? 1 : 0;
1912 }
1913
1914 sub note_login_failure {
1915     my $self = shift;
1916     my $ip_addr = remote_ip();
1917     trick_taint($ip_addr);
1918     Bugzilla->dbh->do("INSERT INTO login_failure (user_id, ip_addr, login_time)
1919                        VALUES (?, ?, LOCALTIMESTAMP(0))",
1920                       undef, $self->id, $ip_addr);
1921     delete $self->{account_ip_login_failures};
1922 }
1923
1924 sub clear_login_failures {
1925     my $self = shift;
1926     my $ip_addr = remote_ip();
1927     trick_taint($ip_addr);
1928     Bugzilla->dbh->do(
1929         'DELETE FROM login_failure WHERE user_id = ? AND ip_addr = ?',
1930         undef, $self->id, $ip_addr);
1931     delete $self->{account_ip_login_failures};
1932 }
1933
1934 sub account_ip_login_failures {
1935     my $self = shift;
1936     my $dbh = Bugzilla->dbh;
1937     my $time = $dbh->sql_date_math('LOCALTIMESTAMP(0)', '-', 
1938                                    LOGIN_LOCKOUT_INTERVAL, 'MINUTE');
1939     my $ip_addr = remote_ip();
1940     trick_taint($ip_addr);
1941     $self->{account_ip_login_failures} ||= Bugzilla->dbh->selectall_arrayref(
1942         "SELECT login_time, ip_addr, user_id FROM login_failure
1943           WHERE user_id = ? AND login_time > $time
1944                 AND ip_addr = ?
1945        ORDER BY login_time", {Slice => {}}, $self->id, $ip_addr);
1946     return $self->{account_ip_login_failures};
1947 }
1948
1949 ###############
1950 # Subroutines #
1951 ###############
1952
1953 sub is_available_username {
1954     my ($username, $old_username) = @_;
1955
1956     if(login_to_id($username) != 0) {
1957         return 0;
1958     }
1959
1960     my $dbh = Bugzilla->dbh;
1961     # $username is safe because it is only used in SELECT placeholders.
1962     trick_taint($username);
1963     # Reject if the new login is part of an email change which is
1964     # still in progress
1965     #
1966     # substring/locate stuff: bug 165221; this used to use regexes, but that
1967     # was unsafe and required weird escaping; using substring to pull out
1968     # the new/old email addresses and sql_position() to find the delimiter (':')
1969     # is cleaner/safer
1970     my $eventdata = $dbh->selectrow_array(
1971         "SELECT eventdata
1972            FROM tokens
1973           WHERE (tokentype = 'emailold'
1974                 AND SUBSTRING(eventdata, 1, (" .
1975                     $dbh->sql_position(q{':'}, 'eventdata') . "-  1)) = ?)
1976              OR (tokentype = 'emailnew'
1977                 AND SUBSTRING(eventdata, (" .
1978                     $dbh->sql_position(q{':'}, 'eventdata') . "+ 1), LENGTH(eventdata)) = ?)",
1979          undef, ($username, $username));
1980
1981     if ($eventdata) {
1982         # Allow thru owner of token
1983         if($old_username && ($eventdata eq "$old_username:$username")) {
1984             return 1;
1985         }
1986         return 0;
1987     }
1988
1989     return 1;
1990 }
1991
1992 sub check_account_creation_enabled {
1993     my $self = shift;
1994
1995     # If we're using e.g. LDAP for login, then we can't create a new account.
1996     $self->authorizer->user_can_create_account
1997       || ThrowUserError('auth_cant_create_account');
1998
1999     Bugzilla->params->{'createemailregexp'}
2000       || ThrowUserError('account_creation_disabled');
2001 }
2002
2003 sub check_and_send_account_creation_confirmation {
2004     my ($self, $login) = @_;
2005
2006     $login = $self->check_login_name_for_creation($login);
2007     my $creation_regexp = Bugzilla->params->{'createemailregexp'};
2008
2009     if ($login !~ /$creation_regexp/i) {
2010         ThrowUserError('account_creation_restricted');
2011     }
2012
2013     # Create and send a token for this new account.
2014     require Bugzilla::Token;
2015     Bugzilla::Token::issue_new_user_account_token($login);
2016 }
2017
2018 # This is used in a few performance-critical areas where we don't want to
2019 # do check() and pull all the user data from the database.
2020 sub login_to_id {
2021     my ($login, $throw_error) = @_;
2022     my $dbh = Bugzilla->dbh;
2023     my $cache = Bugzilla->request_cache->{user_login_to_id} ||= {};
2024
2025     # We cache lookups because this function showed up as taking up a 
2026     # significant amount of time in profiles of xt/search.t. However,
2027     # for users that don't exist, we re-do the check every time, because
2028     # otherwise we break is_available_username.
2029     my $user_id;
2030     if (defined $cache->{$login}) {
2031         $user_id = $cache->{$login};
2032     }
2033     else {
2034         # No need to validate $login -- it will be used by the following SELECT
2035         # statement only, so it's safe to simply trick_taint.
2036         trick_taint($login);
2037         $user_id = $dbh->selectrow_array(
2038             "SELECT userid FROM profiles 
2039               WHERE " . $dbh->sql_istrcmp('login_name', '?'), undef, $login);
2040         $cache->{$login} = $user_id;
2041     }
2042
2043     if ($user_id) {
2044         return $user_id;
2045     } elsif ($throw_error) {
2046         ThrowUserError('invalid_username', { name => $login });
2047     } else {
2048         return 0;
2049     }
2050 }
2051
2052 sub user_id_to_login {
2053     my $user_id = shift;
2054     my $dbh = Bugzilla->dbh;
2055
2056     return '' unless ($user_id && detaint_natural($user_id));
2057
2058     my $login = $dbh->selectrow_array('SELECT login_name FROM profiles
2059                                        WHERE userid = ?', undef, $user_id);
2060     return $login || '';
2061 }
2062
2063 sub validate_password {
2064     my ($password, $matchpassword) = @_;
2065
2066     if (length($password) < USER_PASSWORD_MIN_LENGTH) {
2067         ThrowUserError('password_too_short');
2068     } elsif ((defined $matchpassword) && ($password ne $matchpassword)) {
2069         ThrowUserError('passwords_dont_match');
2070     }
2071     
2072     my $complexity_level = Bugzilla->params->{password_complexity};
2073     if ($complexity_level eq 'letters_numbers_specialchars') {
2074         ThrowUserError('password_not_complex')
2075           if ($password !~ /[[:alpha:]]/ || $password !~ /\d/ || $password !~ /[[:punct:]]/);
2076     } elsif ($complexity_level eq 'letters_numbers') {
2077         ThrowUserError('password_not_complex')
2078           if ($password !~ /[[:lower:]]/ || $password !~ /[[:upper:]]/ || $password !~ /\d/);
2079     } elsif ($complexity_level eq 'mixed_letters') {
2080         ThrowUserError('password_not_complex')
2081           if ($password !~ /[[:lower:]]/ || $password !~ /[[:upper:]]/);
2082     }
2083
2084     # Having done these checks makes us consider the password untainted.
2085     trick_taint($_[0]);
2086     return 1;
2087 }
2088
2089
2090 1;
2091
2092 __END__
2093
2094 =head1 NAME
2095
2096 Bugzilla::User - Object for a Bugzilla user
2097
2098 =head1 SYNOPSIS
2099
2100   use Bugzilla::User;
2101
2102   my $user = new Bugzilla::User($id);
2103
2104   my @get_selectable_classifications = 
2105       $user->get_selectable_classifications;
2106
2107   # Class Functions
2108   $user = Bugzilla::User->create({ 
2109       login_name    => $username, 
2110       realname      => $realname, 
2111       cryptpassword => $plaintext_password, 
2112       disabledtext  => $disabledtext,
2113       disable_mail  => 0});
2114
2115 =head1 DESCRIPTION
2116
2117 This package handles Bugzilla users. Data obtained from here is read-only;
2118 there is currently no way to modify a user from this package.
2119
2120 Note that the currently logged in user (if any) is available via
2121 L<Bugzilla-E<gt>user|Bugzilla/"user">.
2122
2123 C<Bugzilla::User> is an implementation of L<Bugzilla::Object>, and thus
2124 provides all the methods of L<Bugzilla::Object> in addition to the
2125 methods listed below.
2126
2127 =head1 CONSTANTS
2128
2129 =over
2130
2131 =item C<USER_MATCH_MULTIPLE>
2132
2133 Returned by C<match_field()> when at least one field matched more than 
2134 one user, but no matches failed.
2135
2136 =item C<USER_MATCH_FAILED>
2137
2138 Returned by C<match_field()> when at least one field failed to match 
2139 anything.
2140
2141 =item C<USER_MATCH_SUCCESS>
2142
2143 Returned by C<match_field()> when all fields successfully matched only one
2144 user.
2145
2146 =item C<MATCH_SKIP_CONFIRM>
2147
2148 Passed in to match_field to tell match_field to never display a 
2149 confirmation screen.
2150
2151 =back
2152
2153 =head1 METHODS
2154
2155 =head2 Constructors
2156
2157 =over
2158
2159 =item C<super_user>
2160
2161 Returns a user who is in all groups, but who does not really exist in the
2162 database. Used for non-web scripts like L<checksetup> that need to make 
2163 database changes and so on.
2164
2165 =back
2166
2167 =head2 Saved and Shared Queries
2168
2169 =over
2170
2171 =item C<queries>
2172
2173 Returns an arrayref of the user's own saved queries, sorted by name. The 
2174 array contains L<Bugzilla::Search::Saved> objects.
2175
2176 =item C<queries_subscribed>
2177
2178 Returns an arrayref of shared queries that the user has subscribed to.
2179 That is, these are shared queries that the user sees in their footer.
2180 This array contains L<Bugzilla::Search::Saved> objects.
2181
2182 =item C<queries_available>
2183
2184 Returns an arrayref of all queries to which the user could possibly
2185 subscribe. This includes the contents of L</queries_subscribed>.
2186 An array of L<Bugzilla::Search::Saved> objects.
2187
2188 =item C<flush_queries_cache>
2189
2190 Some code modifies the set of stored queries. Because C<Bugzilla::User> does
2191 not handle these modifications, but does cache the result of calling C<queries>
2192 internally, such code must call this method to flush the cached result.
2193
2194 =item C<queryshare_groups>
2195
2196 An arrayref of group ids. The user can share their own queries with these
2197 groups.
2198
2199 =item C<tags>
2200
2201 Returns a hashref with tag IDs as key, and a hashref with tag 'id',
2202 'name' and 'bug_count' as value.
2203
2204 =back
2205
2206 =head2 Saved Recent Bug Lists
2207
2208 =over
2209
2210 =item C<recent_searches>
2211
2212 Returns an arrayref of L<Bugzilla::Search::Recent> objects
2213 containing the user's recent searches.
2214
2215 =item C<recent_search_containing(bug_id)>
2216
2217 Returns a L<Bugzilla::Search::Recent> object that contains the most recent
2218 search by the user for the specified bug id. Retuns undef if no match is found.
2219
2220 =item C<recent_search_for(bug)>
2221
2222 Returns a L<Bugzilla::Search::Recent> object that contains a search by the
2223 user. Uses the list_id of the current loaded page, or the referrer page, and
2224 the bug id if that fails. Finally it will check the BUGLIST cookie, and create
2225 an object based on that, or undef if it does not exist.
2226
2227 =item C<save_last_search>
2228
2229 Saves the users most recent search in the database if logged in, or in the
2230 BUGLIST cookie if not logged in. Parameters are bug_ids, order, vars and
2231 list_id.
2232
2233 =back
2234
2235 =head2 Account Lockout
2236
2237 =over
2238
2239 =item C<account_is_locked_out>
2240
2241 Returns C<1> if the account has failed to log in too many times recently,
2242 and thus is locked out for a period of time. Returns C<0> otherwise.
2243
2244 =item C<account_ip_login_failures>
2245
2246 Returns an arrayref of hashrefs, that contains information about the recent
2247 times that this account has failed to log in from the current remote IP.
2248 The hashes contain C<ip_addr>, C<login_time>, and C<user_id>.
2249
2250 =item C<note_login_failure>
2251
2252 This notes that this account has failed to log in, and stores the fact
2253 in the database. The storing happens immediately, it does not wait for
2254 you to call C<update>.
2255
2256 =back
2257
2258 =head2 Other Methods
2259
2260 =over
2261
2262 =item C<id>
2263
2264 Returns the userid for this user.
2265
2266 =item C<login>
2267
2268 Returns the login name for this user.
2269
2270 =item C<email>
2271
2272 Returns the user's email address. Currently this is the same value as the
2273 login.
2274
2275 =item C<name>
2276
2277 Returns the 'real' name for this user, if any.
2278
2279 =item C<showmybugslink>
2280
2281 Returns C<1> if the user has set his preference to show the 'My Bugs' link in
2282 the page footer, and C<0> otherwise.
2283
2284 =item C<identity>
2285
2286 Returns a string for the identity of the user. This will be of the form
2287 C<name E<lt>emailE<gt>> if the user has specified a name, and C<email>
2288 otherwise.
2289
2290 =item C<nick>
2291
2292 Returns a user "nickname" -- i.e. a shorter, not-necessarily-unique name by
2293 which to identify the user. Currently the part of the user's email address
2294 before the at sign (@), but that could change, especially if we implement
2295 usernames not dependent on email address.
2296
2297 =item C<authorizer>
2298
2299 This is the L<Bugzilla::Auth> object that the User logged in with.
2300 If the user hasn't logged in yet, a new, empty Bugzilla::Auth() object is
2301 returned.
2302
2303 =item C<set_authorizer($authorizer)>
2304
2305 Sets the L<Bugzilla::Auth> object to be returned by C<authorizer()>.
2306 Should only be called by C<Bugzilla::Auth::login>, for the most part.
2307
2308 =item C<disabledtext>
2309
2310 Returns the disable text of the user, if any.
2311
2312 =item C<settings>
2313
2314 Returns a hash of hashes which holds the user's settings. The first key is
2315 the name of the setting, as found in setting.name. The second key is one of:
2316 is_enabled     - true if the user is allowed to set the preference themselves;
2317                  false to force the site defaults
2318                  for themselves or must accept the global site default value
2319 default_value  - the global site default for this setting
2320 value          - the value of this setting for this user. Will be the same
2321                  as the default_value if the user is not logged in, or if 
2322                  is_default is true.
2323 is_default     - a boolean to indicate whether the user has chosen to make
2324                  a preference for themself or use the site default.
2325
2326 =item C<setting(name)>
2327
2328 Returns the value for the specified setting.
2329
2330 =item C<timezone>
2331
2332 Returns the timezone used to display dates and times to the user,
2333 as a DateTime::TimeZone object.
2334
2335 =item C<groups>
2336
2337 Returns an arrayref of L<Bugzilla::Group> objects representing
2338 groups that this user is a member of.
2339
2340 =item C<groups_as_string>
2341
2342 Returns a string containing a comma-separated list of numeric group ids.  If
2343 the user is not a member of any groups, returns "-1". This is most often used
2344 within an SQL IN() function.
2345
2346 =item C<groups_in_sql>
2347
2348 This returns an C<IN> clause for SQL, containing either all of the groups
2349 the user is in, or C<-1> if the user is in no groups. This takes one
2350 argument--the name of the SQL field that should be on the left-hand-side
2351 of the C<IN> statement, which defaults to C<group_id> if not specified.
2352
2353 =item C<in_group($group_name, $product_id)>
2354
2355 Determines whether or not a user is in the given group by name.
2356 If $product_id is given, it also checks for local privileges for
2357 this product.
2358
2359 =item C<in_group_id>
2360
2361 Determines whether or not a user is in the given group by id. 
2362
2363 =item C<bless_groups>
2364
2365 Returns an arrayref of L<Bugzilla::Group> objects.
2366
2367 The arrayref consists of the groups the user can bless, taking into account
2368 that having editusers permissions means that you can bless all groups, and
2369 that you need to be able to see a group in order to bless it.
2370
2371 =item C<get_products_by_permission($group)>
2372
2373 Returns a list of product objects for which the user has $group privileges
2374 and which he can access.
2375 $group must be one of the groups defined in PER_PRODUCT_PRIVILEGES.
2376
2377 =item C<can_see_user(user)>
2378
2379 Returns 1 if the specified user account exists and is visible to the user,
2380 0 otherwise.
2381
2382 =item C<can_edit_product(prod_id)>
2383
2384 Determines if, given a product id, the user can edit bugs in this product
2385 at all.
2386
2387 =item C<can_see_bug(bug_id)>
2388
2389 Determines if the user can see the specified bug.
2390
2391 =item C<can_see_product(product_name)>
2392
2393 Returns 1 if the user can access the specified product, and 0 if the user
2394 should not be aware of the existence of the product.
2395
2396 =item C<derive_regexp_groups>
2397
2398 Bugzilla allows for group inheritance. When data about the user (or any of the
2399 groups) changes, the database must be updated. Handling updated groups is taken
2400 care of by the constructor. However, when updating the email address, the
2401 user may be placed into different groups, based on a new email regexp. This
2402 method should be called in such a case to force reresolution of these groups.
2403
2404 =item C<clear_product_cache>
2405
2406 Clears the stored values for L</get_selectable_products>, 
2407 L</get_enterable_products>, etc. so that their data will be read from
2408 the database again. Used mostly by L<Bugzilla::Product>.
2409
2410 =item C<get_selectable_products>
2411
2412  Description: Returns all products the user is allowed to access. This list
2413               is restricted to some given classification if $classification_id
2414               is given.
2415
2416  Params:      $classification_id - (optional) The ID of the classification
2417                                    the products belong to.
2418
2419  Returns:     An array of product objects, sorted by the product name.
2420
2421 =item C<get_selectable_classifications>
2422
2423  Description: Returns all classifications containing at least one product
2424               the user is allowed to view.
2425
2426  Params:      none
2427
2428  Returns:     An array of Bugzilla::Classification objects, sorted by
2429               the classification name.
2430
2431 =item C<can_enter_product($product_name, $warn)>
2432
2433  Description: Returns a product object if the user can enter bugs into the
2434               specified product.
2435               If the user cannot enter bugs into the product, the behavior of
2436               this method depends on the value of $warn:
2437               - if $warn is false (or not given), a 'false' value is returned;
2438               - if $warn is true, an error is thrown.
2439
2440  Params:      $product_name - a product name.
2441               $warn         - optional parameter, indicating whether an error
2442                               must be thrown if the user cannot enter bugs
2443                               into the specified product.
2444
2445  Returns:     A product object if the user can enter bugs into the product,
2446               0 if the user cannot enter bugs into the product and if $warn
2447               is false (an error is thrown if $warn is true).
2448
2449 =item C<get_enterable_products>
2450
2451  Description: Returns an array of product objects into which the user is
2452               allowed to enter bugs.
2453
2454  Params:      none
2455
2456  Returns:     an array of product objects.
2457
2458 =item C<can_access_product($product)>
2459
2460 Returns 1 if the user can search or enter bugs into the specified product
2461 (either a L<Bugzilla::Product> or a product name), and 0 if the user should
2462 not be aware of the existence of the product.
2463
2464 =item C<get_accessible_products>
2465
2466  Description: Returns an array of product objects the user can search
2467               or enter bugs against.
2468
2469  Params:      none
2470
2471  Returns:     an array of product objects.
2472
2473 =item C<check_can_admin_product($product_name)>
2474
2475  Description: Checks whether the user is allowed to administrate the product.
2476
2477  Params:      $product_name - a product name.
2478
2479  Returns:     On success, a product object. On failure, an error is thrown.
2480
2481 =item C<check_can_admin_flagtype($flagtype_id)>
2482
2483  Description: Checks whether the user is allowed to edit properties of the flag type.
2484               If the flag type is also used by some products for which the user
2485               hasn't editcomponents privs, then the user is only allowed to edit
2486               the inclusion and exclusion lists for products he can administrate.
2487
2488  Params:      $flagtype_id - a flag type ID.
2489
2490  Returns:     On success, a flag type object. On failure, an error is thrown.
2491               In list context, a boolean indicating whether the user can edit
2492               all properties of the flag type is also returned. The boolean
2493               is false if the user can only edit the inclusion and exclusions
2494               lists.
2495
2496 =item C<can_request_flag($flag_type)>
2497
2498  Description: Checks whether the user can request flags of the given type.
2499
2500  Params:      $flag_type - a Bugzilla::FlagType object.
2501
2502  Returns:     1 if the user can request flags of the given type,
2503               0 otherwise.
2504
2505 =item C<can_set_flag($flag_type)>
2506
2507  Description: Checks whether the user can set flags of the given type.
2508
2509  Params:      $flag_type - a Bugzilla::FlagType object.
2510
2511  Returns:     1 if the user can set flags of the given type,
2512               0 otherwise.
2513
2514 =item C<get_userlist>
2515
2516 Returns a reference to an array of users.  The array is populated with hashrefs
2517 containing the login, identity and visibility.  Users that are not visible to this
2518 user will have 'visible' set to zero.
2519
2520 =item C<direct_group_membership>
2521
2522 Returns a reference to an array of group objects. Groups the user belong to
2523 by group inheritance are excluded from the list.
2524
2525 =item C<visible_groups_inherited>
2526
2527 Returns a list of all groups whose members should be visible to this user.
2528 Since this list is flattened already, there is no need for all users to
2529 be have derived groups up-to-date to select the users meeting this criteria.
2530
2531 =item C<visible_groups_direct>
2532
2533 Returns a list of groups that the user is aware of.
2534
2535 =item C<visible_groups_as_string>
2536
2537 Returns the result of C<visible_groups_inherited> as a string (a comma-separated
2538 list).
2539
2540 =item C<product_responsibilities>
2541
2542 Retrieve user's product responsibilities as a list of component objects.
2543 Each object is a component the user has a responsibility for.
2544
2545 =item C<can_bless>
2546
2547 When called with no arguments:
2548 Returns C<1> if the user can bless at least one group, returns C<0> otherwise.
2549
2550 When called with one argument:
2551 Returns C<1> if the user can bless the group with that id, returns
2552 C<0> otherwise.
2553
2554 =item C<wants_bug_mail>
2555
2556 Returns true if the user wants mail for a given bug change.
2557
2558 =item C<wants_mail>
2559
2560 Returns true if the user wants mail for a given set of events. This method is
2561 more general than C<wants_bug_mail>, allowing you to check e.g. permissions
2562 for flag mail.
2563
2564 =item C<is_insider>
2565
2566 Returns true if the user can access private comments and attachments,
2567 i.e. if the 'insidergroup' parameter is set and the user belongs to this group.
2568
2569 =item C<is_global_watcher>
2570
2571 Returns true if the user is a global watcher,
2572 i.e. if the 'globalwatchers' parameter contains the user.
2573
2574 =back
2575
2576 =head1 CLASS FUNCTIONS
2577
2578 These are functions that are not called on a User object, but instead are
2579 called "statically," just like a normal procedural function.
2580
2581 =over 4
2582
2583 =item C<create>
2584
2585 The same as L<Bugzilla::Object/create>.
2586
2587 Params: login_name - B<Required> The login name for the new user.
2588         realname - The full name for the new user.
2589         cryptpassword  - B<Required> The password for the new user.
2590             Even though the name says "crypt", you should just specify
2591             a plain-text password. If you specify '*', the user will not
2592             be able to log in using DB authentication.
2593         disabledtext - The disable-text for the new user. If given, the user 
2594             will be disabled, meaning he cannot log in. Defaults to an
2595             empty string.
2596         disable_mail - If 1, bug-related mail will not be  sent to this user; 
2597             if 0, mail will be sent depending on the user's  email preferences.
2598
2599 =item C<check>
2600
2601 Takes a username as its only argument. Throws an error if there is no
2602 user with that username. Returns a C<Bugzilla::User> object.
2603
2604 =item C<check_account_creation_enabled>
2605
2606 Checks that users can create new user accounts, and throws an error
2607 if user creation is disabled.
2608
2609 =item C<check_and_send_account_creation_confirmation($login)>
2610
2611 If the user request for a new account passes validation checks, an email
2612 is sent to this user for confirmation. Otherwise an error is thrown
2613 indicating why the request has been rejected.
2614
2615 =item C<is_available_username>
2616
2617 Returns a boolean indicating whether or not the supplied username is
2618 already taken in Bugzilla.
2619
2620 Params: $username (scalar, string) - The full login name of the username 
2621             that you are checking.
2622         $old_username (scalar, string) - If you are checking an email-change
2623             token, insert the "old" username that the user is changing from,
2624             here. Then, as long as it's the right user for that token, he 
2625             can change his username to $username. (That is, this function
2626             will return a boolean true value).
2627
2628 =item C<login_to_id($login, $throw_error)>
2629
2630 Takes a login name of a Bugzilla user and changes that into a numeric
2631 ID for that user. This ID can then be passed to Bugzilla::User::new to
2632 create a new user.
2633
2634 If no valid user exists with that login name, then the function returns 0.
2635 However, if $throw_error is set, the function will throw a user error
2636 instead of returning.
2637
2638 This function can also be used when you want to just find out the userid
2639 of a user, but you don't want the full weight of Bugzilla::User.
2640
2641 However, consider using a Bugzilla::User object instead of this function
2642 if you need more information about the user than just their ID.
2643
2644 =item C<user_id_to_login($user_id)>
2645
2646 Returns the login name of the user account for the given user ID. If no
2647 valid user ID is given or the user has no entry in the profiles table,
2648 we return an empty string.
2649
2650 =item C<validate_password($passwd1, $passwd2)>
2651
2652 Returns true if a password is valid (i.e. meets Bugzilla's
2653 requirements for length and content), else returns false.
2654 Untaints C<$passwd1> if successful.
2655
2656 If a second password is passed in, this function also verifies that
2657 the two passwords match.
2658
2659 =item C<match_field($data, $fields, $behavior)>
2660
2661 =over
2662
2663 =item B<Description>
2664
2665 Wrapper for the C<match()> function.
2666
2667 =item B<Params>
2668
2669 =over
2670
2671 =item C<$fields> - A hashref with field names as keys and a hash as values.
2672 Each hash is of the form { 'type' => 'single|multi' }, which specifies
2673 whether the field can take a single login name only or several.
2674
2675 =item C<$data> (optional) - A hashref with field names as keys and field values
2676 as values. If undefined, C<Bugzilla-E<gt>input_params> is used.
2677
2678 =item C<$behavior> (optional) - If set to C<MATCH_SKIP_CONFIRM>, no confirmation
2679 screen is displayed. In that case, the fields which don't match a unique user
2680 are left undefined. If not set, a confirmation screen is displayed if at
2681 least one field doesn't match any login name or match more than one.
2682
2683 =back
2684
2685 =item B<Returns>
2686
2687 If the third parameter is set to C<MATCH_SKIP_CONFIRM>, the function returns
2688 either C<USER_MATCH_SUCCESS> if all fields can be set unambiguously,
2689 C<USER_MATCH_FAILED> if at least one field doesn't match any user account,
2690 or C<USER_MATCH_MULTIPLE> if some fields match more than one user account.
2691
2692 If the third parameter is not set, then if all fields could be set
2693 unambiguously, nothing is returned, else a confirmation page is displayed.
2694
2695 =item B<Note>
2696
2697 This function must be called early in a script, before anything external
2698 is done with the data.
2699
2700 =back
2701
2702 =back
2703
2704 =head1 SEE ALSO
2705
2706 L<Bugzilla|Bugzilla>