X-Git-Url: http://git.freeside.biz/gitweb/?p=freeside.git;a=blobdiff_plain;f=rt%2Flib%2FRT%2FCurrentUser.pm;h=74d44e30459c63d099f349477e651ce0b0eb07ba;hp=6997ddbac9d1cbbe273a8d9fce44a7fdb8a7d0a6;hb=7322f2afedcc2f427e997d1535a503613a83f088;hpb=0ebeec96313dd7edfca340f01f8fbbbac1f4aa1d diff --git a/rt/lib/RT/CurrentUser.pm b/rt/lib/RT/CurrentUser.pm index 6997ddbac..74d44e304 100755 --- a/rt/lib/RT/CurrentUser.pm +++ b/rt/lib/RT/CurrentUser.pm @@ -1,6 +1,50 @@ -# $Header: /home/cvs/cvsroot/freeside/rt/lib/RT/CurrentUser.pm,v 1.1 2002-08-12 06:17:07 ivan Exp $ -# (c) 1996-1999 Jesse Vincent -# This software is redistributable under the terms of the GNU GPL +# BEGIN BPS TAGGED BLOCK {{{ +# +# COPYRIGHT: +# +# This software is Copyright (c) 1996-2016 Best Practical Solutions, LLC +# +# +# (Except where explicitly superseded by other copyright notices) +# +# +# LICENSE: +# +# This work is made available to you under the terms of Version 2 of +# the GNU General Public License. A copy of that license should have +# been provided with this software, but in any event can be snarfed +# from www.gnu.org. +# +# This work is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +# 02110-1301 or visit their web page on the internet at +# http://www.gnu.org/licenses/old-licenses/gpl-2.0.html. +# +# +# CONTRIBUTION SUBMISSION POLICY: +# +# (The following paragraph is not intended to limit the rights granted +# to you to modify and distribute this software under the terms of +# the GNU General Public License and is only of importance to you if +# you choose to contribute your changes and enhancements to the +# community by submitting them to Best Practical Solutions, LLC.) +# +# By intentionally submitting any modifications, corrections or +# derivatives to this work, or any other work intended for use with +# Request Tracker, to Best Practical Solutions, LLC, you confirm that +# you are the copyright holder for those contributions and you grant +# Best Practical Solutions, LLC a nonexclusive, worldwide, irrevocable, +# royalty-free, perpetual, license to use, copy, create derivative +# works based on those contributions, and sublicense and distribute +# those contributions and any derivatives thereof. +# +# END BPS TAGGED BLOCK }}} =head1 NAME @@ -8,125 +52,130 @@ =head1 SYNOPSIS - use RT::CurrentUser + use RT::CurrentUser; + + # load + my $current_user = RT::CurrentUser->new; + $current_user->Load(...); + # or + my $current_user = RT::CurrentUser->new( $user_obj ); + # or + my $current_user = RT::CurrentUser->new( $address || $name || $id ); + + # manipulation + $current_user->UserObj->SetName('new_name'); =head1 DESCRIPTION +B subclass of L class. Used to define the current +user. You should pass an instance of this class to constructors of +many RT classes, then the instance used to check ACLs and localize +strings. =head1 METHODS +See also L for a list of methods this class has. -=begin testing +=head2 new -ok (require RT::TestHarness); -ok (require RT::CurrentUser); - -=end testing +Returns new CurrentUser object. Unlike all other classes of RT it takes +either subclass of C class object or scalar value that is +passed to Load method. =cut package RT::CurrentUser; -use RT::Record; -@ISA= qw(RT::Record); +use strict; +use warnings; + +use base qw/RT::User/; -# {{{ sub _Init +use RT::I18N; #The basic idea here is that $self->CurrentUser is always supposed # to be a CurrentUser object. but that's hard to do when we're trying to load # the CurrentUser object -sub _Init { - my $self = shift; - my $Name = shift; - - $self->{'table'} = "Users"; +sub _Init { + my $self = shift; + my $User = shift; + + $self->{'table'} = "Users"; + + if ( defined $User ) { + + if ( UNIVERSAL::isa( $User, 'RT::User' ) ) { + $self->LoadById( $User->id ); + } + elsif ( ref $User ) { + $RT::Logger->crit( + "RT::CurrentUser->new() called with a bogus argument: $User"); + } + else { + $self->Load( $User ); + } + } - if (defined($Name)) { - $self->Load($Name); - } - - $self->_MyCurrentUser($self); + $self->_BuildTableAttributes; } -# }}} -# {{{ sub Create +=head2 Create, Delete and Set* -sub Create { - return (0, 'Permission Denied'); -} +As stated above it's a subclass of L, but this class is read-only +and calls to these methods are illegal. Return 'permission denied' message +and log an error. -# }}} +=cut -# {{{ sub Delete +sub Create { + my $self = shift; + $RT::Logger->error('RT::CurrentUser is read-only, RT::User for manipulation'); + return (0, $self->loc('Permission Denied')); +} sub Delete { - return (0, 'Permission Denied'); + my $self = shift; + $RT::Logger->error('RT::CurrentUser is read-only, RT::User for manipulation'); + return (0, $self->loc('Permission Denied')); } -# }}} - -# {{{ sub UserObj +sub _Set { + my $self = shift; + $RT::Logger->error('RT::CurrentUser is read-only, RT::User for manipulation'); + return (0, $self->loc('Permission Denied')); +} =head2 UserObj - Returns the RT::User object associated with this CurrentUser object. +Returns the L object associated with this CurrentUser object. =cut sub UserObj { my $self = shift; - - unless ($self->{'UserObj'}) { - use RT::User; - $self->{'UserObj'} = RT::User->new($self); - unless ($self->{'UserObj'}->Load($self->Id)) { - $RT::Logger->err("Couldn't load ".$self->Id. "from the users database.\n"); - } - + + my $user = RT::User->new( $self ); + unless ( $user->LoadById( $self->Id ) ) { + $RT::Logger->error("Couldn't load " . $self->Id . " from the users database."); } - return ($self->{'UserObj'}); -} -# }}} - -# {{{ sub _Accessible -sub _Accessible { - my $self = shift; - my %Cols = ( - Name => 'read', - Gecos => 'read', - RealName => 'read', - Password => 'neither', - EmailAddress => 'read', - Privileged => 'read', - IsAdministrator => 'read' - ); - return($self->SUPER::_Accessible(@_, %Cols)); + return $user; } -# }}} - -# {{{ sub LoadByEmail - -=head2 LoadByEmail - -Loads a User into this CurrentUser object. -Takes the email address of the user to load. -=cut - -sub LoadByEmail { - my $self = shift; - my $identifier = shift; - - $self->LoadByCol("EmailAddress",$identifier); - +sub _CoreAccessible { + { + Name => { 'read' => 1 }, + Gecos => { 'read' => 1 }, + RealName => { 'read' => 1 }, + Lang => { 'read' => 1 }, + Password => { 'read' => 0, 'write' => 0 }, + EmailAddress => { 'read' => 1, 'write' => 0 } + }; + } -# }}} - -# {{{ sub LoadByGecos =head2 LoadByGecos @@ -137,134 +186,91 @@ Takes a unix username as its only argument. sub LoadByGecos { my $self = shift; - my $identifier = shift; - - $self->LoadByCol("Gecos",$identifier); - + return $self->LoadByCol( "Gecos", shift ); } -# }}} - -# {{{ sub LoadByName =head2 LoadByName Loads a User into this CurrentUser object. Takes a Name. + =cut sub LoadByName { my $self = shift; - my $identifier = shift; - $self->LoadByCol("Name",$identifier); - + return $self->LoadByCol( "Name", shift ); } -# }}} -# {{{ sub Load +=head2 LanguageHandle -=head2 Load +Returns this current user's langauge handle. Should take a language +specification. but currently doesn't -Loads a User into this CurrentUser object. -Takes either an integer (users id column reference) or a Name -The latter is deprecated. Instead, you should use LoadByName. -Formerly, this routine also took email addresses. +=cut -=cut +sub LanguageHandle { + my $self = shift; + if ( !defined $self->{'LangHandle'} + || !UNIVERSAL::can( $self->{'LangHandle'}, 'maketext' ) + || @_ ) + { + if ( my $lang = $self->Lang ) { + push @_, $lang; + } + elsif ( $self->id && ($self->id == (RT->SystemUser->id||0) || $self->id == (RT->Nobody->id||0)) ) { + # don't use ENV magic for system users + push @_, 'en'; + } + + $self->{'LangHandle'} = RT::I18N->get_handle(@_); + } -sub Load { - my $self = shift; - my $identifier = shift; - - #if it's an int, load by id. otherwise, load by name. - if ($identifier !~ /\D/) { - $self->SUPER::LoadById($identifier); - } - else { - # This is a bit dangerous, we might get false authen if somebody - # uses ambigous userids or real names: - $self->LoadByCol("Name",$identifier); - } + # Fall back to english. + unless ( $self->{'LangHandle'} ) { + die "We couldn't get a dictionary. Ne mogu naidti slovar. No puedo encontrar dictionario."; + } + return $self->{'LangHandle'}; } -# }}} - -# {{{ sub IsPassword - -=head2 IsPassword - -Takes a password as a string. Passes it off to IsPassword in this -user's UserObj. If it is the user's password and the user isn't -disabled, returns 1. +sub loc { + my $self = shift; + return '' if !defined $_[0] || $_[0] eq ''; -Otherwise, returns undef. + my $handle = $self->LanguageHandle; -=cut + if (@_ == 1) { + # If we have no [_1] replacements, and the key does not appear + # in the lexicon, unescape (using ~) and return it verbatim, as + # an optimization. + my $unescaped = $_[0]; + $unescaped =~ s!~(.)!$1!g; + return $unescaped unless grep exists $_->{$_[0]}, @{ $handle->_lex_refs }; + } -sub IsPassword { - my $self = shift; - my $value = shift; - - return ($self->UserObj->IsPassword($value)); + return $handle->maketext(@_); } -# }}} - -# {{{ sub Privileged - -=head2 Privileged - -Returns true if the current user can be granted rights and be -a member of groups. - -=cut - -sub Privileged { +sub loc_fuzzy { my $self = shift; - return ($self->UserObj->Privileged()); -} - -# }}} + return '' if !defined $_[0] || $_[0] eq ''; -# {{{ Convenient ACL methods - -=head2 HasQueueRight - -calls $self->UserObj->HasQueueRight with the arguments passed in - -=cut - -sub HasQueueRight { - my $self = shift; - return ($self->UserObj->HasQueueRight(@_)); + return $self->LanguageHandle->maketext_fuzzy( @_ ); } -=head2 HasSystemRight +=head2 CurrentUser -calls $self->UserObj->HasSystemRight with the arguments passed in +Return the current currentuser object =cut - -sub HasSystemRight { - my $self = shift; - return ($self->UserObj->HasSystemRight(@_)); +sub CurrentUser { + return shift; } -# }}} - -# {{{ sub HasRight - -=head2 HasSystemRight - -calls $self->UserObj->HasRight with the arguments passed in - -=cut -sub HasRight { - my $self = shift; - return ($self->UserObj->HasRight(@_)); +sub CustomFieldLookupType { + return "RT::User"; } -# }}} +RT::Base->_ImportOverlays(); 1; -