rt/lib/RT/Principal.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 #
  50
  51 package RT::Principal;
  52
  53 use strict;
  54 use warnings;
  55
  56
  57 use base 'RT::Record';
  58
  59 sub Table {'Principals'}
  60
  61
  62
  63 use Cache::Simple::TimedExpiry;
  64
  65
  66 use RT;
  67 use RT::Group;
  68 use RT::User;
  69
  70 # Set up the ACL cache on startup
  71 our $_ACL_CACHE;
  72 InvalidateACLCache();
  73
  74
  75 =head2 IsGroup
  76
  77 Returns true if this principal is a group.
  78 Returns undef, otherwise
  79
  80 =cut
  81
  82 sub IsGroup {
  83     my $self = shift;
  84     if ( defined $self->PrincipalType &&
  85             $self->PrincipalType eq 'Group' ) {
  86         return 1;
  87     }
  88     return undef;
  89 }
  90
  91
  92
  93 =head2 IsUser
  94
  95 Returns true if this principal is a User.
  96 Returns undef, otherwise
  97
  98 =cut
  99
 100 sub IsUser {
 101     my $self = shift;
 102     if ($self->PrincipalType eq 'User') {
 103         return(1);
 104     }
 105     else {
 106         return undef;
 107     }
 108 }
 109
 110
 111
 112 =head2 Object
 113
 114 Returns the user or group associated with this principal
 115
 116 =cut
 117
 118 sub Object {
 119     my $self = shift;
 120
 121     unless ( $self->{'object'} ) {
 122         if ( $self->IsUser ) {
 123            $self->{'object'} = RT::User->new($self->CurrentUser);
 124         }
 125         elsif ( $self->IsGroup ) {
 126             $self->{'object'}  = RT::Group->new($self->CurrentUser);
 127         }
 128         else {
 129             $RT::Logger->crit("Found a principal (".$self->Id.") that was neither a user nor a group");
 130             return(undef);
 131         }
 132         $self->{'object'}->Load( $self->ObjectId() );
 133     }
 134     return ($self->{'object'});
 135
 136
 137 }
 138
 139
 140
 141 =head2 GrantRight  { Right => RIGHTNAME, Object => undef }
 142
 143 A helper function which calls RT::ACE->Create
 144
 145
 146
 147    Returns a tuple of (STATUS, MESSAGE);  If the call succeeded, STATUS is true. Otherwise it's
 148    false.
 149
 150 =cut
 151
 152 sub GrantRight {
 153     my $self = shift;
 154     my %args = (
 155         Right => undef,
 156         Object => undef,
 157         @_
 158     );
 159
 160     return (0, "Permission denied") if $args{'Right'} eq 'ExecuteCode'
 161         and RT->Config->Get('DisallowExecuteCode');
 162
 163     #ACL check handled in ACE.pm
 164     my $ace = RT::ACE->new( $self->CurrentUser );
 165
 166     my $type = $self->_GetPrincipalTypeForACL();
 167
 168     RT->System->QueueCacheNeedsUpdate(1) if $args{'Right'} eq 'SeeQueue';
 169
 170     # If it's a user, we really want to grant the right to their
 171     # user equivalence group
 172     return $ace->Create(
 173         RightName     => $args{'Right'},
 174         Object        => $args{'Object'},
 175         PrincipalType => $type,
 176         PrincipalId   => $self->Id,
 177     );
 178 }
 179
 180
 181 =head2 RevokeRight { Right => "RightName", Object => "object" }
 182
 183 Delete a right that a user has
 184
 185
 186    Returns a tuple of (STATUS, MESSAGE);  If the call succeeded, STATUS is true. Otherwise it's
 187       false.
 188
 189
 190 =cut
 191
 192 sub RevokeRight {
 193
 194     my $self = shift;
 195     my %args = (
 196         Right  => undef,
 197         Object => undef,
 198         @_
 199     );
 200
 201     #if we haven't specified any sort of right, we're talking about a global right
 202     if (!defined $args{'Object'} && !defined $args{'ObjectId'} && !defined $args{'ObjectType'}) {
 203         $args{'Object'} = $RT::System;
 204     }
 205     #ACL check handled in ACE.pm
 206     my $type = $self->_GetPrincipalTypeForACL();
 207
 208     my $ace = RT::ACE->new( $self->CurrentUser );
 209     my ($status, $msg) = $ace->LoadByValues(
 210         RightName     => $args{'Right'},
 211         Object        => $args{'Object'},
 212         PrincipalType => $type,
 213         PrincipalId   => $self->Id
 214     );
 215
 216     if ( not $status and $msg =~ /Invalid right/ ) {
 217         $RT::Logger->warn("Tried to revoke the invalid right '$args{Right}', ignoring it.");
 218         return (1);
 219     }
 220
 221     RT->System->QueueCacheNeedsUpdate(1) if $args{'Right'} eq 'SeeQueue';
 222     return ($status, $msg) unless $status;
 223     return $ace->Delete;
 224 }
 225
 226
 227
 228 =head2 HasRight (Right => 'right' Object => undef)
 229
 230 Checks to see whether this principal has the right "Right" for the Object
 231 specified. This takes the params:
 232
 233 =over 4
 234
 235 =item Right
 236
 237 name of a right
 238
 239 =item Object
 240
 241 an RT style object (->id will get its id)
 242
 243 =back
 244
 245 Returns 1 if a matching ACE was found. Returns undef if no ACE was found.
 246
 247 Use L</HasRights> to fill a fast cache, especially if you're going to
 248 check many different rights with the same principal and object.
 249
 250 =cut
 251
 252 sub HasRight {
 253
 254     my $self = shift;
 255     my %args = ( Right        => undef,
 256                  Object       => undef,
 257                  EquivObjects => undef,
 258                  @_,
 259                );
 260
 261     # RT's SystemUser always has all rights
 262     if ( $self->id == RT->SystemUser->id ) {
 263         return 1;
 264     }
 265
 266     $args{'Right'} = RT::ACE->CanonicalizeRightName( $args{'Right'} );
 267     unless ( $args{'Right'} ) {
 268         $RT::Logger->error(
 269                "Invalid right. Couldn't canonicalize right '$args{'Right'}'");
 270         return undef;
 271     }
 272
 273     return undef if $args{'Right'} eq 'ExecuteCode'
 274         and RT->Config->Get('DisallowExecuteCode');
 275
 276     $args{'EquivObjects'} = [ @{ $args{'EquivObjects'} } ]
 277         if $args{'EquivObjects'};
 278
 279     if ( $self->__Value('Disabled') ) {
 280         $RT::Logger->debug(   "Disabled User #"
 281                             . $self->id
 282                             . " failed access check for "
 283                             . $args{'Right'} );
 284         return (undef);
 285     }
 286
 287     if ( eval { $args{'Object'}->id } ) {
 288         push @{ $args{'EquivObjects'} }, $args{'Object'};
 289     } else {
 290         $RT::Logger->crit("HasRight called with no valid object");
 291         return (undef);
 292     }
 293
 294     {
 295         my $cached = $_ACL_CACHE->fetch(
 296             $self->id .';:;'. ref($args{'Object'}) .'-'. $args{'Object'}->id
 297         );
 298         return $cached->{'SuperUser'} || $cached->{ $args{'Right'} }
 299             if $cached;
 300     }
 301
 302     unshift @{ $args{'EquivObjects'} },
 303         $args{'Object'}->ACLEquivalenceObjects;
 304
 305     unshift @{ $args{'EquivObjects'} }, $RT::System
 306         unless $self->can('_IsOverrideGlobalACL')
 307             && $self->_IsOverrideGlobalACL( $args{'Object'} );
 308
 309     # If we've cached a win or loss for this lookup say so
 310
 311 # Construct a hashkeys to cache decisions:
 312 # 1) full_hashkey - key for any result and for full combination of uid, right and objects
 313 # 2) short_hashkey - one key for each object to store positive results only, it applies
 314 # only to direct group rights and partly to role rights
 315     my $full_hashkey = join (";:;", $self->id, $args{'Right'});
 316     foreach ( @{ $args{'EquivObjects'} } ) {
 317         my $ref_id = $self->_ReferenceId($_);
 318         $full_hashkey .= ";:;".$ref_id;
 319
 320         my $short_hashkey = join(";:;", $self->id, $args{'Right'}, $ref_id);
 321         my $cached_answer = $_ACL_CACHE->fetch($short_hashkey);
 322         return $cached_answer > 0 if defined $cached_answer;
 323     }
 324
 325     {
 326         my $cached_answer = $_ACL_CACHE->fetch($full_hashkey);
 327         return $cached_answer > 0 if defined $cached_answer;
 328     }
 329
 330     my ( $hitcount, $via_obj ) = $self->_HasRight(%args);
 331
 332     $_ACL_CACHE->set( $full_hashkey => $hitcount ? 1 : -1 );
 333     $_ACL_CACHE->set( join(';:;',  $self->id, $args{'Right'},$via_obj) => 1 )
 334         if $via_obj && $hitcount;
 335
 336     return ($hitcount);
 337 }
 338
 339 =head2 HasRights
 340
 341 Returns a hash reference with all rights this principal has on an
 342 object. Takes Object as a named argument.
 343
 344 Main use case of this method is the following:
 345
 346     $ticket->CurrentUser->PrincipalObj->HasRights( Object => $ticket );
 347     ...
 348     $ticket->CurrentUserHasRight('A');
 349     ...
 350     $ticket->CurrentUserHasRight('Z');
 351
 352 Results are cached and the cache is used in this and, as well, in L</HasRight>
 353 method speeding it up. Don't use hash reference returned by this method
 354 directly for rights checks as it's more complicated then it seems, especially
 355 considering config options like 'DisallowExecuteCode'.
 356
 357 =cut
 358
 359 sub HasRights {
 360     my $self = shift;
 361     my %args = (
 362         Object       => undef,
 363         EquivObjects => undef,
 364         @_
 365     );
 366     return {} if $self->__Value('Disabled');
 367
 368     my $object = $args{'Object'};
 369     unless ( eval { $object->id } ) {
 370         $RT::Logger->crit("HasRights called with no valid object");
 371     }
 372
 373     my $cache_key = $self->id .';:;'. ref($object) .'-'. $object->id;
 374     my $cached = $_ACL_CACHE->fetch($cache_key);
 375     return $cached if $cached;
 376
 377     push @{ $args{'EquivObjects'} }, $object;
 378     unshift @{ $args{'EquivObjects'} },
 379         $args{'Object'}->ACLEquivalenceObjects;
 380     unshift @{ $args{'EquivObjects'} }, $RT::System
 381         unless $self->can('_IsOverrideGlobalACL')
 382             && $self->_IsOverrideGlobalACL( $object );
 383
 384     my %res = ();
 385     {
 386         my $query
 387             = "SELECT DISTINCT ACL.RightName "
 388             . $self->_HasGroupRightQuery(
 389                 EquivObjects => $args{'EquivObjects'}
 390             );
 391         my $rights = $RT::Handle->dbh->selectcol_arrayref($query);
 392         unless ($rights) {
 393             $RT::Logger->warning( $RT::Handle->dbh->errstr );
 394             return ();
 395         }
 396         $res{$_} = 1 foreach @$rights;
 397     }
 398     my $roles;
 399     {
 400         my $query
 401             = "SELECT DISTINCT Groups.Type "
 402             . $self->_HasRoleRightQuery(
 403                 EquivObjects => $args{'EquivObjects'}
 404             );
 405         $roles = $RT::Handle->dbh->selectcol_arrayref($query);
 406         unless ($roles) {
 407             $RT::Logger->warning( $RT::Handle->dbh->errstr );
 408             return ();
 409         }
 410     }
 411     if ( @$roles ) {
 412         my $query
 413             = "SELECT DISTINCT ACL.RightName "
 414             . $self->_RolesWithRightQuery(
 415                 EquivObjects => $args{'EquivObjects'}
 416             )
 417             . ' AND ('. join( ' OR ', map "PrincipalType = '$_'", @$roles ) .')'
 418         ;
 419         my $rights = $RT::Handle->dbh->selectcol_arrayref($query);
 420         unless ($rights) {
 421             $RT::Logger->warning( $RT::Handle->dbh->errstr );
 422             return ();
 423         }
 424         $res{$_} = 1 foreach @$rights;
 425     }
 426
 427     delete $res{'ExecuteCode'} if
 428         RT->Config->Get('DisallowExecuteCode');
 429
 430     $_ACL_CACHE->store( $cache_key, \%res );
 431     return \%res;
 432 }
 433
 434 =head2 _HasRight
 435
 436 Low level HasRight implementation, use HasRight method instead.
 437
 438 =cut
 439
 440 sub _HasRight {
 441     my $self = shift;
 442     {
 443         my ( $hit, @other ) = $self->_HasGroupRight(@_);
 444         return ( $hit, @other ) if $hit;
 445     }
 446     {
 447         my ( $hit, @other ) = $self->_HasRoleRight(@_);
 448         return ( $hit, @other ) if $hit;
 449     }
 450     return (0);
 451 }
 452
 453 # this method handles role rights partly in situations
 454 # where user plays role X on an object and as well the right is
 455 # assigned to this role X of the object, for example right CommentOnTicket
 456 # is granted to Cc role of a queue and user is in cc list of the queue
 457 sub _HasGroupRight {
 458     my $self = shift;
 459     my %args = ( Right        => undef,
 460                  EquivObjects => [],
 461                  @_
 462                );
 463
 464     my $query
 465         = "SELECT ACL.id, ACL.ObjectType, ACL.ObjectId "
 466         . $self->_HasGroupRightQuery( %args );
 467
 468     $self->_Handle->ApplyLimits( \$query, 1 );
 469     my ( $hit, $obj, $id ) = $self->_Handle->FetchResult($query);
 470     return (0) unless $hit;
 471
 472     $obj .= "-$id" if $id;
 473     return ( 1, $obj );
 474 }
 475
 476 sub _HasGroupRightQuery {
 477     my $self = shift;
 478     my %args = (
 479         Right        => undef,
 480         EquivObjects => [],
 481         @_
 482     );
 483
 484     my $query
 485         = "FROM ACL, Principals, CachedGroupMembers WHERE "
 486
 487         # Never find disabled groups.
 488         . "Principals.id = ACL.PrincipalId "
 489         . "AND Principals.PrincipalType = 'Group' "
 490         . "AND Principals.Disabled = 0 "
 491
 492 # See if the principal is a member of the group recursively or _is the rightholder_
 493 # never find recursively disabled group members
 494 # also, check to see if the right is being granted _directly_ to this principal,
 495 #  as is the case when we want to look up group rights
 496         . "AND CachedGroupMembers.GroupId  = ACL.PrincipalId "
 497         . "AND CachedGroupMembers.GroupId  = Principals.id "
 498         . "AND CachedGroupMembers.MemberId = ". $self->Id . " "
 499         . "AND CachedGroupMembers.Disabled = 0 ";
 500
 501     my @clauses;
 502     foreach my $obj ( @{ $args{'EquivObjects'} } ) {
 503         my $type = ref($obj) || $obj;
 504         my $clause = "ACL.ObjectType = '$type'";
 505
 506         if ( defined eval { $obj->id } ) {    # it might be 0
 507             $clause .= " AND ACL.ObjectId = " . $obj->id;
 508         }
 509
 510         push @clauses, "($clause)";
 511     }
 512     if (@clauses) {
 513         $query .= " AND (" . join( ' OR ', @clauses ) . ")";
 514     }
 515     if ( my $right = $args{'Right'} ) {
 516         # Only find superuser or rights with the name $right
 517         $query .= " AND (ACL.RightName = 'SuperUser' "
 518             . ( $right ne 'SuperUser' ? "OR ACL.RightName = '$right'" : '' )
 519         . ") ";
 520     }
 521     return $query;
 522 }
 523
 524 sub _HasRoleRight {
 525     my $self = shift;
 526     my %args = ( Right        => undef,
 527                  EquivObjects => [],
 528                  @_
 529                );
 530
 531     my @roles = $self->RolesWithRight(%args);
 532     return 0 unless @roles;
 533
 534     my $query = "SELECT Groups.id "
 535         . $self->_HasRoleRightQuery( %args, Roles => \@roles );
 536
 537     $self->_Handle->ApplyLimits( \$query, 1 );
 538     my ($hit) = $self->_Handle->FetchResult($query);
 539     return (1) if $hit;
 540
 541     return 0;
 542 }
 543
 544 sub _HasRoleRightQuery {
 545     my $self = shift;
 546     my %args = ( Right        => undef,
 547                  EquivObjects => [],
 548                  Roles        => undef,
 549                  @_
 550                );
 551
 552     my $query =
 553         " FROM Groups, Principals, CachedGroupMembers WHERE "
 554
 555         # Never find disabled things
 556         . "Principals.Disabled = 0 " . "AND CachedGroupMembers.Disabled = 0 "
 557
 558         # We always grant rights to Groups
 559         . "AND Principals.id = Groups.id "
 560         . "AND Principals.PrincipalType = 'Group' "
 561
 562 # See if the principal is a member of the group recursively or _is the rightholder_
 563 # never find recursively disabled group members
 564 # also, check to see if the right is being granted _directly_ to this principal,
 565 #  as is the case when we want to look up group rights
 566         . "AND Principals.id = CachedGroupMembers.GroupId "
 567         . "AND CachedGroupMembers.MemberId = " . $self->Id . " "
 568     ;
 569
 570     if ( $args{'Roles'} ) {
 571         $query .= "AND (" . join( ' OR ', map "Groups.Type = '$_'", @{ $args{'Roles'} } ) . ")";
 572     }
 573
 574     my (@object_clauses);
 575     foreach my $obj ( @{ $args{'EquivObjects'} } ) {
 576         my $type = ref($obj) ? ref($obj) : $obj;
 577
 578         my $clause = "Groups.Domain = '$type-Role'";
 579
 580         # XXX: Groups.Instance is VARCHAR in DB, we should quote value
 581         # if we want mysql 4.0 use indexes here. we MUST convert that
 582         # field to integer and drop this quotes.
 583         if ( my $id = eval { $obj->id } ) {
 584             $clause .= " AND Groups.Instance = '$id'";
 585         }
 586         push @object_clauses, "($clause)";
 587     }
 588     $query .= " AND (" . join( ' OR ', @object_clauses ) . ")";
 589     return $query;
 590 }
 591
 592 =head2 RolesWithRight
 593
 594 Returns list with names of roles that have right on
 595 set of objects. Takes Right, EquiveObjects,
 596 IncludeSystemRights and IncludeSuperusers arguments.
 597
 598 IncludeSystemRights is true by default, rights
 599 granted systemwide are ignored when IncludeSystemRights
 600 is set to a false value.
 601
 602 IncludeSuperusers is true by default, SuperUser right
 603 is not checked if it's set to a false value.
 604
 605 =cut
 606
 607 sub RolesWithRight {
 608     my $self = shift;
 609     my %args = ( Right               => undef,
 610                  IncludeSystemRights => 1,
 611                  IncludeSuperusers   => 1,
 612                  EquivObjects        => [],
 613                  @_
 614                );
 615
 616     return () if $args{'Right'} eq 'ExecuteCode'
 617         and RT->Config->Get('DisallowExecuteCode');
 618
 619     my $query = "SELECT DISTINCT PrincipalType "
 620         . $self->_RolesWithRightQuery( %args );
 621
 622     my $roles = $RT::Handle->dbh->selectcol_arrayref($query);
 623     unless ($roles) {
 624         $RT::Logger->warning( $RT::Handle->dbh->errstr );
 625         return ();
 626     }
 627     return @$roles;
 628 }
 629
 630 sub _RolesWithRightQuery {
 631     my $self = shift;
 632     my %args = ( Right               => undef,
 633                  IncludeSystemRights => 1,
 634                  IncludeSuperusers   => 1,
 635                  EquivObjects        => [],
 636                  @_
 637                );
 638
 639     my $query = " FROM ACL WHERE"
 640
 641         # we need only roles
 642         . " PrincipalType != 'Group'";
 643
 644     if ( my $right = $args{'Right'} ) {
 645         $query .=
 646             # Only find superuser or rights with the requested right
 647             " AND ( RightName = '$right' "
 648
 649             # Check SuperUser if we were asked to
 650             . ( $args{'IncludeSuperusers'} ? "OR RightName = 'SuperUser' " : '' )
 651             . ")";
 652     }
 653
 654     # skip rights granted on system level if we were asked to
 655     unless ( $args{'IncludeSystemRights'} ) {
 656         $query .= " AND ObjectType != 'RT::System'";
 657     }
 658
 659     my (@object_clauses);
 660     foreach my $obj ( @{ $args{'EquivObjects'} } ) {
 661         my $type = ref($obj) ? ref($obj) : $obj;
 662
 663         my $object_clause = "ObjectType = '$type'";
 664         if ( my $id = eval { $obj->id } ) {
 665             $object_clause .= " AND ObjectId = $id";
 666         }
 667         push @object_clauses, "($object_clause)";
 668     }
 669
 670     # find ACLs that are related to our objects only
 671     $query .= " AND (" . join( ' OR ', @object_clauses ) . ")"
 672         if @object_clauses;
 673
 674     return $query;
 675 }
 676
 677
 678 =head2 InvalidateACLCache
 679
 680 Cleans out and reinitializes the user rights cache
 681
 682 =cut
 683
 684 sub InvalidateACLCache {
 685     $_ACL_CACHE = Cache::Simple::TimedExpiry->new();
 686     my $lifetime;
 687     $lifetime = $RT::Config->Get('ACLCacheLifetime') if $RT::Config;
 688     $_ACL_CACHE->expire_after( $lifetime || 60 );
 689 }
 690
 691
 692
 693
 694
 695 =head2 _GetPrincipalTypeForACL
 696
 697 Gets the principal type. if it's a user, it's a user. if it's a role group and it has a Type,
 698 return that. if it has no type, return group.
 699
 700 =cut
 701
 702 sub _GetPrincipalTypeForACL {
 703     my $self = shift;
 704     if ($self->PrincipalType eq 'Group' && $self->Object->Domain =~ /Role$/) {
 705         return $self->Object->Type;
 706     } else {
 707         return $self->PrincipalType;
 708     }
 709 }
 710
 711
 712
 713 =head2 _ReferenceId
 714
 715 Returns a list uniquely representing an object or normal scalar.
 716
 717 For a scalar, its string value is returned.
 718 For an object that has an id() method which returns a value, its class name and id are returned as a string separated by a "-".
 719 For an object that has an id() method which returns false, its class name is returned.
 720
 721 =cut
 722
 723 sub _ReferenceId {
 724     my $self = shift;
 725     my $scalar = shift;
 726     my $id = eval { $scalar->id };
 727     if ($@) {
 728         return $scalar;
 729     } elsif ($id) {
 730         return ref($scalar) . "-" . $id;
 731     } else {
 732         return ref($scalar);
 733     }
 734 }
 735
 736
 737
 738
 739
 740
 741 =head2 id
 742
 743 Returns the current value of id.
 744 (In the database, id is stored as int(11).)
 745
 746
 747 =cut
 748
 749
 750 =head2 PrincipalType
 751
 752 Returns the current value of PrincipalType.
 753 (In the database, PrincipalType is stored as varchar(16).)
 754
 755
 756
 757 =head2 SetPrincipalType VALUE
 758
 759
 760 Set PrincipalType to VALUE.
 761 Returns (1, 'Status message') on success and (0, 'Error Message') on failure.
 762 (In the database, PrincipalType will be stored as a varchar(16).)
 763
 764
 765 =cut
 766
 767
 768 =head2 ObjectId
 769
 770 Returns the current value of ObjectId.
 771 (In the database, ObjectId is stored as int(11).)
 772
 773
 774
 775 =head2 SetObjectId VALUE
 776
 777
 778 Set ObjectId to VALUE.
 779 Returns (1, 'Status message') on success and (0, 'Error Message') on failure.
 780 (In the database, ObjectId will be stored as a int(11).)
 781
 782
 783 =cut
 784
 785
 786 =head2 Disabled
 787
 788 Returns the current value of Disabled.
 789 (In the database, Disabled is stored as smallint(6).)
 790
 791
 792
 793 =head2 SetDisabled VALUE
 794
 795
 796 Set Disabled to VALUE.
 797 Returns (1, 'Status message') on success and (0, 'Error Message') on failure.
 798 (In the database, Disabled will be stored as a smallint(6).)
 799
 800
 801 =cut
 802
 803
 804
 805 sub _CoreAccessible {
 806     {
 807
 808         id =>
 809                 {read => 1, sql_type => 4, length => 11,  is_blob => 0,  is_numeric => 1,  type => 'int(11)', default => ''},
 810         PrincipalType =>
 811                 {read => 1, write => 1, sql_type => 12, length => 16,  is_blob => 0,  is_numeric => 0,  type => 'varchar(16)', default => ''},
 812         ObjectId =>
 813                 {read => 1, write => 1, sql_type => 4, length => 11,  is_blob => 0,  is_numeric => 1,  type => 'int(11)', default => ''},
 814         Disabled =>
 815                 {read => 1, write => 1, sql_type => 5, length => 6,  is_blob => 0,  is_numeric => 1,  type => 'smallint(6)', default => '0'},
 816
 817  }
 818 };
 819
 820 RT::Base->_ImportOverlays();
 821
 822 1;