Upgrade 4.0.17 clean.
[usit-rt.git] / lib / RT / CustomFields.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 =head1 NAME
50
51   RT::CustomFields - a collection of RT CustomField objects
52
53 =head1 SYNOPSIS
54
55   use RT::CustomFields;
56
57 =head1 DESCRIPTION
58
59 =head1 METHODS
60
61
62
63 =cut
64
65
66 package RT::CustomFields;
67
68 use strict;
69 use warnings;
70
71 use DBIx::SearchBuilder::Unique;
72
73 use RT::CustomField;
74
75 use base 'RT::SearchBuilder';
76
77 sub Table { 'CustomFields'}
78
79 sub _Init {
80     my $self = shift;
81
82   # By default, order by SortOrder
83   $self->OrderByCols(
84          { ALIAS => 'main',
85            FIELD => 'SortOrder',
86            ORDER => 'ASC' },
87          { ALIAS => 'main',
88            FIELD => 'Name',
89            ORDER => 'ASC' },
90          { ALIAS => 'main',
91            FIELD => 'id',
92            ORDER => 'ASC' },
93      );
94     $self->{'with_disabled_column'} = 1;
95
96     return ( $self->SUPER::_Init(@_) );
97 }
98
99
100 =head2 LimitToLookupType
101
102 Takes LookupType and limits collection.
103
104 =cut
105
106 sub LimitToLookupType  {
107     my $self = shift;
108     my $lookup = shift;
109
110     $self->Limit( FIELD => 'LookupType', VALUE => "$lookup" );
111 }
112
113 =head2 LimitToChildType
114
115 Takes partial LookupType and limits collection to records
116 where LookupType is equal or ends with the value.
117
118 =cut
119
120 sub LimitToChildType  {
121     my $self = shift;
122     my $lookup = shift;
123
124     $self->Limit( FIELD => 'LookupType', VALUE => "$lookup" );
125     $self->Limit( FIELD => 'LookupType', ENDSWITH => "$lookup" );
126 }
127
128
129 =head2 LimitToParentType
130
131 Takes partial LookupType and limits collection to records
132 where LookupType is equal or starts with the value.
133
134 =cut
135
136 sub LimitToParentType  {
137     my $self = shift;
138     my $lookup = shift;
139
140     $self->Limit( FIELD => 'LookupType', VALUE => "$lookup" );
141     $self->Limit( FIELD => 'LookupType', STARTSWITH => "$lookup" );
142 }
143
144 =head2 LimitToObjectId
145
146 Takes an ObjectId and limits the collection to CFs applied to said object.
147
148 When called multiple times the ObjectId limits are joined with OR.
149
150 =cut
151
152 sub LimitToObjectId {
153     my $self = shift;
154     my $id = shift;
155     $self->Limit(
156         ALIAS           => $self->_OCFAlias,
157         FIELD           => 'ObjectId',
158         OPERATOR        => '=',
159         VALUE           => $id || 0,
160         ENTRYAGGREGATOR => 'OR'
161     );
162 }
163
164 =head2 LimitToGlobalOrObjectId
165
166 Takes list of object IDs and limits collection to custom
167 fields that are applied to these objects or globally.
168
169 =cut
170
171 sub LimitToGlobalOrObjectId {
172     my $self = shift;
173     my $global_only = 1;
174
175
176     foreach my $id (@_) {
177         $self->LimitToObjectId($id);
178         $global_only = 0 if $id;
179     }
180
181     $self->LimitToObjectId(0) unless $global_only;
182 }
183
184 sub _LimitToOCFs {
185     my $self = shift;
186     my @ids = @_;
187
188     my $ocfs_alias = $self->_OCFAlias( New => 1, Left => 1 );
189     if ( @ids ) {
190         # XXX: we need different EA in join clause, but DBIx::SB
191         # doesn't support them, use IN (X) instead
192         my $dbh = $self->_Handle->dbh;
193         $self->Limit(
194             LEFTJOIN   => $ocfs_alias,
195             ALIAS      => $ocfs_alias,
196             FIELD      => 'ObjectId',
197             OPERATOR   => 'IN',
198             QUOTEVALUE => 0,
199             VALUE      => "(". join( ',', map $dbh->quote($_), @ids ) .")",
200         );
201     }
202
203     return $ocfs_alias;
204 }
205
206 =head2 LimitToNotApplied
207
208 Takes either list of object ids or nothing. Limits collection
209 to custom fields to listed objects or any corespondingly. Use
210 zero to mean global.
211
212 =cut
213
214 sub LimitToNotApplied {
215     my $self = shift;
216     my @ids = @_;
217
218     my $ocfs_alias = $self->_LimitToOCFs(@ids);
219
220     $self->Limit(
221         ENTRYAGGREGATOR => 'AND',
222         ALIAS    => $ocfs_alias,
223         FIELD    => 'id',
224         OPERATOR => 'IS',
225         VALUE    => 'NULL',
226     );
227 }
228
229 =head2 LimitToApplied
230
231 Limits collection to custom fields to listed objects or any corespondingly. Use
232 zero to mean global.
233
234 =cut
235
236 sub LimitToApplied {
237     my $self = shift;
238     my @ids = @_;
239
240     my $ocfs_alias = $self->_LimitToOCFs(@ids);
241
242     $self->Limit(
243         ENTRYAGGREGATOR => 'AND',
244         ALIAS    => $ocfs_alias,
245         FIELD    => 'id',
246         OPERATOR => 'IS NOT',
247         VALUE    => 'NULL',
248     );
249 }
250
251 =head2 LimitToGlobalOrQueue QUEUEID
252
253 DEPRECATED since CFs are applicable not only to tickets these days.
254
255 Limits the set of custom fields found to global custom fields or those tied to the queue with ID QUEUEID
256
257 =cut
258
259 sub LimitToGlobalOrQueue {
260     my $self = shift;
261     my $queue = shift;
262     $self->LimitToGlobalOrObjectId( $queue );
263     $self->LimitToLookupType( 'RT::Queue-RT::Ticket' );
264 }
265
266
267 =head2 LimitToQueue QUEUEID
268
269 DEPRECATED since CFs are applicable not only to tickets these days.
270
271 Takes a queue id (numerical) as its only argument. Makes sure that
272 Scopes it pulls out apply to this queue (or another that you've selected with
273 another call to this method
274
275 =cut
276
277 sub LimitToQueue  {
278    my $self = shift;
279   my $queue = shift;
280
281   $self->Limit (ALIAS => $self->_OCFAlias,
282                 ENTRYAGGREGATOR => 'OR',
283                 FIELD => 'ObjectId',
284                 VALUE => "$queue")
285       if defined $queue;
286   $self->LimitToLookupType( 'RT::Queue-RT::Ticket' );
287 }
288
289
290 =head2 LimitToGlobal
291
292 DEPRECATED since CFs are applicable not only to tickets these days.
293
294 Makes sure that Scopes it pulls out apply to all queues
295 (or another that you've selected with
296 another call to this method or LimitToQueue)
297
298 =cut
299
300 sub LimitToGlobal  {
301    my $self = shift;
302
303   $self->Limit (ALIAS => $self->_OCFAlias,
304                 ENTRYAGGREGATOR => 'OR',
305                 FIELD => 'ObjectId',
306                 VALUE => 0);
307   $self->LimitToLookupType( 'RT::Queue-RT::Ticket' );
308 }
309
310
311 =head2 ApplySortOrder
312
313 Sort custom fields according to thier order application to objects. It's
314 expected that collection contains only records of one
315 L<RT::CustomField/LookupType> and applied to one object or globally
316 (L</LimitToGlobalOrObjectId>), otherwise sorting makes no sense.
317
318 =cut
319
320 sub ApplySortOrder {
321     my $self = shift;
322     my $order = shift || 'ASC';
323     $self->OrderByCols( {
324         ALIAS => $self->_OCFAlias,
325         FIELD => 'SortOrder',
326         ORDER => $order,
327     } );
328 }
329
330
331 =head2 ContextObject
332
333 Returns context object for this collection of custom fields,
334 but only if it's defined.
335
336 =cut
337
338 sub ContextObject {
339     my $self = shift;
340     return $self->{'context_object'};
341 }
342
343
344 =head2 SetContextObject
345
346 Sets context object for this collection of custom fields.
347
348 =cut
349
350 sub SetContextObject {
351     my $self = shift;
352     return $self->{'context_object'} = shift;
353 }
354
355
356 sub _OCFAlias {
357     my $self = shift;
358     my %args = ( New => 0, Left => 0, @_ );
359
360     return $self->{'_sql_ocfalias'} if $self->{'_sql_ocfalias'} && !$args{'New'};
361
362     my $alias = $self->Join(
363         $args{'Left'} ? (TYPE => 'LEFT') : (),
364         ALIAS1 => 'main',
365         FIELD1 => 'id',
366         TABLE2 => 'ObjectCustomFields',
367         FIELD2 => 'CustomField'
368     );
369     return $alias if $args{'New'};
370     return $self->{'_sql_ocfalias'} = $alias;
371 }
372
373
374 =head2 Next
375
376 Returns the next custom field that this user can see.
377
378 =cut
379
380 sub Next {
381     my $self = shift;
382
383     my $CF = $self->SUPER::Next();
384     return $CF unless $CF;
385
386     $CF->SetContextObject( $self->ContextObject );
387
388     return $self->Next unless $CF->CurrentUserHasRight('SeeCustomField');
389     return $CF;
390 }
391
392 =head2 NewItem
393
394 Returns an empty new RT::CustomField item
395 Overrides <RT::SearchBuilder/NewItem> to make sure </ContextObject>
396 is inherited.
397
398 =cut
399
400 sub NewItem {
401     my $self = shift;
402     my $res = RT::CustomField->new($self->CurrentUser);
403     $res->SetContextObject($self->ContextObject);
404     return $res;
405 }
406
407 RT::Base->_ImportOverlays();
408
409 1;