#
# COPYRIGHT:
#
-# This software is Copyright (c) 1996-2012 Best Practical Solutions, LLC
+# This software is Copyright (c) 1996-2016 Best Practical Solutions, LLC
# <sales@bestpractical.com>
#
# (Except where explicitly superseded by other copyright notices)
use strict;
use warnings;
+use 5.010;
-
+use Scalar::Util 'blessed';
use base 'RT::Record';
-sub Table {'CustomFields'}
+use Role::Basic 'with';
+with "RT::Record::Role::Rights";
+sub Table {'CustomFields'}
+use Scalar::Util qw(blessed);
use RT::CustomFieldValues;
use RT::ObjectCustomFields;
use RT::ObjectCustomFieldValues;
sort_order => 10,
selection_type => 1,
- labels => [ 'Select multiple values', # loc
- 'Select one value', # loc
- 'Select up to [_1] values', # loc
+ labels => [ 'Select multiple values', # loc
+ 'Select one value', # loc
+ 'Select up to [quant,_1,value,values]', # loc
],
render_types => {
sort_order => 20,
selection_type => 0,
- labels => [ 'Enter multiple values', # loc
- 'Enter one value', # loc
- 'Enter up to [_1] values', # loc
+ labels => [ 'Enter multiple values', # loc
+ 'Enter one value', # loc
+ 'Enter up to [quant,_1,value,values]', # loc
]
},
Text => {
sort_order => 30,
selection_type => 0,
labels => [
- 'Fill in multiple text areas', # loc
- 'Fill in one text area', # loc
- 'Fill in up to [_1] text areas', # loc
+ 'Fill in multiple text areas', # loc
+ 'Fill in one text area', # loc
+ 'Fill in up to [quant,_1,text area,text areas]', # loc
]
},
Wikitext => {
sort_order => 40,
selection_type => 0,
labels => [
- 'Fill in multiple wikitext areas', # loc
- 'Fill in one wikitext area', # loc
- 'Fill in up to [_1] wikitext areas', # loc
+ 'Fill in multiple wikitext areas', # loc
+ 'Fill in one wikitext area', # loc
+ 'Fill in up to [quant,_1,wikitext area,wikitext areas]', # loc
]
},
labels => [
'Upload multiple images', # loc
'Upload one image', # loc
- 'Upload up to [_1] images', # loc
+ 'Upload up to [quant,_1,image,images]', # loc
]
},
Binary => {
sort_order => 60,
selection_type => 0,
labels => [
- 'Upload multiple files', # loc
- 'Upload one file', # loc
- 'Upload up to [_1] files', # loc
+ 'Upload multiple files', # loc
+ 'Upload one file', # loc
+ 'Upload up to [quant,_1,file,files]', # loc
]
},
sort_order => 70,
selection_type => 1,
labels => [
- 'Combobox: Select or enter multiple values', # loc
- 'Combobox: Select or enter one value', # loc
- 'Combobox: Select or enter up to [_1] values', # loc
+ 'Combobox: Select or enter multiple values', # loc
+ 'Combobox: Select or enter one value', # loc
+ 'Combobox: Select or enter up to [quant,_1,value,values]', # loc
]
},
Autocomplete => {
sort_order => 80,
selection_type => 1,
labels => [
- 'Enter multiple values with autocompletion', # loc
- 'Enter one value with autocompletion', # loc
- 'Enter up to [_1] values with autocompletion', # loc
+ 'Enter multiple values with autocompletion', # loc
+ 'Enter one value with autocompletion', # loc
+ 'Enter up to [quant,_1,value,values] with autocompletion', # loc
]
},
sort_order => 90,
selection_type => 0,
labels => [
- 'Select multiple dates', # loc
- 'Select date', # loc
- 'Select up to [_1] dates', # loc
+ 'Select multiple dates', # loc
+ 'Select date', # loc
+ 'Select up to [quant,_1,date,dates]', # loc
]
},
DateTime => {
sort_order => 100,
selection_type => 0,
labels => [
- 'Select multiple datetimes', # loc
- 'Select datetime', # loc
- 'Select up to [_1] datetimes', # loc
+ 'Select multiple datetimes', # loc
+ 'Select datetime', # loc
+ 'Select up to [quant,_1,datetime,datetimes]', # loc
]
},
- TimeValue => [
- 'Enter multiple time values (UNSUPPORTED)',
- 'Enter a time value',
- 'Enter [_1] time values (UNSUPPORTED)',
- ],
+ TimeValue => {
+ sort_order => 105,
+ selection_type => 0,
+ labels => [
+ 'Enter multiple time values (UNSUPPORTED)',
+ 'Enter a time value',
+ 'Enter [_1] time values (UNSUPPORTED)',
+ ]
+ },
IPAddress => {
sort_order => 110,
selection_type => 0,
- labels => [ 'Enter multiple IP addresses', # loc
- 'Enter one IP address', # loc
- 'Enter up to [_1] IP addresses', # loc
+ labels => [ 'Enter multiple IP addresses', # loc
+ 'Enter one IP address', # loc
+ 'Enter up to [quant,_1,IP address,IP addresses]', # loc
]
},
IPAddressRange => {
sort_order => 120,
selection_type => 0,
- labels => [ 'Enter multiple IP address ranges', # loc
- 'Enter one IP address range', # loc
- 'Enter up to [_1] IP address ranges', # loc
+ labels => [ 'Enter multiple IP address ranges', # loc
+ 'Enter one IP address range', # loc
+ 'Enter up to [quant,_1,IP address range,IP address ranges]', # 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 => 'View custom fields', # loc_pair
- AdminCustomField => 'Create, modify and delete custom fields', # loc_pair
- AdminCustomFieldValues => 'Create, modify and delete custom fields values', # loc_pair
- ModifyCustomField => 'Add, modify and delete custom field values for objects' # loc_pair
-};
-
-our $RIGHT_CATEGORIES = {
- SeeCustomField => 'General',
- AdminCustomField => 'Admin',
- AdminCustomFieldValues => 'Admin',
- ModifyCustomField => 'Staff',
-};
-
-# Tell RT::ACE that this sort of object can get acls granted
-$RT::ACE::OBJECT_TYPES{'RT::CustomField'} = 1;
-
-__PACKAGE__->AddRights(%$RIGHTS);
-__PACKAGE__->AddRightCategories(%$RIGHT_CATEGORIES);
-
-=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;
-}
-
-=head2 RightCategories
-
-Returns a hashref where the keys are rights for this type of object and the
-values are the category (General, Staff, Admin) the right falls into.
+my %BUILTIN_GROUPINGS;
+my %FRIENDLY_LOOKUP_TYPES = ();
-=cut
-
-sub RightCategories {
- return $RIGHT_CATEGORIES;
-}
-
-=head2 AddRightCategories C<RIGHT>, C<CATEGORY> [, ...]
+__PACKAGE__->RegisterLookupType( 'RT::Queue-RT::Ticket' => "Tickets", ); #loc
+__PACKAGE__->RegisterLookupType( 'RT::Queue-RT::Ticket-RT::Transaction' => "Ticket Transactions", ); #loc
+__PACKAGE__->RegisterLookupType( 'RT::User' => "Users", ); #loc
+__PACKAGE__->RegisterLookupType( 'RT::Queue' => "Queues", ); #loc
+__PACKAGE__->RegisterLookupType( 'RT::Group' => "Groups", ); #loc
-Adds the given right and category pairs to the list of right categories. This
-method should be called during server startup, not at runtime.
-
-=cut
+__PACKAGE__->RegisterBuiltInGroupings(
+ 'RT::Ticket' => [ qw(Basics Dates Links People) ],
+ 'RT::User' => [ 'Identity', 'Access control', 'Location', 'Phones' ],
+);
-sub AddRightCategories {
- my $self = shift if ref $_[0] or $_[0] eq __PACKAGE__;
- my %new = @_;
- $RIGHT_CATEGORIES = { %$RIGHT_CATEGORIES, %new };
-}
+__PACKAGE__->AddRight( General => SeeCustomField => 'View custom fields'); # loc
+__PACKAGE__->AddRight( Admin => AdminCustomField => 'Create, modify and delete custom fields'); # loc
+__PACKAGE__->AddRight( Admin => AdminCustomFieldValues => 'Create, modify and delete custom fields values'); # loc
+__PACKAGE__->AddRight( Staff => ModifyCustomField => 'Add, modify and delete custom field values for objects'); # loc
=head1 NAME
varchar(200) 'Type'.
int(11) 'MaxValues'.
varchar(255) 'Pattern'.
- smallint(6) 'Repeated'.
varchar(255) 'Description'.
int(11) 'SortOrder'.
varchar(255) 'LookupType'.
Description => '',
Disabled => 0,
LookupType => '',
- Repeated => 0,
LinkValueTo => '',
IncludeContentForValue => '',
@_,
}
}
+ $args{'Disabled'} ||= 0;
+
(my $rv, $msg) = $self->SUPER::Create(
Name => $args{'Name'},
Type => $args{'Type'},
Description => $args{'Description'},
Disabled => $args{'Disabled'},
LookupType => $args{'LookupType'},
- Repeated => $args{'Repeated'},
);
if ($rv) {
$self->SetUILocation( $args{'UILocation'} );
}
+ if ( exists $args{'NoClone'} ) {
+ $self->SetNoClone( $args{'NoClone'} );
+ }
+
return ($rv, $msg) unless exists $args{'Queue'};
# Compat code -- create a new ObjectCustomField mapping
-=head2 LoadByName (Queue => QUEUEID, Name => NAME)
+=head2 LoadByName Name => C<NAME>, [...]
+
+Loads the Custom field named NAME. As other optional parameters, takes:
+
+=over
+
+=item LookupType => C<LOOKUPTYPE>
+
+The type of Custom Field to look for; while this parameter is not
+required, it is highly suggested, or you may not find the Custom Field
+you are expecting. It should be passed a C<LookupType> such as
+L<RT::Ticket/CustomFieldLookupType> or
+L<RT::User/CustomFieldLookupType>.
+
+=item ObjectType => C<CLASS>
-Loads the Custom field named NAME.
+The class of object that the custom field is applied to. This can be
+intuited from the provided C<LookupType>.
-Will load a Disabled Custom Field even if there is a non-disabled Custom Field
-with the same Name.
+=item ObjectId => C<ID>
-If a Queue parameter is specified, only look for ticket custom fields tied to that Queue.
+limits the custom field search to one applied to the relevant id. For
+example, if a C<LookupType> of C<< RT::Ticket->CustomFieldLookupType >>
+is used, this is which Queue the CF must be applied to. Pass 0 to only
+search custom fields that are applied globally.
-If the Queue parameter is '0', look for global ticket custom fields.
+=item IncludeDisabled => C<BOOLEAN>
-If no queue parameter is specified, look for any and all custom fields with this name.
+Whether it should return Disabled custom fields if they match; defaults
+to on, though non-Disabled custom fields are returned preferentially.
-BUG/TODO, this won't let you specify that you only want user or group CFs.
+=item IncludeGlobal => C<BOOLEAN>
+
+Whether to also search global custom fields, even if a value is provided
+for C<ObjectId>; defaults to off. Non-global custom fields are returned
+preferentially.
+
+=back
+
+For backwards compatibility, a value passed for C<Queue> is equivalent
+to specifying a C<LookupType> of L<RT::Ticket/CustomFieldLookupType>,
+and a C<ObjectId> of the value passed as C<Queue>.
+
+If multiple custom fields match the above constraints, the first
+according to C<SortOrder> will be returned; ties are broken by C<id>,
+lowest-first.
+
+=head2 LoadNameAndQueue
+
+=head2 LoadByNameAndQueue
+
+Deprecated alternate names for L</LoadByName>.
=cut
sub LoadByName {
my $self = shift;
my %args = (
+ Name => undef,
+ LookupType => undef,
+ ObjectType => undef,
+ ObjectId => undef,
+
+ IncludeDisabled => 1,
+ IncludeGlobal => 0,
+
+ # Back-compat
Queue => undef,
- Name => undef,
+
@_,
);
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/ || !$self->ContextObject) ) {
- my $QueueObj = RT::Queue->new( $self->CurrentUser );
- $QueueObj->Load( $args{'Queue'} );
- $args{'Queue'} = $QueueObj->Id;
- $self->SetContextObject( $QueueObj )
- unless $self->ContextObject;
+ if ( defined $args{'Queue'} ) {
+ # Set a LookupType for backcompat, otherwise we'll calculate
+ # one of RT::Queue from your ContextObj. Older code was relying
+ # on us defaulting to RT::Queue-RT::Ticket in old LimitToQueue call.
+ $args{LookupType} ||= 'RT::Queue-RT::Ticket';
+ $args{ObjectId} //= delete $args{Queue};
+ }
+
+ # Default the ObjectType to the top category of the LookupType; it's
+ # what the CFs are assigned on.
+ $args{ObjectType} ||= $1 if $args{LookupType} and $args{LookupType} =~ /^([^-]+)/;
+
+ # Resolve the ObjectId/ObjectType; this is necessary to properly
+ # limit ObjectId, and also possibly useful to set a ContextObj if we
+ # are currently lacking one. It is not strictly necessary if we
+ # have a context object and were passed a numeric ObjectId, but it
+ # cannot hurt to verify its sanity. Skip if we have a false
+ # ObjectId, which means "global", or if we lack an ObjectType
+ if ($args{ObjectId} and $args{ObjectType}) {
+ my ($obj, $ok, $msg);
+ eval {
+ $obj = $args{ObjectType}->new( $self->CurrentUser );
+ ($ok, $msg) = $obj->Load( $args{ObjectId} );
+ };
+
+ if ($ok) {
+ $args{ObjectId} = $obj->id;
+ $self->SetContextObject( $obj )
+ unless $self->ContextObject;
+ } else {
+ $RT::Logger->warning("Failed to load $args{ObjectType} '$args{ObjectId}'");
+ if ($args{IncludeGlobal}) {
+ # Fall back to acting like we were only asked about the
+ # global case
+ $args{ObjectId} = 0;
+ } else {
+ # If they didn't also want global results, there's no
+ # point in searching; abort
+ return wantarray ? (0, $self->loc("Not found")) : 0;
+ }
+ }
+ } elsif (not $args{ObjectType} and $args{ObjectId}) {
+ # If we skipped out on the above due to lack of ObjectType, make
+ # sure we clear out ObjectId of anything lingering
+ $RT::Logger->warning("No LookupType or ObjectType passed; ignoring ObjectId");
+ delete $args{ObjectId};
}
- # 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' },
+ # The context object may be a ticket, for example, as context for a
+ # queue CF. The valid lookup types are thus the entire set of
+ # ACLEquivalenceObjects for the context object.
+ $args{LookupType} ||= [
+ map {$_->CustomFieldLookupType}
+ ($self->ContextObject, $self->ContextObject->ACLEquivalenceObjects) ]
+ if $self->ContextObject;
+
+ # Apply LookupType limits
+ $args{LookupType} = [ $args{LookupType} ]
+ if $args{LookupType} and not ref($args{LookupType});
+ $CFs->Limit( FIELD => "LookupType", OPERATOR => "IN", VALUE => $args{LookupType} )
+ if $args{LookupType};
+
+ # Default to by SortOrder and id; this mirrors the standard ordering
+ # of RT::CustomFields (minus the Name, which is guaranteed to be
+ # fixed)
+ my @order = (
+ { FIELD => 'SortOrder',
+ ORDER => 'ASC' },
+ { FIELD => 'id',
+ ORDER => 'ASC' },
);
+ if (defined $args{ObjectId}) {
+ # The join to OCFs is distinct -- either we have a global
+ # application or an objectid match, but never both. Even if
+ # this were not the case, we care only for the first row.
+ my $ocfs = $CFs->_OCFAlias( Distinct => 1);
+ if ($args{IncludeGlobal}) {
+ $CFs->Limit(
+ ALIAS => $ocfs,
+ FIELD => 'ObjectId',
+ OPERATOR => 'IN',
+ VALUE => [ $args{ObjectId}, 0 ],
+ );
+ # Find the queue-specific first
+ unshift @order, { ALIAS => $ocfs, FIELD => "ObjectId", ORDER => "DESC" };
+ } else {
+ $CFs->Limit(
+ ALIAS => $ocfs,
+ FIELD => 'ObjectId',
+ VALUE => $args{ObjectId},
+ );
+ }
+ }
+
+ if ($args{IncludeDisabled}) {
+ # Load disabled fields, but return them only as a last resort.
+ # This goes at the front of @order, as we prefer the
+ # non-disabled global CF to the disabled Queue-specific CF.
+ $CFs->FindAllRows;
+ unshift @order, { FIELD => "Disabled", ORDER => 'ASC' };
+ }
+
+ # Apply the above orderings
+ $CFs->OrderByCols( @order );
+
# We only want one entry.
$CFs->RowsPerPage(1);
my $class = $self->ValuesClass;
if ( $class ne 'RT::CustomFieldValues') {
- eval "require $class" or die "$@";
+ $class->require or die "Can't load $class: $@";
}
my $cf_values = $class->new( $self->CurrentUser );
+ $cf_values->SetCustomFieldObject( $self );
# if the user has no rights, return an empty object
if ( $self->id && $self->CurrentUserHasRight( 'SeeCustomField') ) {
$cf_values->LimitToCustomField( $self->Id );
my $self = shift;
my $class = shift;
- return 1 if !defined $class || $class eq 'RT::CustomFieldValues';
+ return 1 if !$class || $class eq 'RT::CustomFieldValues';
return 1 if grep $class eq $_, RT->Config->Get('CustomFieldValuesSources');
return undef;
}
my $type = shift;
if ( $type =~ s/(?:Single|Multiple)$// ) {
- $RT::Logger->warning( "Prefix 'Single' and 'Multiple' to Type deprecated, use MaxValues instead at (". join(":",caller).")");
+ RT->Deprecated(
+ Arguments => "suffix 'Single' or 'Multiple'",
+ Instead => "MaxValues",
+ Remove => "4.4",
+ );
}
if ( $FieldTypes{$type} ) {
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).")");
+ RT->Deprecated(
+ Arguments => "suffix 'Single' or 'Multiple'",
+ Instead => "MaxValues",
+ Remove => "4.4",
+ );
$self->SetMaxValues($1 ? 1 : 0);
}
$self->_Set(Field => 'Type', Value =>$type);
}
-=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
=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.
+Set or get a context for this object. It can be ticket, queue or another
+object this CF added to. Used for ACL control, for example
+SeeCustomField can be granted on queue level to allow people to see all
+fields added to the queue.
=cut
=head2 ValidateContextObject
-Ensure that a given ContextObject applies to this Custom Field.
-For custom fields that are assigned to Queues or to Classes, this checks that the Custom
-Field is actually applied to that objects. For Global Custom Fields, it returns true
-as long as the Object is of the right type, because you may be using
-your permissions on a given Queue of Class to see a Global CF.
-For CFs that are only applied Globally, you don't need a ContextObject.
+Ensure that a given ContextObject applies to this Custom Field. For
+custom fields that are assigned to Queues or to Classes, this checks
+that the Custom Field is actually added to that object. For Global
+Custom Fields, it returns true as long as the Object is of the right
+type, because you may be using your permissions on a given Queue of
+Class to see a Global CF. For CFs that are only added globally, you
+don't need a ContextObject.
=cut
my $self = shift;
my $object = shift;
- return 1 if $self->IsApplied(0);
+ return 1 if $self->IsGlobal;
# global only custom fields don't have objects
# that should be used as context objects.
- return if $self->ApplyGlobally;
+ return if $self->IsOnlyGlobal;
# Otherwise, make sure we weren't passed a user object that we're
# supposed to treat as a queue.
return unless $self->ValidContextType(ref $object);
- # Check that it is applied correctly
- my ($applied_to) = grep {ref($_) eq $self->RecordClassFromLookupType} ($object, $object->ACLEquivalenceObjects);
- return unless $applied_to;
- return $self->IsApplied($applied_to->id);
+ # Check that it is added correctly
+ my ($added_to) = grep {ref($_) eq $self->RecordClassFromLookupType} ($object, $object->ACLEquivalenceObjects);
+ return unless $added_to;
+ return $self->IsAdded($added_to->id);
}
-
sub _Set {
my $self = shift;
$self->FriendlyType));
}
- # XXX: Remove this restriction once we support lists and cascaded selects
- if ( $self->BasedOnObj->id and $type =~ /List/ ) {
- return (0, $self->loc("We can't currently render as a List when basing categories on another custom field. Please use another render type."));
- }
-
return $self->_Set( Field => 'RenderType', Value => $type, @_ );
}
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};
+ RT::ObjectCustomField->new($self->CurrentUser)->DeleteAll( CustomField => $self );
}
return $self->_Set(Field => 'LookupType', Value =>$lookup);
}
sub LookupTypes {
my $self = shift;
- return keys %FRIENDLY_OBJECT_TYPES;
+ return sort keys %FRIENDLY_LOOKUP_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
sub FriendlyLookupType {
my $self = shift;
my $lookup = shift || $self->LookupType;
-
- return ($self->loc( $FRIENDLY_OBJECT_TYPES{$lookup} ))
- if (defined $FRIENDLY_OBJECT_TYPES{$lookup} );
+
+ return ($self->loc( $FRIENDLY_LOOKUP_TYPES{$lookup} ))
+ if defined $FRIENDLY_LOOKUP_TYPES{$lookup};
my @types = map { s/^RT::// ? $self->loc($_) : $_ }
grep { defined and length }
split( /-/, $lookup )
or return;
- return ( $self->loc( $FriendlyObjectTypes[$#types], @types ) );
+
+ state $LocStrings = [
+ "[_1] objects", # loc
+ "[_1]'s [_2] objects", # loc
+ "[_1]'s [_2]'s [_3] objects", # loc
+ ];
+ return ( $self->loc( $LocStrings->[$#types], @types ) );
}
+=head1 RecordClassFromLookupType
+
+Returns the type of Object referred to by ObjectCustomFields' ObjectId column
+
+Optionally takes a LookupType to use instead of using the value on the loaded
+record. In this case, the method may be called on the class instead of an
+object.
+
+=cut
+
sub RecordClassFromLookupType {
my $self = shift;
- my ($class) = ($self->LookupType =~ /^([^-]+)/);
+ my $type = shift || $self->LookupType;
+ my ($class) = ($type =~ /^([^-]+)/);
unless ( $class ) {
- $RT::Logger->error(
- "Custom Field #". $self->id
- ." has incorrect LookupType '". $self->LookupType ."'"
- );
+ if (blessed($self) and $self->LookupType eq $type) {
+ $RT::Logger->error(
+ "Custom Field #". $self->id
+ ." has incorrect LookupType '$type'"
+ );
+ } else {
+ RT->Logger->error("Invalid LookupType passed as argument: $type");
+ }
+ return undef;
+ }
+ return $class;
+}
+
+=head1 ObjectTypeFromLookupType
+
+Returns the ObjectType used in ObjectCustomFieldValues rows for this CF
+
+Optionally takes a LookupType to use instead of using the value on the loaded
+record. In this case, the method may be called on the class instead of an
+object.
+
+=cut
+
+sub ObjectTypeFromLookupType {
+ my $self = shift;
+ my $type = shift || $self->LookupType;
+ my ($class) = ($type =~ /([^-]+)$/);
+ unless ( $class ) {
+ if (blessed($self) and $self->LookupType eq $type) {
+ $RT::Logger->error(
+ "Custom Field #". $self->id
+ ." has incorrect LookupType '$type'"
+ );
+ } else {
+ RT->Logger->error("Invalid LookupType passed as argument: $type");
+ }
return undef;
}
return $class;
return $collection_class;
}
-=head1 ApplyGlobally
+=head2 Groupings
+
+Returns a (sorted and lowercased) list of the groupings in which this custom
+field appears.
+
+If called on a loaded object, the returned list is limited to groupings which
+apply to the record class this CF applies to (L</RecordClassFromLookupType>).
-Certain custom fields (users, groups) should only be applied globally
-but rather than regexing in code for LookupType =~ RT::Queue, we'll codify
-the rules here.
+If passed a loaded object or a class name, the returned list is limited to
+groupings which apply to the class of the object or the specified class.
+
+If called on an unloaded object, all potential groupings are returned.
=cut
-sub ApplyGlobally {
+sub Groupings {
my $self = shift;
+ my $record_class = $self->_GroupingClass(shift);
+
+ my $config = RT->Config->Get('CustomFieldGroupings');
+ $config = {} unless ref($config) eq 'HASH';
+
+ my @groups;
+ if ( $record_class ) {
+ push @groups, sort {lc($a) cmp lc($b)} keys %{ $BUILTIN_GROUPINGS{$record_class} || {} };
+ if ( ref($config->{$record_class} ||= []) eq "ARRAY") {
+ my @order = @{ $config->{$record_class} };
+ while (@order) {
+ push @groups, shift(@order);
+ shift(@order);
+ }
+ } else {
+ @groups = sort {lc($a) cmp lc($b)} keys %{ $config->{$record_class} };
+ }
+ } else {
+ my %all = (%$config, %BUILTIN_GROUPINGS);
+ @groups = sort {lc($a) cmp lc($b)} map {$self->Groupings($_)} grep {$_} keys(%all);
+ }
- return ($self->LookupType =~ /^RT::(?:Group|User)/io);
-
+ my %seen;
+ return
+ grep defined && length && !$seen{lc $_}++,
+ @groups;
}
-=head1 AppliedTo
-
-Returns collection with objects this custom field is applied to.
-Class of the collection depends on L</LookupType>.
-See all L</NotAppliedTo> .
+=head2 CustomGroupings
-Doesn't takes into account if object is applied globally.
+Identical to L</Groupings> but filters out built-in groupings from the the
+returned list.
=cut
-sub AppliedTo {
+sub CustomGroupings {
my $self = shift;
+ my $record_class = $self->_GroupingClass(shift);
+ return grep !$BUILTIN_GROUPINGS{$record_class}{$_}, $self->Groupings( $record_class );
+}
- my ($res, $ocfs_alias) = $self->_AppliedTo;
- return $res unless $res;
+sub _GroupingClass {
+ my $self = shift;
+ my $record = shift;
- $res->Limit(
- ALIAS => $ocfs_alias,
- FIELD => 'id',
- OPERATOR => 'IS NOT',
- VALUE => 'NULL',
- );
+ my $record_class = ref($record) || $record || '';
+ $record_class = $self->RecordClassFromLookupType
+ if !$record_class and blessed($self) and $self->id;
- return $res;
+ return $record_class;
}
-=head1 NotAppliedTo
+=head2 RegisterBuiltInGroupings
-Returns collection with objects this custom field is not applied to.
-Class of the collection depends on L</LookupType>.
-See all L</AppliedTo> .
+Registers groupings to be considered a fundamental part of RT, either via use
+in core RT or via an extension. These groupings must be rendered explicitly in
+Mason by specific calls to F</Elements/ShowCustomFields> and
+F</Elements/EditCustomFields>. They will not show up automatically on normal
+display pages like configured custom groupings.
-Doesn't takes into account if object is applied globally.
+Takes a set of key-value pairs of class names (valid L<RT::Record> subclasses)
+and array refs of grouping names to consider built-in.
+
+If a class already contains built-in groupings (such as L<RT::Ticket> and
+L<RT::User>), new groupings are appended.
=cut
-sub NotAppliedTo {
+sub RegisterBuiltInGroupings {
+ my $self = shift;
+ my %new = @_;
+
+ while (my ($k,$v) = each %new) {
+ $v = [$v] unless ref($v) eq 'ARRAY';
+ $BUILTIN_GROUPINGS{$k} = {
+ %{$BUILTIN_GROUPINGS{$k} || {}},
+ map { $_ => 1 } @$v
+ };
+ }
+ $BUILTIN_GROUPINGS{''} = { map { %$_ } values %BUILTIN_GROUPINGS };
+}
+
+=head1 IsOnlyGlobal
+
+Certain custom fields (users, groups) should only be added globally;
+codify that set here for reference.
+
+=cut
+
+sub IsOnlyGlobal {
my $self = shift;
- my ($res, $ocfs_alias) = $self->_AppliedTo;
- return $res unless $res;
+ return ($self->LookupType =~ /^RT::(?:Group|User)/io);
- $res->Limit(
- ALIAS => $ocfs_alias,
- FIELD => 'id',
- OPERATOR => 'IS',
- VALUE => 'NULL',
+}
+sub ApplyGlobally {
+ RT->Deprecated(
+ Instead => "IsOnlyGlobal",
+ Remove => "4.4",
);
-
- return $res;
+ return shift->IsOnlyGlobal(@_);
}
-sub _AppliedTo {
- my $self = shift;
+=head1 AddedTo
- my ($class) = $self->CollectionClassFromLookupType;
- return undef unless $class;
+Returns collection with objects this custom field is added to.
+Class of the collection depends on L</LookupType>.
+See all L</NotAddedTo> .
- my $res = $class->new( $self->CurrentUser );
+Doesn't takes into account if object is added globally.
- # If CF is a Group CF, only display user-defined groups
- if ( $class eq 'RT::Groups' ) {
- $res->LimitToUserDefinedGroups;
- }
+=cut
- $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,
+sub AddedTo {
+ my $self = shift;
+ return RT::ObjectCustomField->new( $self->CurrentUser )
+ ->AddedTo( CustomField => $self );
+}
+sub AppliedTo {
+ RT->Deprecated(
+ Instead => "AddedTo",
+ Remove => "4.4",
);
- return ($res, $ocfs_alias);
+ shift->AddedTo(@_);
+};
+
+=head1 NotAddedTo
+
+Returns collection with objects this custom field is not added to.
+Class of the collection depends on L</LookupType>.
+See all L</AddedTo> .
+
+Doesn't take into account if the object is added globally.
+
+=cut
+
+sub NotAddedTo {
+ my $self = shift;
+ return RT::ObjectCustomField->new( $self->CurrentUser )
+ ->NotAddedTo( CustomField => $self );
}
+sub NotAppliedTo {
+ RT->Deprecated(
+ Instead => "NotAddedTo",
+ Remove => "4.4",
+ );
+ shift->NotAddedTo(@_)
+};
-=head2 IsApplied
+=head2 IsAdded
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.
+record if this custom field is added to the object. Use 0 to check
+if custom field is added globally.
=cut
-sub IsApplied {
+sub IsAdded {
my $self = shift;
my $id = shift;
my $ocf = RT::ObjectCustomField->new( $self->CurrentUser );
return undef unless $ocf->id;
return $ocf;
}
+sub IsApplied {
+ RT->Deprecated(
+ Instead => "IsAdded",
+ Remove => "4.4",
+ );
+ shift->IsAdded(@_);
+};
+
+sub IsGlobal { return shift->IsAdded(0) }
+
+=head2 IsAddedToAny
+
+Returns true if custom field is applied to any object.
+
+=cut
+
+sub IsAddedToAny {
+ my $self = shift;
+ my $id = shift;
+ my $ocf = RT::ObjectCustomField->new( $self->CurrentUser );
+ $ocf->LoadByCols( CustomField => $self->id );
+ return $ocf->id ? 1 : 0;
+}
=head2 AddToObject OBJECT
=cut
-
sub AddToObject {
my $self = shift;
my $object = shift;
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,
+ my ( $oid, $msg ) = $ocf->Add(
+ CustomField => $self->id, ObjectId => $id,
);
return ( $oid, $msg );
}
return ( 0, $self->loc('Permission Denied') );
}
- my $ocf = $self->IsApplied( $id );
+ my $ocf = $self->IsAdded( $id );
unless ( $ocf ) {
- return ( 0, $self->loc("This custom field does not apply to that object") );
+ return ( 0, $self->loc("This custom field cannot be added to that object") );
}
# XXX: Delete doesn't return anything
}
}
- if (my $canonicalizer = $self->can('_CanonicalizeValue'.$self->Type)) {
- $canonicalizer->($self, \%args);
- }
-
-
-
my $newval = RT::ObjectCustomFieldValue->new( $self->CurrentUser );
my ($val, $msg) = $newval->Create(
ObjectType => ref($obj),
}
+sub _CanonicalizeValue {
+ my $self = shift;
+ my $args = shift;
+
+ my $type = $self->__Value('Type');
+ return 1 unless $type;
+
+ my $method = '_CanonicalizeValue'. $type;
+ return 1 unless $self->can($method);
+ $self->$method($args);
+}
sub _CanonicalizeValueDateTime {
my $self = shift;
$DateObj->Set( Format => 'unknown',
Value => $args->{'Content'} );
$args->{'Content'} = $DateObj->ISO;
+ return 1;
}
# For date, we need to store Content as ISO date
my $DateObj = RT::Date->new( $self->CurrentUser );
$DateObj->Set( Format => 'unknown',
Value => $args->{'Content'},
- Timezone => 'UTC',
);
- $args->{'Content'} = $DateObj->Date( Timezone => 'UTC' );
+ $args->{'Content'} = $DateObj->Date( Timezone => 'user' );
+ return 1;
+}
+
+sub _CanonicalizeValueIPAddress {
+ my $self = shift;
+ my $args = shift;
+
+ $args->{Content} = RT::ObjectCustomFieldValue->ParseIP( $args->{Content} );
+ return (0, $self->loc("Content is not a valid IP address"))
+ unless $args->{Content};
+ return 1;
+}
+
+sub _CanonicalizeValueIPAddressRange {
+ my $self = shift;
+ my $args = shift;
+
+ my $content = $args->{Content};
+ $content .= "-".$args->{LargeContent} if $args->{LargeContent};
+
+ ($args->{Content}, $args->{LargeContent})
+ = RT::ObjectCustomFieldValue->ParseIPRange( $content );
+
+ $args->{ContentType} = 'text/plain';
+ return (0, $self->loc("Content is not a valid IP address range"))
+ unless $args->{Content};
+ return 1;
}
=head2 MatchPattern STRING
my $object = shift;
my $values = RT::ObjectCustomFieldValues->new($self->CurrentUser);
- unless ($self->CurrentUserHasRight('SeeCustomField')) {
+ unless ($self->id and $self->CurrentUserHasRight('SeeCustomField')) {
# Return an empty object if they have no rights to see
+ $values->Limit( FIELD => "id", VALUE => 0, SUBCLAUSE => "ACL" );
return ($values);
}
-
-
+
$values->LimitToCustomField($self->Id);
- $values->LimitToEnabled();
$values->LimitToObject($object);
return ($values);
}
-=head2 _ForObjectType PATH FRIENDLYNAME
+=head2 RegisterLookupType LOOKUPTYPE FRIENDLYNAME
-Tell RT that a certain object accepts custom fields
+Tell RT that a certain object accepts custom fields via a lookup type and
+provide a friendly name for such CFs.
Examples:
'RT::Queue-RT::Ticket-RT::Transaction' => "Ticket Transactions", # loc
'RT::User' => "Users", # loc
'RT::Group' => "Groups", # loc
+ 'RT::Queue' => "Queues", # loc
This is a class method.
=cut
-sub _ForObjectType {
+sub RegisterLookupType {
my $self = shift;
my $path = shift;
my $friendly_name = shift;
- $FRIENDLY_OBJECT_TYPES{$path} = $friendly_name;
+ $FRIENDLY_LOOKUP_TYPES{$path} = $friendly_name;
+}
+sub _ForObjectType {
+ RT->Deprecated(
+ Instead => 'RegisterLookupType',
+ Remove => '4.4',
+ );
+ my $self = shift;
+ $self->RegisterLookupType(@_);
}
unless ( $self->CurrentUserHasRight('AdminCustomField') ) {
return ( 0, $self->loc('Permission Denied') );
}
- $self->SetAttribute( Name => $template_name, Content => $value );
+ if (length $value and defined $value) {
+ $self->SetAttribute( Name => $template_name, Content => $value );
+ } else {
+ $self->DeleteAttribute( $template_name );
+ }
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 }
-
+ my ($attr) = $self->Attributes->Named($template_name);
+ return undef unless $attr;
+ return $attr->Content;
}
}
$cf->SetContextObject( $self->ContextObject );
$cf->Load( ref $value ? $value->id : $value );
- return (0, "Permission denied")
+ return (0, "Permission Denied")
unless $cf->id && $cf->CurrentUserHasRight('SeeCustomField');
# XXX: Remove this restriction once we support lists and cascaded selects
}
}
+sub NoClone {
+ my $self = shift;
+ $self->FirstAttribute('NoClone') ? 1 : '';
+}
-
-
+sub SetNoClone {
+ my $self = shift;
+ my $value = shift;
+ if ( $value ) {
+ return $self->SetAttribute( Name => 'NoClone', Content => 1 );
+ } else {
+ return $self->DeleteAttribute('NoClone');
+ }
+}
=head2 id
=cut
-=head2 Repeated
-
-Returns the current value of Repeated.
-(In the database, Repeated is stored as smallint(6).)
-
-
-
-=head2 SetRepeated VALUE
-
-
-Set Repeated to VALUE.
-Returns (1, 'Status message') on success and (0, 'Error Message') on failure.
-(In the database, Repeated will be stored as a smallint(6).)
-
-
-=cut
-
-
=head2 BasedOn
Returns the current value of BasedOn.
{read => 1, write => 1, sql_type => 4, length => 11, is_blob => 0, is_numeric => 1, type => 'int(11)', default => ''},
Pattern =>
{read => 1, write => 1, sql_type => -4, length => 0, is_blob => 1, is_numeric => 0, type => 'text', default => ''},
- Repeated =>
- {read => 1, write => 1, sql_type => 5, length => 6, is_blob => 0, is_numeric => 1, type => 'smallint(6)', default => '0'},
+ ValuesClass =>
+ {read => 1, write => 1, sql_type => 12, length => 64, is_blob => 0, is_numeric => 0, type => 'varchar(64)', default => ''},
BasedOn =>
{read => 1, write => 1, sql_type => 4, length => 11, is_blob => 0, is_numeric => 1, type => 'int(11)', default => ''},
Description =>
}
};
+sub FindDependencies {
+ my $self = shift;
+ my ($walker, $deps) = @_;
+
+ $self->SUPER::FindDependencies($walker, $deps);
+
+ $deps->Add( out => $self->BasedOnObj )
+ if $self->BasedOnObj->id;
+
+ my $applied = RT::ObjectCustomFields->new( $self->CurrentUser );
+ $applied->LimitToCustomField( $self->id );
+ $deps->Add( in => $applied );
+
+ $deps->Add( in => $self->Values ) if $self->ValuesClass eq "RT::CustomFieldValues";
+}
+
+sub __DependsOn {
+ my $self = shift;
+ my %args = (
+ Shredder => undef,
+ Dependencies => undef,
+ @_,
+ );
+ my $deps = $args{'Dependencies'};
+ my $list = [];
+
+# Custom field values
+ push( @$list, $self->Values );
+
+# Applications of this CF
+ my $applied = RT::ObjectCustomFields->new( $self->CurrentUser );
+ $applied->LimitToCustomField( $self->Id );
+ push @$list, $applied;
+
+# Ticket custom field values
+ my $objs = RT::ObjectCustomFieldValues->new( $self->CurrentUser );
+ $objs->LimitToCustomField( $self->Id );
+ push( @$list, $objs );
+
+ $deps->_PushDependencies(
+ BaseObject => $self,
+ Flags => RT::Shredder::Constants::DEPENDS_ON,
+ TargetObjects => $list,
+ Shredder => $args{'Shredder'}
+ );
+ return $self->SUPER::__DependsOn( %args );
+}
RT::Base->_ImportOverlays();
projects / freeside.git / blobdiff