rt/lib/RT/System.pm

   1 # BEGIN BPS TAGGED BLOCK {{{
   2 #
   3 # COPYRIGHT:
   4 #
   5 # This software is Copyright (c) 1996-2016 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::System
  52
  53 =head1 DESCRIPTION
  54
  55 RT::System is a simple global object used as a focal point for things
  56 that are system-wide.
  57
  58 It works sort of like an RT::Record, except it's really a single object that has
  59 an id of "1" when instantiated.
  60
  61 This gets used by the ACL system so that you can have rights for the scope "RT::System"
  62
  63 In the future, there will probably be other API goodness encapsulated here.
  64
  65 =cut
  66
  67
  68 package RT::System;
  69
  70 use strict;
  71 use warnings;
  72
  73 use base qw/RT::Record/;
  74
  75 use Role::Basic 'with';
  76 with "RT::Record::Role::Roles",
  77      "RT::Record::Role::Rights" => { -excludes => [qw/AvailableRights RightCategories/] };
  78
  79 use RT::ACL;
  80 use RT::ACE;
  81 use Data::GUID;
  82
  83 __PACKAGE__->AddRight( Admin   => SuperUser           => 'Do anything and everything'); # loc
  84 __PACKAGE__->AddRight( Staff   => ShowUserHistory     => 'Show history of public user properties'); # loc
  85 __PACKAGE__->AddRight( Admin   => AdminUsers          => 'Create, modify and delete users'); # loc
  86 __PACKAGE__->AddRight( Staff   => ModifySelf          => "Modify one's own RT account"); # loc
  87 __PACKAGE__->AddRight( Staff   => ShowArticlesMenu    => 'Show Articles menu'); # loc
  88 __PACKAGE__->AddRight( Admin   => ShowConfigTab       => 'Show Admin menu'); # loc
  89 __PACKAGE__->AddRight( Admin   => ShowApprovalsTab    => 'Show Approvals tab'); # loc
  90 __PACKAGE__->AddRight( Staff   => ShowGlobalTemplates => 'Show global templates'); # loc
  91 __PACKAGE__->AddRight( General => LoadSavedSearch     => 'Allow loading of saved searches'); # loc
  92 __PACKAGE__->AddRight( General => CreateSavedSearch   => 'Allow creation of saved searches'); # loc
  93 __PACKAGE__->AddRight( Admin   => ExecuteCode         => 'Allow writing Perl code in templates, scrips, etc'); # loc
  94
  95 =head2 AvailableRights
  96
  97 Returns a hashref of available rights for this object.  The keys are the
  98 right names and the values are a description of what the rights do.
  99
 100 This method as well returns rights of other RT objects, like
 101 L<RT::Queue> or L<RT::Group>, to allow users to apply those rights
 102 globally.
 103
 104 If an L<RT::Principal> is passed as the first argument, the available
 105 rights will be limited to ones which make sense for the principal.
 106 Currently only role groups are supported and rights announced by object
 107 types to which the role group doesn't apply are not returned.
 108
 109 =cut
 110
 111 sub AvailableRights {
 112     my $self = shift;
 113     my $principal = shift;
 114     my $class = ref($self) || $self;
 115
 116     my @rights;
 117     if ($principal and $principal->IsRoleGroup) {
 118         my $role = $principal->Object->Name;
 119         for my $class (keys %RT::ACE::RIGHTS) {
 120             next unless $class->DOES('RT::Record::Role::Roles') and $class->HasRole($role) and $class ne "RT::System";
 121             push @rights, values %{ $RT::ACE::RIGHTS{$class} };
 122         }
 123     } else {
 124         @rights = map {values %{$_}} values %RT::ACE::RIGHTS;
 125     }
 126
 127     my %rights;
 128     $rights{$_->{Name}} = $_->{Description} for @rights;
 129
 130     delete $rights{ExecuteCode} if RT->Config->Get('DisallowExecuteCode');
 131
 132     return \%rights;
 133 }
 134
 135 =head2 RightCategories
 136
 137 Returns a hashref where the keys are rights for this type of object and the
 138 values are the category (General, Staff, Admin) the right falls into.
 139
 140 =cut
 141
 142 sub RightCategories {
 143     my $self = shift;
 144     my $class = ref($self) || $self;
 145
 146     my %rights;
 147     $rights{$_->{Name}} = $_->{Category}
 148         for map {values %{$_}} values %RT::ACE::RIGHTS;
 149     return \%rights;
 150 }
 151
 152 sub _Init {
 153     my $self = shift;
 154     $self->SUPER::_Init (@_) if @_ && $_[0];
 155 }
 156
 157 =head2 id
 158
 159 Returns RT::System's id. It's 1.
 160
 161 =cut
 162
 163 *Id = \&id;
 164 sub id { return 1 }
 165
 166 sub UID { return "RT::System" }
 167
 168 =head2 Load
 169
 170 Since this object is pretending to be an RT::Record, we need a load method.
 171 It does nothing
 172
 173 =cut
 174
 175 sub Load    { return 1 }
 176 sub Name    { return 'RT System' }
 177 sub __Set   { return 0 }
 178 sub __Value { return 0 }
 179 sub Create  { return 0 }
 180 sub Delete  { return 0 }
 181
 182 sub SubjectTag {
 183     my $self = shift;
 184     my $queue = shift;
 185
 186     use Carp;
 187     confess "SubjectTag called on $self with $queue" if $queue;
 188
 189     return $queue->SubjectTag if $queue;
 190
 191     my $queues = RT::Queues->new( $self->CurrentUser );
 192     $queues->Limit( FIELD => 'SubjectTag', OPERATOR => 'IS NOT', VALUE => 'NULL' );
 193     return $queues->DistinctFieldValues('SubjectTag');
 194 }
 195
 196 =head2 QueueCacheNeedsUpdate ( 1 )
 197
 198 Attribute to decide when SelectQueue needs to flush the list of queues
 199 and retrieve new ones.  Set when queues are created, enabled/disabled
 200 and on certain acl changes.  Should also better understand group management.
 201
 202 If passed a true value, will update the attribute to be the current time.
 203
 204 =cut
 205
 206 sub QueueCacheNeedsUpdate {
 207     my $self = shift;
 208     my $update = shift;
 209
 210     if ($update) {
 211         return $self->SetAttribute(Name => 'QueueCacheNeedsUpdate', Content => time);
 212     } else {
 213         my $cache = $self->FirstAttribute('QueueCacheNeedsUpdate');
 214         return (defined $cache ? $cache->Content : 0 );
 215     }
 216 }
 217
 218 =head2 AddUpgradeHistory package, data
 219
 220 Adds an entry to the upgrade history database. The package can be either C<RT>
 221 for core RT upgrades, or the fully qualified name of a plugin. The data must be
 222 a hash reference.
 223
 224 =cut
 225
 226 sub AddUpgradeHistory {
 227     my $self  = shift;
 228     my $package = shift;
 229     my $data  = shift;
 230
 231     $data->{timestamp}  ||= time;
 232     $data->{rt_version} ||= $RT::VERSION;
 233
 234     my $upgrade_history_attr = $self->FirstAttribute('UpgradeHistory');
 235     my $upgrade_history = $upgrade_history_attr ? $upgrade_history_attr->Content : {};
 236
 237     push @{ $upgrade_history->{$package} }, $data;
 238
 239     $self->SetAttribute(
 240         Name    => 'UpgradeHistory',
 241         Content => $upgrade_history,
 242     );
 243 }
 244
 245 =head2 UpgradeHistory [package]
 246
 247 Returns the entries of RT's upgrade history. If a package is specified, the list
 248 of upgrades for that package will be returned. Otherwise a hash reference of
 249 C<< package => [upgrades] >> will be returned.
 250
 251 =cut
 252
 253 sub UpgradeHistory {
 254     my $self  = shift;
 255     my $package = shift;
 256
 257     my $upgrade_history_attr = $self->FirstAttribute('UpgradeHistory');
 258     my $upgrade_history = $upgrade_history_attr ? $upgrade_history_attr->Content : {};
 259
 260     if ($package) {
 261         return @{ $upgrade_history->{$package} || [] };
 262     }
 263
 264     return $upgrade_history;
 265 }
 266
 267 sub ParsedUpgradeHistory {
 268     my $self = shift;
 269     my $package = shift;
 270
 271     my $version_status = "Current version: ";
 272     if ( $package eq 'RT' ){
 273         $version_status .= $RT::VERSION;
 274     } elsif ( grep {/$package/} @{RT->Config->Get('Plugins')} ) {
 275         no strict 'refs';
 276         $version_status .= ${ $package . '::VERSION' };
 277     } else {
 278         $version_status = "Not currently loaded";
 279     }
 280
 281     my %ids;
 282     my @lines;
 283
 284     my @events = $self->UpgradeHistory( $package );
 285     for my $event (@events) {
 286         if ($event->{stage} eq 'before' or (($event->{action}||'') eq 'insert' and not $event->{full_id})) {
 287             if (not $event->{full_id}) {
 288                 # For upgrade done in the 4.1 series without GUIDs
 289                 if (($event->{type}||'') eq 'full upgrade') {
 290                     $event->{full_id} = $event->{individual_id} = Data::GUID->new->as_string;
 291                 } else {
 292                     $event->{individual_id} = Data::GUID->new->as_string;
 293                     $event->{full_id} = (@lines ? $lines[-1]{full_id} : Data::GUID->new->as_string);
 294                 }
 295                 $event->{return_value} = [1] if $event->{stage} eq 'after';
 296             }
 297             if ($ids{$event->{full_id}}) {
 298                 my $kids = $ids{$event->{full_id}}{sub_events} ||= [];
 299                 # Stitch non-"upgrade"s beneath the previous "upgrade"
 300                 if ( @{$kids} and $event->{action} ne 'upgrade' and $kids->[-1]{action} eq 'upgrade') {
 301                     push @{ $kids->[-1]{sub_events} }, $event;
 302                 } else {
 303                     push @{ $kids }, $event;
 304                 }
 305             } else {
 306                 push @lines, $event;
 307             }
 308             $ids{$event->{individual_id}} = $event;
 309         } elsif ($event->{stage} eq 'after') {
 310             if (not $event->{individual_id}) {
 311                 if (($event->{type}||'') eq 'full upgrade') {
 312                     $lines[-1]{end} = $event->{timestamp} if @lines;
 313                 } elsif (($event->{type}||'') eq 'individual upgrade') {
 314                     $lines[-1]{sub_events}[-1]{end} = $event->{timestamp}
 315                         if @lines and @{ $lines[-1]{sub_events} };
 316                 }
 317             } elsif ($ids{$event->{individual_id}}) {
 318                 my $end = $event;
 319                 $event = $ids{$event->{individual_id}};
 320                 $event->{end} = $end->{timestamp};
 321
 322                 $end->{return_value} = [ split ', ', $end->{return_value}, 2 ]
 323                     if $end->{return_value} and not ref $end->{return_value};
 324                 $event->{return_value} = $end->{return_value};
 325                 $event->{content} ||= $end->{content};
 326             }
 327         }
 328     }
 329
 330     return ($version_status, @lines);
 331 }
 332
 333
 334 RT::Base->_ImportOverlays();
 335
 336 1;