Unreviewed. Fix individual benchmark description urls to go to in-depth.html instead...
[WebKit-https.git] / Websites / bugs.webkit.org / editgroups.cgi
1 #!/usr/bin/perl -T
2 # This Source Code Form is subject to the terms of the Mozilla Public
3 # License, v. 2.0. If a copy of the MPL was not distributed with this
4 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
5 #
6 # This Source Code Form is "Incompatible With Secondary Licenses", as
7 # defined by the Mozilla Public License, v. 2.0.
8
9 use 5.10.1;
10 use strict;
11 use warnings;
12
13 use lib qw(. lib);
14
15 use Bugzilla;
16 use Bugzilla::Constants;
17 use Bugzilla::Config qw(:admin);
18 use Bugzilla::Util;
19 use Bugzilla::Error;
20 use Bugzilla::Group;
21 use Bugzilla::Product;
22 use Bugzilla::User;
23 use Bugzilla::Token;
24
25 my $cgi = Bugzilla->cgi;
26 my $dbh = Bugzilla->dbh;
27 my $template = Bugzilla->template;
28 my $vars = {};
29
30 my $user = Bugzilla->login(LOGIN_REQUIRED);
31
32 print $cgi->header();
33
34 $user->in_group('creategroups')
35   || ThrowUserError("auth_failure", {group  => "creategroups",
36                                      action => "edit",
37                                      object => "groups"});
38
39 my $action = trim($cgi->param('action') || '');
40 my $token  = $cgi->param('token');
41
42 # CheckGroupID checks that a positive integer is given and is
43 # actually a valid group ID. If all tests are successful, the
44 # trimmed group ID is returned.
45
46 sub CheckGroupID {
47     my ($group_id) = @_;
48     $group_id = trim($group_id || 0);
49     ThrowUserError("group_not_specified") unless $group_id;
50     (detaint_natural($group_id)
51       && Bugzilla->dbh->selectrow_array("SELECT id FROM groups WHERE id = ?",
52                                         undef, $group_id))
53       || ThrowUserError("invalid_group_ID");
54     return $group_id;
55 }
56
57 # CheckGroupRegexp checks that the regular expression is valid
58 # (the regular expression being optional, the test is successful
59 # if none is given, as expected). The trimmed regular expression
60 # is returned.
61
62 sub CheckGroupRegexp {
63     my ($regexp) = @_;
64     $regexp = trim($regexp || '');
65     trick_taint($regexp);
66     ThrowUserError("invalid_regexp") unless (eval {qr/$regexp/});
67     return $regexp;
68 }
69
70 # A helper for displaying the edit.html.tmpl template.
71 sub get_current_and_available {
72     my ($group, $vars) = @_;
73
74     my @all_groups         = Bugzilla::Group->get_all;
75     my @members_current    = @{$group->grant_direct(GROUP_MEMBERSHIP)};
76     my @member_of_current  = @{$group->granted_by_direct(GROUP_MEMBERSHIP)};
77     my @bless_from_current = @{$group->grant_direct(GROUP_BLESS)};
78     my @bless_to_current   = @{$group->granted_by_direct(GROUP_BLESS)};
79     my (@visible_from_current, @visible_to_me_current);
80     if (Bugzilla->params->{'usevisibilitygroups'}) {
81         @visible_from_current  = @{$group->grant_direct(GROUP_VISIBLE)};
82         @visible_to_me_current = @{$group->granted_by_direct(GROUP_VISIBLE)};
83     }
84
85     # Figure out what groups are not currently a member of this group,
86     # and what groups this group is not currently a member of.
87     my (@members_available, @member_of_available,
88         @bless_from_available, @bless_to_available,
89         @visible_from_available, @visible_to_me_available);
90     foreach my $group_option (@all_groups) {
91         if (Bugzilla->params->{'usevisibilitygroups'}) {
92             push(@visible_from_available, $group_option)
93                 if !grep($_->id == $group_option->id, @visible_from_current);
94             push(@visible_to_me_available, $group_option)
95                 if !grep($_->id == $group_option->id, @visible_to_me_current);
96         }
97
98         push(@bless_from_available, $group_option)
99             if !grep($_->id == $group_option->id, @bless_from_current);
100
101         # The group itself should never show up in the membership lists,
102         # and should show up in only one of the bless lists (otherwise
103         # you can try to allow it to bless itself twice, leading to a
104         # database unique constraint error).
105         next if $group_option->id == $group->id;
106
107         push(@members_available, $group_option)
108             if !grep($_->id == $group_option->id, @members_current);
109         push(@member_of_available, $group_option)
110             if !grep($_->id == $group_option->id, @member_of_current);
111         push(@bless_to_available, $group_option)
112            if !grep($_->id == $group_option->id, @bless_to_current);
113     }
114
115     $vars->{'members_current'}     = \@members_current;
116     $vars->{'members_available'}   = \@members_available;
117     $vars->{'member_of_current'}   = \@member_of_current;
118     $vars->{'member_of_available'} = \@member_of_available;
119
120     $vars->{'bless_from_current'}   = \@bless_from_current;
121     $vars->{'bless_from_available'} = \@bless_from_available;
122     $vars->{'bless_to_current'}     = \@bless_to_current;
123     $vars->{'bless_to_available'}   = \@bless_to_available;
124
125     if (Bugzilla->params->{'usevisibilitygroups'}) {
126         $vars->{'visible_from_current'}    = \@visible_from_current;
127         $vars->{'visible_from_available'}  = \@visible_from_available;
128         $vars->{'visible_to_me_current'}   = \@visible_to_me_current;
129         $vars->{'visible_to_me_available'} = \@visible_to_me_available;
130     }
131 }
132
133 # If no action is specified, get a list of all groups available.
134
135 unless ($action) {
136     my @groups = Bugzilla::Group->get_all;
137     $vars->{'groups'} = \@groups;
138
139     $template->process("admin/groups/list.html.tmpl", $vars)
140       || ThrowTemplateError($template->error());
141     exit;
142 }
143
144 #
145 # action='changeform' -> present form for altering an existing group
146 #
147 # (next action will be 'postchanges')
148 #
149
150 if ($action eq 'changeform') {
151     # Check that an existing group ID is given
152     my $group_id = CheckGroupID($cgi->param('group'));
153     my $group = new Bugzilla::Group($group_id);
154
155     get_current_and_available($group, $vars);
156     $vars->{'group'} = $group;
157     $vars->{'token'} = issue_session_token('edit_group');
158
159     $template->process("admin/groups/edit.html.tmpl", $vars)
160       || ThrowTemplateError($template->error());
161     exit;
162 }
163
164 #
165 # action='add' -> present form for parameters for new group
166 #
167 # (next action will be 'new')
168 #
169
170 if ($action eq 'add') {
171     $vars->{'token'} = issue_session_token('add_group');
172
173     $template->process("admin/groups/create.html.tmpl", $vars)
174       || ThrowTemplateError($template->error());
175     exit;
176 }
177
178
179
180 #
181 # action='new' -> add group entered in the 'action=add' screen
182 #
183
184 if ($action eq 'new') {
185     check_token_data($token, 'add_group');
186     my $group = Bugzilla::Group->create({
187         name        => scalar $cgi->param('name'),
188         description => scalar $cgi->param('desc'),
189         userregexp  => scalar $cgi->param('regexp'),
190         isactive    => scalar $cgi->param('isactive'),
191         icon_url    => scalar $cgi->param('icon_url'),
192         isbuggroup  => 1,
193         use_in_all_products => scalar $cgi->param('insertnew'),
194     });
195
196     delete_token($token);
197
198     $vars->{'message'} = 'group_created';
199     $vars->{'group'} = $group;
200     get_current_and_available($group, $vars);
201     $vars->{'token'} = issue_session_token('edit_group');
202
203     $template->process("admin/groups/edit.html.tmpl", $vars)
204       || ThrowTemplateError($template->error());
205     exit;
206 }
207
208 #
209 # action='del' -> ask if user really wants to delete
210 #
211 # (next action would be 'delete')
212 #
213
214 if ($action eq 'del') {
215     # Check that an existing group ID is given
216     my $group = Bugzilla::Group->check({ id => scalar $cgi->param('group') });
217     $group->check_remove({ test_only => 1 });
218     $vars->{'shared_queries'} =
219         $dbh->selectrow_array('SELECT COUNT(*)
220                                  FROM namedquery_group_map
221                                 WHERE group_id = ?', undef, $group->id);
222
223     $vars->{'group'} = $group;
224     $vars->{'token'} = issue_session_token('delete_group');
225
226     $template->process("admin/groups/delete.html.tmpl", $vars)
227       || ThrowTemplateError($template->error());
228     exit;
229 }
230
231 #
232 # action='delete' -> really delete the group
233 #
234
235 if ($action eq 'delete') {
236     check_token_data($token, 'delete_group');
237     # Check that an existing group ID is given
238     my $group = Bugzilla::Group->check({ id => scalar $cgi->param('group') });
239     $vars->{'name'} = $group->name;
240     $group->remove_from_db({
241         remove_from_users => scalar $cgi->param('removeusers'),
242         remove_from_bugs  => scalar $cgi->param('removebugs'),
243         remove_from_flags => scalar $cgi->param('removeflags'),
244         remove_from_products => scalar $cgi->param('unbind'),
245     });
246     delete_token($token);
247
248     $vars->{'message'} = 'group_deleted';
249     $vars->{'groups'} = [Bugzilla::Group->get_all];
250
251     $template->process("admin/groups/list.html.tmpl", $vars)
252       || ThrowTemplateError($template->error());
253     exit;
254 }
255
256 #
257 # action='postchanges' -> update the groups
258 #
259
260 if ($action eq 'postchanges') {
261     check_token_data($token, 'edit_group');
262     my $changes = doGroupChanges();
263     delete_token($token);
264
265     my $group = new Bugzilla::Group($cgi->param('group_id'));
266     get_current_and_available($group, $vars);
267     $vars->{'message'} = 'group_updated';
268     $vars->{'group'}   = $group;
269     $vars->{'changes'} = $changes;
270     $vars->{'token'} = issue_session_token('edit_group');
271
272     $template->process("admin/groups/edit.html.tmpl", $vars)
273       || ThrowTemplateError($template->error());
274     exit;
275 }
276
277 if ($action eq 'confirm_remove') {
278     my $group = new Bugzilla::Group(CheckGroupID($cgi->param('group_id')));
279     $vars->{'group'} = $group;
280     $vars->{'regexp'} = CheckGroupRegexp($cgi->param('regexp'));
281     $vars->{'token'} = issue_session_token('remove_group_members');
282
283     $template->process('admin/groups/confirm-remove.html.tmpl', $vars)
284         || ThrowTemplateError($template->error());
285     exit;
286 }
287
288 if ($action eq 'remove_regexp') {
289     check_token_data($token, 'remove_group_members');
290     # remove all explicit users from the group with
291     # gid = $cgi->param('group') that match the regular expression
292     # stored in the DB for that group or all of them period
293
294     my $group  = new Bugzilla::Group(CheckGroupID($cgi->param('group_id')));
295     my $regexp = CheckGroupRegexp($cgi->param('regexp'));
296
297     $dbh->bz_start_transaction();
298
299     my $users = $group->members_direct();
300     my $sth_delete = $dbh->prepare(
301         "DELETE FROM user_group_map
302            WHERE user_id = ? AND isbless = 0 AND group_id = ?");
303
304     my @deleted;
305     foreach my $member (@$users) {
306         if ($regexp eq '' || $member->login =~ m/$regexp/i) {
307             $sth_delete->execute($member->id, $group->id);
308             push(@deleted, $member);
309         }
310     }
311     $dbh->bz_commit_transaction();
312
313     $vars->{'users'}  = \@deleted;
314     $vars->{'regexp'} = $regexp;
315     delete_token($token);
316
317     $vars->{'message'} = 'group_membership_removed';
318     $vars->{'group'} = $group->name;
319     $vars->{'groups'} = [Bugzilla::Group->get_all];
320
321     $template->process("admin/groups/list.html.tmpl", $vars)
322       || ThrowTemplateError($template->error());
323     exit;
324 }
325
326 # No valid action found
327 ThrowUserError('unknown_action', {action => $action});
328
329 # Helper sub to handle the making of changes to a group
330 sub doGroupChanges {
331     my $cgi = Bugzilla->cgi;
332     my $dbh = Bugzilla->dbh;
333
334     $dbh->bz_start_transaction();
335
336     # Check that the given group ID is valid and make a Group.
337     my $group = new Bugzilla::Group(CheckGroupID($cgi->param('group_id')));
338
339     if (defined $cgi->param('regexp')) {
340         $group->set_user_regexp($cgi->param('regexp'));
341     }
342
343     if ($group->is_bug_group) {
344         if (defined $cgi->param('name')) {
345             $group->set_name($cgi->param('name'));
346         }
347         if (defined $cgi->param('desc')) {
348             $group->set_description($cgi->param('desc'));
349         }
350         # Only set isactive if we came from the right form.
351         if (defined $cgi->param('regexp')) {
352             $group->set_is_active($cgi->param('isactive'));
353         }
354     }
355
356     if (defined $cgi->param('icon_url')) {
357         $group->set_icon_url($cgi->param('icon_url'));
358     }
359
360     my $changes = $group->update();
361
362     my $sth_insert = $dbh->prepare('INSERT INTO group_group_map
363                                     (member_id, grantor_id, grant_type)
364                                     VALUES (?, ?, ?)');
365
366     my $sth_delete = $dbh->prepare('DELETE FROM group_group_map
367                                      WHERE member_id = ?
368                                            AND grantor_id = ?
369                                            AND grant_type = ?');
370
371     # First item is the type, second is whether or not it's "reverse" 
372     # (granted_by) (see _do_add for more explanation).
373     my %fields = (
374         members       => [GROUP_MEMBERSHIP, 0],
375         bless_from    => [GROUP_BLESS, 0],
376         visible_from  => [GROUP_VISIBLE, 0],
377         member_of     => [GROUP_MEMBERSHIP, 1],
378         bless_to      => [GROUP_BLESS, 1],
379         visible_to_me => [GROUP_VISIBLE, 1]
380     );
381     while (my ($field, $data) = each %fields) {
382         _do_add($group, $changes, $sth_insert, "${field}_add", 
383                 $data->[0], $data->[1]);
384         _do_remove($group, $changes, $sth_delete, "${field}_remove",
385                    $data->[0], $data->[1]);
386     }
387
388     $dbh->bz_commit_transaction();
389     return $changes;
390 }
391
392 sub _do_add {
393     my ($group, $changes, $sth_insert, $field, $type, $reverse) = @_;
394     my $cgi = Bugzilla->cgi;
395
396     my $current;
397     # $reverse means we're doing a granted_by--that is, somebody else
398     # is granting us something.
399     if ($reverse) {
400         $current = $group->granted_by_direct($type);
401     }
402     else {
403         $current = $group->grant_direct($type);
404     }
405
406     my $add_items = Bugzilla::Group->new_from_list([$cgi->param($field)]);
407
408     foreach my $add (@$add_items) {
409         next if grep($_->id == $add->id, @$current);
410
411         $changes->{$field} ||= [];
412         push(@{$changes->{$field}}, $add->name);
413         # They go this direction for a normal "This group is granting
414         # $add something."
415         my @ids = ($add->id, $group->id);
416         # But they get reversed for "This group is being granted something
417         # by $add."
418         @ids = reverse @ids if $reverse;
419         $sth_insert->execute(@ids, $type);
420     }
421 }
422
423 sub _do_remove {
424     my ($group, $changes, $sth_delete, $field, $type, $reverse) = @_;
425     my $cgi = Bugzilla->cgi;
426     my $remove_items = Bugzilla::Group->new_from_list([$cgi->param($field)]);
427
428     foreach my $remove (@$remove_items) {
429         my @ids = ($remove->id, $group->id);
430         # See _do_add for an explanation of $reverse
431         @ids = reverse @ids if $reverse;
432         # Deletions always succeed and are harmless if they fail, so we
433         # don't need to do any checks.
434         $sth_delete->execute(@ids, $type);
435         $changes->{$field} ||= [];
436         push(@{$changes->{$field}}, $remove->name);
437     }
438 }