diff options
Diffstat (limited to 'rt/lib/RT/CustomField_Overlay.pm')
-rw-r--r-- | rt/lib/RT/CustomField_Overlay.pm | 1449 |
1 files changed, 1449 insertions, 0 deletions
diff --git a/rt/lib/RT/CustomField_Overlay.pm b/rt/lib/RT/CustomField_Overlay.pm new file mode 100644 index 0000000..c91f120 --- /dev/null +++ b/rt/lib/RT/CustomField_Overlay.pm @@ -0,0 +1,1449 @@ +# BEGIN BPS TAGGED BLOCK {{{ +# +# COPYRIGHT: +# +# This software is Copyright (c) 1996-2009 Best Practical Solutions, LLC +# <jesse@bestpractical.com> +# +# (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 }}} + +package RT::CustomField; + +use strict; +no warnings qw(redefine); + +use RT::CustomFieldValues; +use RT::ObjectCustomFields; +use RT::ObjectCustomFieldValues; + + +our %FieldTypes = ( + Select => [ + 'Select multiple values', # loc + 'Select one value', # loc + 'Select up to [_1] values', # loc + ], + Freeform => [ + 'Enter multiple values', # loc + 'Enter one value', # loc + 'Enter up to [_1] values', # loc + ], + Text => [ + 'Fill in multiple text areas', # loc + 'Fill in one text area', # loc + 'Fill in up to [_1] text areas',# loc + ], + Wikitext => [ + 'Fill in multiple wikitext areas', # loc + 'Fill in one wikitext area', # loc + 'Fill in up to [_1] wikitext areas',# loc + ], + Image => [ + 'Upload multiple images', # loc + 'Upload one image', # loc + 'Upload up to [_1] images', # loc + ], + Binary => [ + 'Upload multiple files', # loc + 'Upload one file', # loc + 'Upload up to [_1] files', # loc + ], + Combobox => [ + 'Combobox: Select or enter multiple values', # loc + 'Combobox: Select or enter one value', # loc + 'Combobox: Select or enter up to [_1] values', # loc + ], + Autocomplete => [ + 'Enter multiple values with autocompletion', # loc + 'Enter one value with autocompletion', # loc + 'Enter up to [_1] values with autocompletion', # loc + ], + Date => [ + 'Select multiple dates', # loc + 'Select date', # loc + 'Select up to [_1] dates', # loc + ], +); + + +our %FRIENDLY_OBJECT_TYPES = (); + +RT::CustomField->_ForObjectType( 'RT::Queue-RT::Ticket' => "Tickets", ); #loc +RT::CustomField->_ForObjectType( + 'RT::Queue-RT::Ticket-RT::Transaction' => "Ticket Transactions", ); #loc +RT::CustomField->_ForObjectType( 'RT::User' => "Users", ); #loc +RT::CustomField->_ForObjectType( 'RT::Queue' => "Queues", ); #loc +RT::CustomField->_ForObjectType( 'RT::Group' => "Groups", ); #loc + +our $RIGHTS = { + SeeCustomField => 'See custom fields', # loc_pair + AdminCustomField => 'Create, delete and modify custom fields', # loc_pair + ModifyCustomField => 'Add, delete and modify custom field values for objects' #loc_pair +}; + +# Tell RT::ACE that this sort of object can get acls granted +$RT::ACE::OBJECT_TYPES{'RT::CustomField'} = 1; + +foreach my $right ( keys %{$RIGHTS} ) { + $RT::ACE::LOWERCASERIGHTNAMES{ lc $right } = $right; +} + +=head2 AddRights C<RIGHT>, C<DESCRIPTION> [, ...] + +Adds the given rights to the list of possible rights. This method +should be called during server startup, not at runtime. + +=cut + +sub AddRights { + my $self = shift; + my %new = @_; + $RIGHTS = { %$RIGHTS, %new }; + %RT::ACE::LOWERCASERIGHTNAMES = ( %RT::ACE::LOWERCASERIGHTNAMES, + map { lc($_) => $_ } keys %new); +} + +sub AvailableRights { + my $self = shift; + return $RIGHTS; +} + +=head1 NAME + + RT::CustomField_Overlay - overlay for RT::CustomField + +=head1 DESCRIPTION + +=head1 'CORE' METHODS + +=head2 Create PARAMHASH + +Create takes a hash of values and creates a row in the database: + + varchar(200) 'Name'. + varchar(200) 'Type'. + int(11) 'MaxValues'. + varchar(255) 'Pattern'. + smallint(6) 'Repeated'. + varchar(255) 'Description'. + int(11) 'SortOrder'. + varchar(255) 'LookupType'. + smallint(6) 'Disabled'. + +C<LookupType> is generally the result of either +C<RT::Ticket->CustomFieldLookupType> or C<RT::Transaction->CustomFieldLookupType>. + +=cut + +sub Create { + my $self = shift; + my %args = ( + Name => '', + Type => '', + MaxValues => 0, + Pattern => '', + Description => '', + Disabled => 0, + LookupType => '', + Repeated => 0, + LinkValueTo => '', + IncludeContentForValue => '', + @_, + ); + + unless ( $self->CurrentUser->HasRight(Object => $RT::System, Right => 'AdminCustomField') ) { + return (0, $self->loc('Permission Denied')); + } + + if ( $args{TypeComposite} ) { + @args{'Type', 'MaxValues'} = split(/-/, $args{TypeComposite}, 2); + } + elsif ( $args{Type} =~ s/(?:(Single)|Multiple)$// ) { + # old style Type string + $args{'MaxValues'} = $1 ? 1 : 0; + } + $args{'MaxValues'} = int $args{'MaxValues'}; + + if ( !exists $args{'Queue'}) { + # do nothing -- things below are strictly backward compat + } + elsif ( ! $args{'Queue'} ) { + unless ( $self->CurrentUser->HasRight( Object => $RT::System, Right => 'AssignCustomFields') ) { + return ( 0, $self->loc('Permission Denied') ); + } + $args{'LookupType'} = 'RT::Queue-RT::Ticket'; + } + else { + my $queue = RT::Queue->new($self->CurrentUser); + $queue->Load($args{'Queue'}); + unless ($queue->Id) { + return (0, $self->loc("Queue not found")); + } + unless ( $queue->CurrentUserHasRight('AssignCustomFields') ) { + return ( 0, $self->loc('Permission Denied') ); + } + $args{'LookupType'} = 'RT::Queue-RT::Ticket'; + $args{'Queue'} = $queue->Id; + } + + my ($ok, $msg) = $self->_IsValidRegex( $args{'Pattern'} ); + return (0, $self->loc("Invalid pattern: [_1]", $msg)) unless $ok; + + if ( $args{'MaxValues'} != 1 && $args{'Type'} =~ /(text|combobox)$/i ) { + $RT::Logger->warning("Support for 'multiple' Texts or Comboboxes is not implemented"); + $args{'MaxValues'} = 1; + } + + (my $rv, $msg) = $self->SUPER::Create( + Name => $args{'Name'}, + Type => $args{'Type'}, + MaxValues => $args{'MaxValues'}, + Pattern => $args{'Pattern'}, + Description => $args{'Description'}, + Disabled => $args{'Disabled'}, + LookupType => $args{'LookupType'}, + Repeated => $args{'Repeated'}, + ); + + if ( exists $args{'LinkValueTo'}) { + $self->SetLinkValueTo($args{'LinkValueTo'}); + } + + if ( exists $args{'IncludeContentForValue'}) { + $self->SetIncludeContentForValue($args{'IncludeContentForValue'}); + } + + if ( exists $args{'ValuesClass'} ) { + $self->SetValuesClass( $args{'ValuesClass'} ); + } + + if ( exists $args{'BasedOn'} ) { + $self->SetBasedOn( $args{'BasedOn'} ); + } + + return ($rv, $msg) unless exists $args{'Queue'}; + + # Compat code -- create a new ObjectCustomField mapping + my $OCF = RT::ObjectCustomField->new( $self->CurrentUser ); + $OCF->Create( + CustomField => $self->Id, + ObjectId => $args{'Queue'}, + ); + + return ($rv, $msg); +} + +=head2 Load ID/NAME + +Load a custom field. If the value handed in is an integer, load by custom field ID. Otherwise, Load by name. + +=cut + +sub Load { + my $self = shift; + my $id = shift || ''; + + if ( $id =~ /^\d+$/ ) { + return $self->SUPER::Load( $id ); + } else { + return $self->LoadByName( Name => $id ); + } +} + + +# {{{ sub LoadByName + +=head2 LoadByName (Queue => QUEUEID, Name => NAME) + +Loads the Custom field named NAME. + +Will load a Disabled Custom Field even if there is a non-disabled Custom Field +with the same Name. + +If a Queue parameter is specified, only look for ticket custom fields tied to that Queue. + +If the Queue parameter is '0', look for global ticket custom fields. + +If no queue parameter is specified, look for any and all custom fields with this name. + +BUG/TODO, this won't let you specify that you only want user or group CFs. + +=cut + +# Compatibility for API change after 3.0 beta 1 +*LoadNameAndQueue = \&LoadByName; +# Change after 3.4 beta. +*LoadByNameAndQueue = \&LoadByName; + +sub LoadByName { + my $self = shift; + my %args = ( + Queue => undef, + Name => undef, + @_, + ); + + unless ( defined $args{'Name'} && length $args{'Name'} ) { + $RT::Logger->error("Couldn't load Custom Field without Name"); + return wantarray ? (0, $self->loc("No name provided")) : 0; + } + + # if we're looking for a queue by name, make it a number + if ( defined $args{'Queue'} && $args{'Queue'} =~ /\D/ ) { + my $QueueObj = RT::Queue->new( $self->CurrentUser ); + $QueueObj->Load( $args{'Queue'} ); + $args{'Queue'} = $QueueObj->Id; + } + + # XXX - really naive implementation. Slow. - not really. still just one query + + my $CFs = RT::CustomFields->new( $self->CurrentUser ); + $CFs->SetContextObject( $self->ContextObject ); + my $field = $args{'Name'} =~ /\D/? 'Name' : 'id'; + $CFs->Limit( FIELD => $field, VALUE => $args{'Name'}, CASESENSITIVE => 0); + # Don't limit to queue if queue is 0. Trying to do so breaks + # RT::Group type CFs. + if ( defined $args{'Queue'} ) { + $CFs->LimitToQueue( $args{'Queue'} ); + } + + # When loading by name, we _can_ load disabled fields, but prefer + # non-disabled fields. + $CFs->FindAllRows; + $CFs->OrderByCols( + { FIELD => "Disabled", ORDER => 'ASC' }, + ); + + # We only want one entry. + $CFs->RowsPerPage(1); + + # version before 3.8 just returns 0, so we need to test if wantarray to be + # backward compatible. + return wantarray ? (0, $self->loc("Not found")) : 0 unless my $first = $CFs->First; + + return $self->LoadById( $first->id ); +} + +# }}} + +# {{{ Dealing with custom field values + + +=head2 Custom field values + +=head3 Values FIELD + +Return a object (collection) of all acceptable values for this Custom Field. +Class of the object can vary and depends on the return value +of the C<ValuesClass> method. + +=cut + +*ValuesObj = \&Values; + +sub Values { + my $self = shift; + + my $class = $self->ValuesClass || 'RT::CustomFieldValues'; + eval "require $class" or die "$@"; + my $cf_values = $class->new( $self->CurrentUser ); + # if the user has no rights, return an empty object + if ( $self->id && $self->CurrentUserHasRight( 'SeeCustomField') ) { + $cf_values->LimitToCustomField( $self->Id ); + } + return ($cf_values); +} + +# {{{ AddValue + +=head3 AddValue HASH + +Create a new value for this CustomField. Takes a paramhash containing the elements Name, Description and SortOrder + +=cut + +sub AddValue { + my $self = shift; + my %args = @_; + + unless ($self->CurrentUserHasRight('AdminCustomField')) { + return (0, $self->loc('Permission Denied')); + } + + # allow zero value + if ( !defined $args{'Name'} || $args{'Name'} eq '' ) { + return (0, $self->loc("Can't add a custom field value without a name")); + } + + my $newval = RT::CustomFieldValue->new( $self->CurrentUser ); + return $newval->Create( %args, CustomField => $self->Id ); +} + + +# }}} + +# {{{ DeleteValue + +=head3 DeleteValue ID + +Deletes a value from this custom field by id. + +Does not remove this value for any article which has had it selected + +=cut + +sub DeleteValue { + my $self = shift; + my $id = shift; + unless ( $self->CurrentUserHasRight('AdminCustomField') ) { + return (0, $self->loc('Permission Denied')); + } + + my $val_to_del = RT::CustomFieldValue->new( $self->CurrentUser ); + $val_to_del->Load( $id ); + unless ( $val_to_del->Id ) { + return (0, $self->loc("Couldn't find that value")); + } + unless ( $val_to_del->CustomField == $self->Id ) { + return (0, $self->loc("That is not a value for this custom field")); + } + + my $retval = $val_to_del->Delete; + unless ( $retval ) { + return (0, $self->loc("Custom field value could not be deleted")); + } + return ($retval, $self->loc("Custom field value deleted")); +} + +# }}} + + +=head2 ValidateQueue Queue + +Make sure that the queue specified is a valid queue name + +=cut + +sub ValidateQueue { + my $self = shift; + my $id = shift; + + return undef unless defined $id; + # 0 means "Global" null would _not_ be ok. + return 1 if $id eq '0'; + + my $q = RT::Queue->new( $RT::SystemUser ); + $q->Load( $id ); + return undef unless $q->id; + return 1; +} + + +# {{{ Types + +=head2 Types + +Retuns an array of the types of CustomField that are supported + +=cut + +sub Types { + return (keys %FieldTypes); +} + +# }}} + +# {{{ IsSelectionType + +=head2 IsSelectionType + +Retuns a boolean value indicating whether the C<Values> method makes sense +to this Custom Field. + +=cut + +sub IsSelectionType { + my $self = shift; + my $type = @_? shift : $self->Type; + return undef unless $type; + + $type =~ /(?:Select|Combobox|Autocomplete)/; +} + +# }}} + + +=head2 IsExternalValues + +=cut + +sub IsExternalValues { + my $self = shift; + my $selectable = $self->IsSelectionType( @_ ); + return $selectable unless $selectable; + + my $class = $self->ValuesClass; + return 0 if $class eq 'RT::CustomFieldValues'; + return 1; +} + +sub ValuesClass { + my $self = shift; + return '' unless $self->IsSelectionType; + + my $class = $self->FirstAttribute( 'ValuesClass' ); + $class = $class->Content if $class; + return $class || 'RT::CustomFieldValues'; +} + +sub SetValuesClass { + my $self = shift; + my $class = shift || 'RT::CustomFieldValues'; + + if( $class eq 'RT::CustomFieldValues' ) { + return $self->DeleteAttribute( 'ValuesClass' ); + } + return $self->SetAttribute( Name => 'ValuesClass', Content => $class ); +} + + +=head2 FriendlyType [TYPE, MAX_VALUES] + +Returns a localized human-readable version of the custom field type. +If a custom field type is specified as the parameter, the friendly type for that type will be returned + +=cut + +sub FriendlyType { + my $self = shift; + + my $type = @_ ? shift : $self->Type; + my $max = @_ ? shift : $self->MaxValues; + $max = 0 unless $max; + + if (my $friendly_type = $FieldTypes{$type}[$max>2 ? 2 : $max]) { + return ( $self->loc( $friendly_type, $max ) ); + } + else { + return ( $self->loc( $type ) ); + } +} + +sub FriendlyTypeComposite { + my $self = shift; + my $composite = shift || $self->TypeComposite; + return $self->FriendlyType(split(/-/, $composite, 2)); +} + + +=head2 ValidateType TYPE + +Takes a single string. returns true if that string is a value +type of custom field + + +=cut + +sub ValidateType { + my $self = shift; + my $type = shift; + + if ( $type =~ s/(?:Single|Multiple)$// ) { + $RT::Logger->warning( "Prefix 'Single' and 'Multiple' to Type deprecated, use MaxValues instead at (". join(":",caller).")"); + } + + if ( $FieldTypes{$type} ) { + return 1; + } + else { + return undef; + } +} + + +sub SetType { + my $self = shift; + my $type = shift; + if ($type =~ s/(?:(Single)|Multiple)$//) { + $RT::Logger->warning("'Single' and 'Multiple' on SetType deprecated, use SetMaxValues instead at (". join(":",caller).")"); + $self->SetMaxValues($1 ? 1 : 0); + } + $self->SUPER::SetType($type); +} + +=head2 SetPattern STRING + +Takes a single string representing a regular expression. Performs basic +validation on that regex, and sets the C<Pattern> field for the CF if it +is valid. + +=cut + +sub SetPattern { + my $self = shift; + my $regex = shift; + + my ($ok, $msg) = $self->_IsValidRegex($regex); + if ($ok) { + return $self->SUPER::SetPattern($regex); + } + else { + return (0, $self->loc("Invalid pattern: [_1]", $msg)); + } +} + +=head2 _IsValidRegex(Str $regex) returns (Bool $success, Str $msg) + +Tests if the string contains an invalid regex. + +=cut + +sub _IsValidRegex { + my $self = shift; + my $regex = shift or return (1, 'valid'); + + local $^W; local $@; + local $SIG{__DIE__} = sub { 1 }; + local $SIG{__WARN__} = sub { 1 }; + + if (eval { qr/$regex/; 1 }) { + return (1, 'valid'); + } + + my $err = $@; + $err =~ s{[,;].*}{}; # strip debug info from error + chomp $err; + return (0, $err); +} + +# {{{ SingleValue + +=head2 SingleValue + +Returns true if this CustomField only accepts a single value. +Returns false if it accepts multiple values + +=cut + +sub SingleValue { + my $self = shift; + if (($self->MaxValues||0) == 1) { + return 1; + } + else { + return undef; + } +} + +sub UnlimitedValues { + my $self = shift; + if (($self->MaxValues||0) == 0) { + return 1; + } + else { + return undef; + } +} + +# }}} + +=head2 CurrentUserHasRight RIGHT + +Helper function to call the custom field's queue's CurrentUserHasRight with the passed in args. + +=cut + +sub CurrentUserHasRight { + my $self = shift; + my $right = shift; + + return $self->CurrentUser->HasRight( + Object => $self, + Right => $right, + ); +} + +=head2 ACLEquivalenceObjects + +Returns list of objects via which users can get rights on this custom field. For custom fields +these objects can be set using L<ContextObject|/"ContextObject and SetContextObject">. + +=cut + +sub ACLEquivalenceObjects { + my $self = shift; + + my $ctx = $self->ContextObject + or return; + return ($ctx, $ctx->ACLEquivalenceObjects); +} + +=head2 ContextObject and SetContextObject + +Set or get a context for this object. It can be ticket, queue or another object +this CF applies to. Used for ACL control, for example SeeCustomField can be granted on +queue level to allow people to see all fields applied to the queue. + +=cut + +sub SetContextObject { + my $self = shift; + return $self->{'context_object'} = shift; +} + +sub ContextObject { + my $self = shift; + return $self->{'context_object'}; +} + +# {{{ sub _Set + +sub _Set { + my $self = shift; + + unless ( $self->CurrentUserHasRight('AdminCustomField') ) { + return ( 0, $self->loc('Permission Denied') ); + } + return $self->SUPER::_Set( @_ ); + +} + +# }}} + +# {{{ sub _Value + +=head2 _Value + +Takes the name of a table column. +Returns its value as a string, if the user passes an ACL check + +=cut + +sub _Value { + my $self = shift; + return undef unless $self->id; + + # we need to do the rights check + unless ( $self->CurrentUserHasRight('SeeCustomField') ) { + $RT::Logger->debug( + "Permission denied. User #". $self->CurrentUser->id + ." has no SeeCustomField right on CF #". $self->id + ); + return (undef); + } + return $self->__Value( @_ ); +} + +# }}} +# {{{ sub SetDisabled + +=head2 SetDisabled + +Takes a boolean. +1 will cause this custom field to no longer be avaialble for objects. +0 will re-enable this field. + +=cut + +# }}} + +=head2 SetTypeComposite + +Set this custom field's type and maximum values as a composite value + +=cut + +sub SetTypeComposite { + my $self = shift; + my $composite = shift; + + my $old = $self->TypeComposite; + + my ($type, $max_values) = split(/-/, $composite, 2); + if ( $type ne $self->Type ) { + my ($status, $msg) = $self->SetType( $type ); + return ($status, $msg) unless $status; + } + if ( ($max_values || 0) != ($self->MaxValues || 0) ) { + my ($status, $msg) = $self->SetMaxValues( $max_values ); + return ($status, $msg) unless $status; + } + return 1, $self->loc( + "Type changed from '[_1]' to '[_2]'", + $self->FriendlyTypeComposite( $old ), + $self->FriendlyTypeComposite( $composite ), + ); +} + +=head2 TypeComposite + +Returns a composite value composed of this object's type and maximum values + +=cut + + +sub TypeComposite { + my $self = shift; + return join '-', ($self->Type || ''), ($self->MaxValues || 0); +} + +=head2 TypeComposites + +Returns an array of all possible composite values for custom fields. + +=cut + +sub TypeComposites { + my $self = shift; + return grep !/(?:[Tt]ext|Combobox|Date)-0/, map { ("$_-1", "$_-0") } $self->Types; +} + +=head2 SetLookupType + +Autrijus: care to doc how LookupTypes work? + +=cut + +sub SetLookupType { + my $self = shift; + my $lookup = shift; + if ( $lookup ne $self->LookupType ) { + # Okay... We need to invalidate our existing relationships + my $ObjectCustomFields = RT::ObjectCustomFields->new($self->CurrentUser); + $ObjectCustomFields->LimitToCustomField($self->Id); + $_->Delete foreach @{$ObjectCustomFields->ItemsArrayRef}; + } + return $self->SUPER::SetLookupType($lookup); +} + +=head2 LookupTypes + +Returns an array of LookupTypes available + +=cut + + +sub LookupTypes { + my $self = shift; + return keys %FRIENDLY_OBJECT_TYPES; +} + +my @FriendlyObjectTypes = ( + "[_1] objects", # loc + "[_1]'s [_2] objects", # loc + "[_1]'s [_2]'s [_3] objects", # loc +); + +=head2 FriendlyLookupType + +Returns a localized description of the type of this custom field + +=cut + +sub FriendlyLookupType { + my $self = shift; + my $lookup = shift || $self->LookupType; + + return ($self->loc( $FRIENDLY_OBJECT_TYPES{$lookup} )) + if (defined $FRIENDLY_OBJECT_TYPES{$lookup} ); + + my @types = map { s/^RT::// ? $self->loc($_) : $_ } + grep { defined and length } + split( /-/, $lookup ) + or return; + return ( $self->loc( $FriendlyObjectTypes[$#types], @types ) ); +} + +sub RecordClassFromLookupType { + my $self = shift; + my ($class) = ($self->LookupType =~ /^([^-]+)/); + unless ( $class ) { + $RT::Logger->error( + "Custom Field #". $self->id + ." has incorrect LookupType '". $self->LookupType ."'" + ); + return undef; + } + return $class; +} + +sub CollectionClassFromLookupType { + my $self = shift; + + my $record_class = $self->RecordClassFromLookupType; + return undef unless $record_class; + + my $collection_class; + if ( UNIVERSAL::can($record_class.'Collection', 'new') ) { + $collection_class = $record_class.'Collection'; + } elsif ( UNIVERSAL::can($record_class.'es', 'new') ) { + $collection_class = $record_class.'es'; + } elsif ( UNIVERSAL::can($record_class.'s', 'new') ) { + $collection_class = $record_class.'s'; + } else { + $RT::Logger->error("Can not find a collection class for record class '$record_class'"); + return undef; + } + return $collection_class; +} + +=head1 AppliedTo + +Returns collection with objects this custom field is applied to. +Class of the collection depends on L</LookupType>. +See all L</NotAppliedTo> . + +Doesn't takes into account if object is applied globally. + +=cut + +sub AppliedTo { + my $self = shift; + + my ($res, $ocfs_alias) = $self->_AppliedTo; + return $res unless $res; + + $res->Limit( + ALIAS => $ocfs_alias, + FIELD => 'id', + OPERATOR => 'IS NOT', + VALUE => 'NULL', + ); + + return $res; +} + +=head1 NotAppliedTo + +Returns collection with objects this custom field is not applied to. +Class of the collection depends on L</LookupType>. +See all L</AppliedTo> . + +Doesn't takes into account if object is applied globally. + +=cut + +sub NotAppliedTo { + my $self = shift; + + my ($res, $ocfs_alias) = $self->_AppliedTo; + return $res unless $res; + + $res->Limit( + ALIAS => $ocfs_alias, + FIELD => 'id', + OPERATOR => 'IS', + VALUE => 'NULL', + ); + + return $res; +} + +sub _AppliedTo { + my $self = shift; + + my ($class) = $self->CollectionClassFromLookupType; + return undef unless $class; + + my $res = $class->new( $self->CurrentUser ); + + # If CF is a Group CF, only display user-defined groups + if ( $class eq 'RT::Groups' ) { + $res->LimitToUserDefinedGroups; + } + + $res->OrderBy( FIELD => 'Name' ); + my $ocfs_alias = $res->Join( + TYPE => 'LEFT', + ALIAS1 => 'main', + FIELD1 => 'id', + TABLE2 => 'ObjectCustomFields', + FIELD2 => 'ObjectId', + ); + $res->Limit( + LEFTJOIN => $ocfs_alias, + ALIAS => $ocfs_alias, + FIELD => 'CustomField', + VALUE => $self->id, + ); + return ($res, $ocfs_alias); +} + +=head2 IsApplied + +Takes object id and returns corresponding L<RT::ObjectCustomField> +record if this custom field is applied to the object. Use 0 to check +if custom field is applied globally. + +=cut + +sub IsApplied { + my $self = shift; + my $id = shift; + my $ocf = RT::ObjectCustomField->new( $self->CurrentUser ); + $ocf->LoadByCols( CustomField => $self->id, ObjectId => $id || 0 ); + return undef unless $ocf->id; + return $ocf; +} + +=head2 AddToObject OBJECT + +Add this custom field as a custom field for a single object, such as a queue or group. + +Takes an object + +=cut + + +sub AddToObject { + my $self = shift; + my $object = shift; + my $id = $object->Id || 0; + + unless (index($self->LookupType, ref($object)) == 0) { + return ( 0, $self->loc('Lookup type mismatch') ); + } + + unless ( $object->CurrentUserHasRight('AssignCustomFields') ) { + return ( 0, $self->loc('Permission Denied') ); + } + + if ( $self->IsApplied( $id ) ) { + return ( 0, $self->loc("Custom field is already applied to the object") ); + } + + if ( $id ) { + # applying locally + return (0, $self->loc("Couldn't apply custom field to an object as it's global already") ) + if $self->IsApplied( 0 ); + } + else { + my $applied = RT::ObjectCustomFields->new( $self->CurrentUser ); + $applied->LimitToCustomField( $self->id ); + while ( my $record = $applied->Next ) { + $record->Delete; + } + } + + my $ocf = RT::ObjectCustomField->new( $self->CurrentUser ); + my ( $oid, $msg ) = $ocf->Create( + ObjectId => $id, CustomField => $self->id, + ); + return ( $oid, $msg ); +} + + +=head2 RemoveFromObject OBJECT + +Remove this custom field for a single object, such as a queue or group. + +Takes an object + +=cut + +sub RemoveFromObject { + my $self = shift; + my $object = shift; + my $id = $object->Id || 0; + + unless (index($self->LookupType, ref($object)) == 0) { + return ( 0, $self->loc('Object type mismatch') ); + } + + unless ( $object->CurrentUserHasRight('AssignCustomFields') ) { + return ( 0, $self->loc('Permission Denied') ); + } + + my $ocf = $self->IsApplied( $id ); + unless ( $ocf ) { + return ( 0, $self->loc("This custom field does not apply to that object") ); + } + + # XXX: Delete doesn't return anything + my ( $oid, $msg ) = $ocf->Delete; + return ( $oid, $msg ); +} + +# {{{ AddValueForObject + +=head2 AddValueForObject HASH + +Adds a custom field value for a record object of some kind. +Takes a param hash of + +Required: + + Object + Content + +Optional: + + LargeContent + ContentType + +=cut + +sub AddValueForObject { + my $self = shift; + my %args = ( + Object => undef, + Content => undef, + LargeContent => undef, + ContentType => undef, + @_ + ); + my $obj = $args{'Object'} or return ( 0, $self->loc('Invalid object') ); + + unless ( $self->CurrentUserHasRight('ModifyCustomField') ) { + return ( 0, $self->loc('Permission Denied') ); + } + + unless ( $self->MatchPattern($args{'Content'}) ) { + return ( 0, $self->loc('Input must match [_1]', $self->FriendlyPattern) ); + } + + $RT::Handle->BeginTransaction; + + if ( $self->MaxValues ) { + my $current_values = $self->ValuesForObject($obj); + my $extra_values = ( $current_values->Count + 1 ) - $self->MaxValues; + + # (The +1 is for the new value we're adding) + + # If we have a set of current values and we've gone over the maximum + # allowed number of values, we'll need to delete some to make room. + # which former values are blown away is not guaranteed + + while ($extra_values) { + my $extra_item = $current_values->Next; + unless ( $extra_item->id ) { + $RT::Logger->crit( "We were just asked to delete " + ."a custom field value that doesn't exist!" ); + $RT::Handle->Rollback(); + return (undef); + } + $extra_item->Delete; + $extra_values--; + } + } + # For date, we need to store Content as ISO date + if ($self->Type eq 'Date') { + my $DateObj = new RT::Date( $self->CurrentUser ); + $DateObj->Set( + Format => 'unknown', + Value => $args{'Content'}, + ); + $args{'Content'} = $DateObj->ISO; + } + my $newval = RT::ObjectCustomFieldValue->new( $self->CurrentUser ); + my $val = $newval->Create( + ObjectType => ref($obj), + ObjectId => $obj->Id, + Content => $args{'Content'}, + LargeContent => $args{'LargeContent'}, + ContentType => $args{'ContentType'}, + CustomField => $self->Id + ); + + unless ($val) { + $RT::Handle->Rollback(); + return ($val, $self->loc("Couldn't create record")); + } + + $RT::Handle->Commit(); + return ($val); + +} + +# }}} + +# {{{ MatchPattern + +=head2 MatchPattern STRING + +Tests the incoming string against the Pattern of this custom field object +and returns a boolean; returns true if the Pattern is empty. + +=cut + +sub MatchPattern { + my $self = shift; + my $regex = $self->Pattern or return 1; + + return (( defined $_[0] ? $_[0] : '') =~ $regex); +} + + +# }}} + +# {{{ FriendlyPattern + +=head2 FriendlyPattern + +Prettify the pattern of this custom field, by taking the text in C<(?#text)> +and localizing it. + +=cut + +sub FriendlyPattern { + my $self = shift; + my $regex = $self->Pattern; + + return '' unless length $regex; + if ( $regex =~ /\(\?#([^)]*)\)/ ) { + return '[' . $self->loc($1) . ']'; + } + else { + return $regex; + } +} + + +# }}} + +# {{{ DeleteValueForObject + +=head2 DeleteValueForObject HASH + +Deletes a custom field value for a ticket. Takes a param hash of Object and Content + +Returns a tuple of (STATUS, MESSAGE). If the call succeeded, the STATUS is true. otherwise it's false + +=cut + +sub DeleteValueForObject { + my $self = shift; + my %args = ( Object => undef, + Content => undef, + Id => undef, + @_ ); + + + unless ($self->CurrentUserHasRight('ModifyCustomField')) { + return (0, $self->loc('Permission Denied')); + } + + my $oldval = RT::ObjectCustomFieldValue->new($self->CurrentUser); + + if (my $id = $args{'Id'}) { + $oldval->Load($id); + } + unless ($oldval->id) { + $oldval->LoadByObjectContentAndCustomField( + Object => $args{'Object'}, + Content => $args{'Content'}, + CustomField => $self->Id, + ); + } + + + # check to make sure we found it + unless ($oldval->Id) { + return(0, $self->loc("Custom field value [_1] could not be found for custom field [_2]", $args{'Content'}, $self->Name)); + } + + # for single-value fields, we need to validate that empty string is a valid value for it + if ( $self->SingleValue and not $self->MatchPattern( '' ) ) { + return ( 0, $self->loc('Input must match [_1]', $self->FriendlyPattern) ); + } + + # delete it + + my $ret = $oldval->Delete(); + unless ($ret) { + return(0, $self->loc("Custom field value could not be found")); + } + return($oldval->Id, $self->loc("Custom field value deleted")); +} + + +=head2 ValuesForObject OBJECT + +Return an L<RT::ObjectCustomFieldValues> object containing all of this custom field's values for OBJECT + +=cut + +sub ValuesForObject { + my $self = shift; + my $object = shift; + + my $values = new RT::ObjectCustomFieldValues($self->CurrentUser); + unless ($self->CurrentUserHasRight('SeeCustomField')) { + # Return an empty object if they have no rights to see + return ($values); + } + + + $values->LimitToCustomField($self->Id); + $values->LimitToEnabled(); + $values->LimitToObject($object); + + return ($values); +} + + +=head2 _ForObjectType PATH FRIENDLYNAME + +Tell RT that a certain object accepts custom fields + +Examples: + + 'RT::Queue-RT::Ticket' => "Tickets", # loc + 'RT::Queue-RT::Ticket-RT::Transaction' => "Ticket Transactions", # loc + 'RT::User' => "Users", # loc + 'RT::Group' => "Groups", # loc + +This is a class method. + +=cut + +sub _ForObjectType { + my $self = shift; + my $path = shift; + my $friendly_name = shift; + + $FRIENDLY_OBJECT_TYPES{$path} = $friendly_name; + +} + + +=head2 IncludeContentForValue [VALUE] (and SetIncludeContentForValue) + +Gets or sets the C<IncludeContentForValue> for this custom field. RT +uses this field to automatically include content into the user's browser +as they display records with custom fields in RT. + +=cut + +sub SetIncludeContentForValue { + shift->IncludeContentForValue(@_); +} +sub IncludeContentForValue{ + my $self = shift; + $self->_URLTemplate('IncludeContentForValue', @_); +} + + + +=head2 LinkValueTo [VALUE] (and SetLinkValueTo) + +Gets or sets the C<LinkValueTo> for this custom field. RT +uses this field to make custom field values into hyperlinks in the user's +browser as they display records with custom fields in RT. + +=cut + + +sub SetLinkValueTo { + shift->LinkValueTo(@_); +} + +sub LinkValueTo { + my $self = shift; + $self->_URLTemplate('LinkValueTo', @_); + +} + + +=head2 _URLTemplate NAME [VALUE] + +With one argument, returns the _URLTemplate named C<NAME>, but only if +the current user has the right to see this custom field. + +With two arguments, attemptes to set the relevant template value. + +=cut + +sub _URLTemplate { + my $self = shift; + my $template_name = shift; + if (@_) { + + my $value = shift; + unless ( $self->CurrentUserHasRight('AdminCustomField') ) { + return ( 0, $self->loc('Permission Denied') ); + } + $self->SetAttribute( Name => $template_name, Content => $value ); + return ( 1, $self->loc('Updated') ); + } else { + unless ( $self->id && $self->CurrentUserHasRight('SeeCustomField') ) { + return (undef); + } + + my @attr = $self->Attributes->Named($template_name); + my $attr = shift @attr; + + if ($attr) { return $attr->Content } + + } +} + +sub SetBasedOn { + my $self = shift; + my $value = shift; + + return $self->DeleteAttribute( "BasedOn" ) + unless defined $value and length $value; + + my $cf = RT::CustomField->new( $self->CurrentUser ); + $cf->Load( ref $value ? $value->Id : $value ); + + return (0, "Permission denied") + unless $cf->Id && $cf->CurrentUserHasRight('SeeCustomField'); + + return $self->AddAttribute( + Name => "BasedOn", + Description => "Custom field whose CF we depend on", + Content => $cf->Id, + ); +} + +sub BasedOnObj { + my $self = shift; + my $obj = RT::CustomField->new( $self->CurrentUser ); + + my $attribute = $self->FirstAttribute("BasedOn"); + $obj->Load($attribute->Content) if defined $attribute; + return $obj; +} + +1; |