Upgrade to 4.0.13
[usit-rt.git] / lib / RT / Dashboard.pm
1 # BEGIN BPS TAGGED BLOCK {{{
2 #
3 # COPYRIGHT:
4 #
5 # This software is Copyright (c) 1996-2013 Best Practical Solutions, LLC
6 #                                          <sales@bestpractical.com>
7 #
8 # (Except where explicitly superseded by other copyright notices)
9 #
10 #
11 # LICENSE:
12 #
13 # This work is made available to you under the terms of Version 2 of
14 # the GNU General Public License. A copy of that license should have
15 # been provided with this software, but in any event can be snarfed
16 # from www.gnu.org.
17 #
18 # This work is distributed in the hope that it will be useful, but
19 # WITHOUT ANY WARRANTY; without even the implied warranty of
20 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21 # General Public License for more details.
22 #
23 # You should have received a copy of the GNU General Public License
24 # along with this program; if not, write to the Free Software
25 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
26 # 02110-1301 or visit their web page on the internet at
27 # http://www.gnu.org/licenses/old-licenses/gpl-2.0.html.
28 #
29 #
30 # CONTRIBUTION SUBMISSION POLICY:
31 #
32 # (The following paragraph is not intended to limit the rights granted
33 # to you to modify and distribute this software under the terms of
34 # the GNU General Public License and is only of importance to you if
35 # you choose to contribute your changes and enhancements to the
36 # community by submitting them to Best Practical Solutions, LLC.)
37 #
38 # By intentionally submitting any modifications, corrections or
39 # derivatives to this work, or any other work intended for use with
40 # Request Tracker, to Best Practical Solutions, LLC, you confirm that
41 # you are the copyright holder for those contributions and you grant
42 # Best Practical Solutions,  LLC a nonexclusive, worldwide, irrevocable,
43 # royalty-free, perpetual, license to use, copy, create derivative
44 # works based on those contributions, and sublicense and distribute
45 # those contributions and any derivatives thereof.
46 #
47 # END BPS TAGGED BLOCK }}}
48
49 =head1 NAME
50
51   RT::Dashboard - an API for saving and retrieving dashboards
52
53 =head1 SYNOPSIS
54
55   use RT::Dashboard
56
57 =head1 DESCRIPTION
58
59   Dashboard is an object that can belong to either an RT::User or an
60   RT::Group.  It consists of an ID, a name, and a number of
61   saved searches and portlets.
62
63 =head1 METHODS
64
65
66 =cut
67
68 package RT::Dashboard;
69
70 use RT::SavedSearch;
71
72 use strict;
73 use warnings;
74
75 use base qw/RT::SharedSetting/;
76
77 use RT::System;
78 RT::System::AddRights(
79     SubscribeDashboard => 'Subscribe to dashboards', #loc_pair
80
81     SeeDashboard       => 'View system dashboards', #loc_pair
82     CreateDashboard    => 'Create system dashboards', #loc_pair
83     ModifyDashboard    => 'Modify system dashboards', #loc_pair
84     DeleteDashboard    => 'Delete system dashboards', #loc_pair
85
86     SeeOwnDashboard    => 'View personal dashboards', #loc_pair
87     CreateOwnDashboard => 'Create personal dashboards', #loc_pair
88     ModifyOwnDashboard => 'Modify personal dashboards', #loc_pair
89     DeleteOwnDashboard => 'Delete personal dashboards', #loc_pair
90 );
91
92 RT::System::AddRightCategories(
93     SubscribeDashboard => 'Staff',
94
95     SeeDashboard       => 'General',
96     CreateDashboard    => 'Admin',
97     ModifyDashboard    => 'Admin',
98     DeleteDashboard    => 'Admin',
99
100     SeeOwnDashboard    => 'Staff',
101     CreateOwnDashboard => 'Staff',
102     ModifyOwnDashboard => 'Staff',
103     DeleteOwnDashboard => 'Staff',
104 );
105
106 =head2 ObjectName
107
108 An object of this class is called "dashboard"
109
110 =cut
111
112 sub ObjectName { "dashboard" } # loc
113
114 sub SaveAttribute {
115     my $self   = shift;
116     my $object = shift;
117     my $args   = shift;
118
119     return $object->AddAttribute(
120         'Name'        => 'Dashboard',
121         'Description' => $args->{'Name'},
122         'Content'     => {Panes => $args->{'Panes'}},
123     );
124 }
125
126 sub UpdateAttribute {
127     my $self = shift;
128     my $args = shift;
129
130     my ($status, $msg) = (1, undef);
131     if (defined $args->{'Panes'}) {
132         ($status, $msg) = $self->{'Attribute'}->SetSubValues(
133             Panes => $args->{'Panes'},
134         );
135     }
136
137     if ($status && $args->{'Name'}) {
138         ($status, $msg) = $self->{'Attribute'}->SetDescription($args->{'Name'})
139             unless $self->Name eq $args->{'Name'};
140     }
141
142     if ($status && $args->{'Privacy'}) {
143         my ($new_obj_type, $new_obj_id) = split /-/, $args->{'Privacy'};
144         my ($obj_type, $obj_id) = split /-/, $self->Privacy;
145
146         my $attr = $self->{'Attribute'};
147         if ($new_obj_type ne $obj_type) {
148             ($status, $msg) = $attr->SetObjectType($new_obj_type);
149         }
150         if ($status && $new_obj_id != $obj_id ) {
151             ($status, $msg) = $attr->SetObjectId($new_obj_id);
152         }
153         $self->{'Privacy'} = $args->{'Privacy'} if $status;
154     }
155
156     return ($status, $msg);
157 }
158
159 =head2 PostLoadValidate
160
161 Ensure that the ID corresponds to an actual dashboard object, since it's all
162 attributes under the hood.
163
164 =cut
165
166 sub PostLoadValidate {
167     my $self = shift;
168     return (0, "Invalid object type") unless $self->{'Attribute'}->Name eq 'Dashboard';
169     return 1;
170 }
171
172 =head2 Panes
173
174 Returns a hashref of pane name to portlets
175
176 =cut
177
178 sub Panes {
179     my $self = shift;
180     return unless ref($self->{'Attribute'}) eq 'RT::Attribute';
181     return $self->{'Attribute'}->SubValue('Panes') || {};
182 }
183
184 =head2 Portlets
185
186 Returns the list of this dashboard's portlets, each a hashref with key
187 C<portlet_type> being C<search> or C<component>.
188
189 =cut
190
191 sub Portlets {
192     my $self = shift;
193     return map { @$_ } values %{ $self->Panes };
194 }
195
196 =head2 Dashboards
197
198 Returns a list of loaded sub-dashboards
199
200 =cut
201
202 sub Dashboards {
203     my $self = shift;
204     return map {
205         my $search = RT::Dashboard->new($self->CurrentUser);
206         $search->LoadById($_->{id});
207         $search
208     } grep { $_->{portlet_type} eq 'dashboard' } $self->Portlets;
209 }
210
211 =head2 Searches
212
213 Returns a list of loaded saved searches
214
215 =cut
216
217 sub Searches {
218     my $self = shift;
219     return map {
220         my $search = RT::SavedSearch->new($self->CurrentUser);
221         $search->Load($_->{privacy}, $_->{id});
222         $search
223     } grep { $_->{portlet_type} eq 'search' } $self->Portlets;
224 }
225
226 =head2 ShowSearchName Portlet
227
228 Returns an array for one saved search, suitable for passing to
229 /Elements/ShowSearch.
230
231 =cut
232
233 sub ShowSearchName {
234     my $self = shift;
235     my $portlet = shift;
236
237     if ($portlet->{privacy} eq 'RT::System') {
238         return Name => $portlet->{description};
239     }
240
241     return SavedSearch => join('-', $portlet->{privacy}, 'SavedSearch', $portlet->{id});
242 }
243
244 =head2 PossibleHiddenSearches
245
246 This will return a list of saved searches that are potentially not visible by
247 all users for whom the dashboard is visible. You may pass in a privacy to
248 use instead of the dashboard's privacy.
249
250 =cut
251
252 sub PossibleHiddenSearches {
253     my $self = shift;
254     my $privacy = shift || $self->Privacy;
255
256     return grep { !$_->IsVisibleTo($privacy) } $self->Searches, $self->Dashboards;
257 }
258
259 # _PrivacyObjects: returns a list of objects that can be used to load
260 # dashboards from. You probably want to use the wrapper methods like
261 # ObjectsForLoading, ObjectsForCreating, etc.
262
263 sub _PrivacyObjects {
264     my $self = shift;
265
266     my @objects;
267
268     my $CurrentUser = $self->CurrentUser;
269     push @objects, $CurrentUser->UserObj;
270
271     my $groups = RT::Groups->new($CurrentUser);
272     $groups->LimitToUserDefinedGroups;
273     $groups->WithMember( PrincipalId => $CurrentUser->Id,
274                          Recursively => 1 );
275     push @objects, @{ $groups->ItemsArrayRef };
276
277     push @objects, RT::System->new($CurrentUser);
278
279     return @objects;
280 }
281
282 # ACLs
283
284 sub _CurrentUserCan {
285     my $self    = shift;
286     my $privacy = shift || $self->Privacy;
287     my %args    = @_;
288
289     if (!defined($privacy)) {
290         $RT::Logger->debug("No privacy provided to $self->_CurrentUserCan");
291         return 0;
292     }
293
294     my $object = $self->_GetObject($privacy);
295     return 0 unless $object;
296
297     my $level;
298
299        if ($object->isa('RT::User'))   { $level = 'Own' }
300     elsif ($object->isa('RT::Group'))  { $level = 'Group' }
301     elsif ($object->isa('RT::System')) { $level = '' }
302     else {
303         $RT::Logger->error("Unknown object $object from privacy $privacy");
304         return 0;
305     }
306
307     # users are mildly special-cased, since we actually have to check that
308     # the user is operating on himself
309     if ($object->isa('RT::User')) {
310         return 0 unless $object->Id == $self->CurrentUser->Id;
311     }
312
313     my $right = $args{FullRight}
314              || join('', $args{Right}, $level, 'Dashboard');
315
316     # all rights, except group rights, are global
317     $object = $RT::System unless $object->isa('RT::Group');
318
319     return $self->CurrentUser->HasRight(
320         Right  => $right,
321         Object => $object,
322     );
323 }
324
325 sub CurrentUserCanSee {
326     my $self    = shift;
327     my $privacy = shift;
328
329     $self->_CurrentUserCan($privacy, Right => 'See');
330 }
331
332 sub CurrentUserCanCreate {
333     my $self    = shift;
334     my $privacy = shift;
335
336     $self->_CurrentUserCan($privacy, Right => 'Create');
337 }
338
339 sub CurrentUserCanModify {
340     my $self    = shift;
341     my $privacy = shift;
342
343     $self->_CurrentUserCan($privacy, Right => 'Modify');
344 }
345
346 sub CurrentUserCanDelete {
347     my $self    = shift;
348     my $privacy = shift;
349
350     $self->_CurrentUserCan($privacy, Right => 'Delete');
351 }
352
353 sub CurrentUserCanSubscribe {
354     my $self    = shift;
355     my $privacy = shift;
356
357     $self->_CurrentUserCan($privacy, FullRight => 'SubscribeDashboard');
358 }
359
360 =head2 Subscription
361
362 Returns the L<RT::Attribute> representing the current user's subscription
363 to this dashboard if there is one; otherwise, returns C<undef>.
364
365 =cut
366
367 sub Subscription {
368     my $self = shift;
369
370     # no subscription to unloaded dashboards
371     return unless $self->id;
372
373     for my $sub ($self->CurrentUser->UserObj->Attributes->Named('Subscription')) {
374         return $sub if $sub->SubValue('DashboardId') == $self->id;
375     }
376
377     return;
378 }
379
380 sub ObjectsForLoading {
381     my $self = shift;
382     my %args = (
383         IncludeSuperuserGroups => 1,
384         @_
385     );
386     my @objects;
387
388     # If you've been granted the SeeOwnDashboard global right (which you
389     # could have by way of global user right or global group right), you
390     # get to see your own dashboards
391     my $CurrentUser = $self->CurrentUser;
392     push @objects, $CurrentUser->UserObj
393         if $CurrentUser->HasRight(Object => $RT::System, Right => 'SeeOwnDashboard');
394
395     # Find groups for which: (a) you are a member of the group, and (b)
396     # you have been granted SeeGroupDashboard on (by any means), and (c)
397     # have at least one dashboard
398     my $groups = RT::Groups->new($CurrentUser);
399     $groups->LimitToUserDefinedGroups;
400     $groups->ForWhichCurrentUserHasRight(
401         Right             => 'SeeGroupDashboard',
402         IncludeSuperusers => $args{IncludeSuperuserGroups},
403     );
404     $groups->WithMember(
405         Recursively => 1,
406         PrincipalId => $CurrentUser->UserObj->PrincipalId
407     );
408     my $attrs = $groups->Join(
409         ALIAS1 => 'main',
410         FIELD1 => 'id',
411         TABLE2 => 'Attributes',
412         FIELD2 => 'ObjectId',
413     );
414     $groups->Limit(
415         ALIAS => $attrs,
416         FIELD => 'ObjectType',
417         VALUE => 'RT::Group',
418     );
419     $groups->Limit(
420         ALIAS => $attrs,
421         FIELD => 'Name',
422         VALUE => 'Dashboard',
423     );
424     push @objects, @{ $groups->ItemsArrayRef };
425
426     # Finally, if you have been granted the SeeDashboard right (which
427     # you could have by way of global user right or global group right),
428     # you can see system dashboards.
429     push @objects, RT::System->new($CurrentUser)
430         if $CurrentUser->HasRight(Object => $RT::System, Right => 'SeeDashboard');
431
432     return @objects;
433 }
434
435 sub CurrentUserCanCreateAny {
436     my $self = shift;
437     my @objects;
438
439     my $CurrentUser = $self->CurrentUser;
440     return 1
441         if $CurrentUser->HasRight(Object => $RT::System, Right => 'CreateOwnDashboard');
442
443     my $groups = RT::Groups->new($CurrentUser);
444     $groups->LimitToUserDefinedGroups;
445     $groups->ForWhichCurrentUserHasRight(
446         Right             => 'CreateGroupDashboard',
447         IncludeSuperusers => 1,
448     );
449     return 1 if $groups->Count;
450
451     return 1
452         if $CurrentUser->HasRight(Object => $RT::System, Right => 'CreateDashboard');
453
454     return 0;
455 }
456
457 =head2 Delete
458
459 Deletes the dashboard and related subscriptions.
460 Returns a tuple of status and message, where status is true upon success.
461
462 =cut
463
464 sub Delete {
465     my $self = shift;
466     my $id = $self->id;
467     my ( $status, $msg ) = $self->SUPER::Delete(@_);
468     if ( $status ) {
469         # delete all the subscriptions
470         my $subscriptions = RT::Attributes->new( RT->SystemUser );
471         $subscriptions->Limit(
472             FIELD => 'Name',
473             VALUE => 'Subscription',
474         );
475         $subscriptions->Limit(
476             FIELD => 'Description',
477             VALUE => "Subscription to dashboard $id",
478         );
479         while ( my $subscription = $subscriptions->Next ) {
480             $subscription->Delete();
481         }
482     }
483
484     return ( $status, $msg );
485 }
486
487 RT::Base->_ImportOverlays();
488
489 1;