rt/lib/RT/Ticket_Overlay.pm

   1 # BEGIN BPS TAGGED BLOCK {{{
   2 #
   3 # COPYRIGHT:
   4 #
   5 # This software is Copyright (c) 1996-2011 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 # {{{ Front Material
  50
  51 =head1 SYNOPSIS
  52
  53   use RT::Ticket;
  54   my $ticket = new RT::Ticket($CurrentUser);
  55   $ticket->Load($ticket_id);
  56
  57 =head1 DESCRIPTION
  58
  59 This module lets you manipulate RT\'s ticket object.
  60
  61
  62 =head1 METHODS
  63
  64
  65 =cut
  66
  67
  68 package RT::Ticket;
  69
  70 use strict;
  71 no warnings qw(redefine);
  72
  73 use RT::Queue;
  74 use RT::User;
  75 use RT::Record;
  76 use RT::Links;
  77 use RT::Date;
  78 use RT::CustomFields;
  79 use RT::Tickets;
  80 use RT::Transactions;
  81 use RT::Reminders;
  82 use RT::URI::fsck_com_rt;
  83 use RT::URI;
  84 use RT::URI::freeside;
  85 use MIME::Entity;
  86
  87
  88 # {{{ LINKTYPEMAP
  89 # A helper table for links mapping to make it easier
  90 # to build and parse links between tickets
  91
  92 our %LINKTYPEMAP = (
  93     MemberOf => { Type => 'MemberOf',
  94                   Mode => 'Target', },
  95     Parents => { Type => 'MemberOf',
  96          Mode => 'Target', },
  97     Members => { Type => 'MemberOf',
  98                  Mode => 'Base', },
  99     Children => { Type => 'MemberOf',
 100           Mode => 'Base', },
 101     HasMember => { Type => 'MemberOf',
 102                    Mode => 'Base', },
 103     RefersTo => { Type => 'RefersTo',
 104                   Mode => 'Target', },
 105     ReferredToBy => { Type => 'RefersTo',
 106                       Mode => 'Base', },
 107     DependsOn => { Type => 'DependsOn',
 108                    Mode => 'Target', },
 109     DependedOnBy => { Type => 'DependsOn',
 110                       Mode => 'Base', },
 111     MergedInto => { Type => 'MergedInto',
 112                    Mode => 'Target', },
 113
 114 );
 115
 116 # }}}
 117
 118 # {{{ LINKDIRMAP
 119 # A helper table for links mapping to make it easier
 120 # to build and parse links between tickets
 121
 122 our %LINKDIRMAP = (
 123     MemberOf => { Base => 'MemberOf',
 124                   Target => 'HasMember', },
 125     RefersTo => { Base => 'RefersTo',
 126                 Target => 'ReferredToBy', },
 127     DependsOn => { Base => 'DependsOn',
 128                    Target => 'DependedOnBy', },
 129     MergedInto => { Base => 'MergedInto',
 130                    Target => 'MergedInto', },
 131
 132 );
 133
 134 # }}}
 135
 136 sub LINKTYPEMAP   { return \%LINKTYPEMAP   }
 137 sub LINKDIRMAP   { return \%LINKDIRMAP   }
 138
 139 our %MERGE_CACHE = (
 140     effective => {},
 141     merged => {},
 142 );
 143
 144 # {{{ sub Load
 145
 146 =head2 Load
 147
 148 Takes a single argument. This can be a ticket id, ticket alias or
 149 local ticket uri.  If the ticket can't be loaded, returns undef.
 150 Otherwise, returns the ticket id.
 151
 152 =cut
 153
 154 sub Load {
 155     my $self = shift;
 156     my $id   = shift;
 157     $id = '' unless defined $id;
 158
 159     # TODO: modify this routine to look at EffectiveId and
 160     # do the recursive load thing. be careful to cache all
 161     # the interim tickets we try so we don't loop forever.
 162
 163     # FIXME: there is no TicketBaseURI option in config
 164     my $base_uri = RT->Config->Get('TicketBaseURI') || '';
 165     #If it's a local URI, turn it into a ticket id
 166     if ( $base_uri && $id =~ /^$base_uri(\d+)$/ ) {
 167         $id = $1;
 168     }
 169
 170     unless ( $id =~ /^\d+$/ ) {
 171         $RT::Logger->debug("Tried to load a bogus ticket id: '$id'");
 172         return (undef);
 173     }
 174
 175     $id = $MERGE_CACHE{'effective'}{ $id }
 176         if $MERGE_CACHE{'effective'}{ $id };
 177
 178     my ($ticketid, $msg) = $self->LoadById( $id );
 179     unless ( $self->Id ) {
 180         $RT::Logger->debug("$self tried to load a bogus ticket: $id");
 181         return (undef);
 182     }
 183
 184     #If we're merged, resolve the merge.
 185     if ( $self->EffectiveId && $self->EffectiveId != $self->Id ) {
 186         $RT::Logger->debug(
 187             "We found a merged ticket. "
 188             . $self->id ."/". $self->EffectiveId
 189         );
 190         my $real_id = $self->Load( $self->EffectiveId );
 191         $MERGE_CACHE{'effective'}{ $id } = $real_id;
 192         return $real_id;
 193     }
 194
 195     #Ok. we're loaded. lets get outa here.
 196     return $self->Id;
 197 }
 198
 199 # }}}
 200
 201 # {{{ sub Create
 202
 203 =head2 Create (ARGS)
 204
 205 Arguments: ARGS is a hash of named parameters.  Valid parameters are:
 206
 207   id
 208   Queue  - Either a Queue object or a Queue Name
 209   Requestor -  A reference to a list of  email addresses or RT user Names
 210   Cc  - A reference to a list of  email addresses or Names
 211   AdminCc  - A reference to a  list of  email addresses or Names
 212   SquelchMailTo - A reference to a list of email addresses -
 213                   who should this ticket not mail
 214   Type -- The ticket\'s type. ignore this for now
 215   Owner -- This ticket\'s owner. either an RT::User object or this user\'s id
 216   Subject -- A string describing the subject of the ticket
 217   Priority -- an integer from 0 to 99
 218   InitialPriority -- an integer from 0 to 99
 219   FinalPriority -- an integer from 0 to 99
 220   Status -- any valid status (Defined in RT::Queue)
 221   TimeEstimated -- an integer. estimated time for this task in minutes
 222   TimeWorked -- an integer. time worked so far in minutes
 223   TimeLeft -- an integer. time remaining in minutes
 224   Starts -- an ISO date describing the ticket\'s start date and time in GMT
 225   Due -- an ISO date describing the ticket\'s due date and time in GMT
 226   MIMEObj -- a MIME::Entity object with the content of the initial ticket request.
 227   CustomField-<n> -- a scalar or array of values for the customfield with the id <n>
 228
 229 Ticket links can be set up during create by passing the link type as a hask key and
 230 the ticket id to be linked to as a value (or a URI when linking to other objects).
 231 Multiple links of the same type can be created by passing an array ref. For example:
 232
 233   Parents => 45,
 234   DependsOn => [ 15, 22 ],
 235   RefersTo => 'http://www.bestpractical.com',
 236
 237 Supported link types are C<MemberOf>, C<HasMember>, C<RefersTo>, C<ReferredToBy>,
 238 C<DependsOn> and C<DependedOnBy>. Also, C<Parents> is alias for C<MemberOf> and
 239 C<Members> and C<Children> are aliases for C<HasMember>.
 240
 241 Returns: TICKETID, Transaction Object, Error Message
 242
 243
 244 =cut
 245
 246 sub Create {
 247     my $self = shift;
 248
 249     my %args = (
 250         id                 => undef,
 251         EffectiveId        => undef,
 252         Queue              => undef,
 253         Requestor          => undef,
 254         Cc                 => undef,
 255         AdminCc            => undef,
 256         SquelchMailTo      => undef,
 257         Type               => 'ticket',
 258         Owner              => undef,
 259         Subject            => '',
 260         InitialPriority    => undef,
 261         FinalPriority      => undef,
 262         Priority           => undef,
 263         Status             => 'new',
 264         TimeWorked         => "0",
 265         TimeLeft           => 0,
 266         TimeEstimated      => 0,
 267         Due                => undef,
 268         Starts             => undef,
 269         Started            => undef,
 270         Resolved           => undef,
 271         MIMEObj            => undef,
 272         _RecordTransaction => 1,
 273         DryRun             => 0,
 274         @_
 275     );
 276
 277     my ($ErrStr, @non_fatal_errors);
 278
 279     my $QueueObj = RT::Queue->new( $RT::SystemUser );
 280     if ( ref $args{'Queue'} eq 'RT::Queue' ) {
 281         $QueueObj->Load( $args{'Queue'}->Id );
 282     }
 283     elsif ( $args{'Queue'} ) {
 284         $QueueObj->Load( $args{'Queue'} );
 285     }
 286     else {
 287         $RT::Logger->debug("'". ( $args{'Queue'} ||''). "' not a recognised queue object." );
 288     }
 289
 290     #Can't create a ticket without a queue.
 291     unless ( $QueueObj->Id ) {
 292         $RT::Logger->debug("$self No queue given for ticket creation.");
 293         return ( 0, 0, $self->loc('Could not create ticket. Queue not set') );
 294     }
 295
 296
 297     #Now that we have a queue, Check the ACLS
 298     unless (
 299         $self->CurrentUser->HasRight(
 300             Right  => 'CreateTicket',
 301             Object => $QueueObj
 302         )
 303       )
 304     {
 305         return (
 306             0, 0,
 307             $self->loc( "No permission to create tickets in the queue '[_1]'", $QueueObj->Name));
 308     }
 309
 310     unless ( $QueueObj->IsValidStatus( $args{'Status'} ) ) {
 311         return ( 0, 0, $self->loc('Invalid value for status') );
 312     }
 313
 314     #Since we have a queue, we can set queue defaults
 315
 316     #Initial Priority
 317     # If there's no queue default initial priority and it's not set, set it to 0
 318     $args{'InitialPriority'} = $QueueObj->InitialPriority || 0
 319         unless defined $args{'InitialPriority'};
 320
 321     #Final priority
 322     # If there's no queue default final priority and it's not set, set it to 0
 323     $args{'FinalPriority'} = $QueueObj->FinalPriority || 0
 324         unless defined $args{'FinalPriority'};
 325
 326     # Priority may have changed from InitialPriority, for the case
 327     # where we're importing tickets (eg, from an older RT version.)
 328     $args{'Priority'} = $args{'InitialPriority'}
 329         unless defined $args{'Priority'};
 330
 331     # {{{ Dates
 332     #TODO we should see what sort of due date we're getting, rather +
 333     # than assuming it's in ISO format.
 334
 335     #Set the due date. if we didn't get fed one, use the queue default due in
 336     my $Due = new RT::Date( $self->CurrentUser );
 337     if ( defined $args{'Due'} ) {
 338         $Due->Set( Format => 'ISO', Value => $args{'Due'} );
 339     }
 340     elsif ( my $due_in = $QueueObj->DefaultDueIn ) {
 341         $Due->SetToNow;
 342         $Due->AddDays( $due_in );
 343     }
 344
 345     my $Starts = new RT::Date( $self->CurrentUser );
 346     if ( defined $args{'Starts'} ) {
 347         $Starts->Set( Format => 'ISO', Value => $args{'Starts'} );
 348     }
 349
 350     my $Started = new RT::Date( $self->CurrentUser );
 351     if ( defined $args{'Started'} ) {
 352         $Started->Set( Format => 'ISO', Value => $args{'Started'} );
 353     }
 354     elsif ( $args{'Status'} ne 'new' ) {
 355         $Started->SetToNow;
 356     }
 357
 358     my $Resolved = new RT::Date( $self->CurrentUser );
 359     if ( defined $args{'Resolved'} ) {
 360         $Resolved->Set( Format => 'ISO', Value => $args{'Resolved'} );
 361     }
 362
 363     #If the status is an inactive status, set the resolved date
 364     elsif ( $QueueObj->IsInactiveStatus( $args{'Status'} ) )
 365     {
 366         $RT::Logger->debug( "Got a ". $args{'Status'}
 367             ."(inactive) ticket with undefined resolved date. Setting to now."
 368         );
 369         $Resolved->SetToNow;
 370     }
 371
 372     # }}}
 373
 374     # {{{ Dealing with time fields
 375
 376     $args{'TimeEstimated'} = 0 unless defined $args{'TimeEstimated'};
 377     $args{'TimeWorked'}    = 0 unless defined $args{'TimeWorked'};
 378     $args{'TimeLeft'}      = 0 unless defined $args{'TimeLeft'};
 379
 380     # }}}
 381
 382     # {{{ Deal with setting the owner
 383
 384     my $Owner;
 385     if ( ref( $args{'Owner'} ) eq 'RT::User' ) {
 386         if ( $args{'Owner'}->id ) {
 387             $Owner = $args{'Owner'};
 388         } else {
 389             $RT::Logger->error('passed not loaded owner object');
 390             push @non_fatal_errors, $self->loc("Invalid owner object");
 391             $Owner = undef;
 392         }
 393     }
 394
 395     #If we've been handed something else, try to load the user.
 396     elsif ( $args{'Owner'} ) {
 397         $Owner = RT::User->new( $self->CurrentUser );
 398         $Owner->Load( $args{'Owner'} );
 399         $Owner->LoadByEmail( $args{'Owner'} )
 400             unless $Owner->Id;
 401         unless ( $Owner->Id ) {
 402             push @non_fatal_errors,
 403                 $self->loc("Owner could not be set.") . " "
 404               . $self->loc( "User '[_1]' could not be found.", $args{'Owner'} );
 405             $Owner = undef;
 406         }
 407     }
 408
 409     #If we have a proposed owner and they don't have the right
 410     #to own a ticket, scream about it and make them not the owner
 411
 412     my $DeferOwner;
 413     if ( $Owner && $Owner->Id != $RT::Nobody->Id
 414         && !$Owner->HasRight( Object => $QueueObj, Right  => 'OwnTicket' ) )
 415     {
 416         $DeferOwner = $Owner;
 417         $Owner = undef;
 418         $RT::Logger->debug('going to deffer setting owner');
 419
 420     }
 421
 422     #If we haven't been handed a valid owner, make it nobody.
 423     unless ( defined($Owner) && $Owner->Id ) {
 424         $Owner = new RT::User( $self->CurrentUser );
 425         $Owner->Load( $RT::Nobody->Id );
 426     }
 427
 428     # }}}
 429
 430 # We attempt to load or create each of the people who might have a role for this ticket
 431 # _outside_ the transaction, so we don't get into ticket creation races
 432     foreach my $type ( "Cc", "AdminCc", "Requestor" ) {
 433         $args{ $type } = [ $args{ $type } ] unless ref $args{ $type };
 434         foreach my $watcher ( splice @{ $args{$type} } ) {
 435             next unless $watcher;
 436             if ( $watcher =~ /^\d+$/ ) {
 437                 push @{ $args{$type} }, $watcher;
 438             } else {
 439                 my @addresses = RT::EmailParser->ParseEmailAddress( $watcher );
 440                 foreach my $address( @addresses ) {
 441                     my $user = RT::User->new( $RT::SystemUser );
 442                     my ($uid, $msg) = $user->LoadOrCreateByEmail( $address );
 443                     unless ( $uid ) {
 444                         push @non_fatal_errors,
 445                             $self->loc("Couldn't load or create user: [_1]", $msg);
 446                     } else {
 447                         push @{ $args{$type} }, $user->id;
 448                     }
 449                 }
 450             }
 451         }
 452     }
 453
 454     $RT::Handle->BeginTransaction();
 455
 456     my %params = (
 457         Queue           => $QueueObj->Id,
 458         Owner           => $Owner->Id,
 459         Subject         => $args{'Subject'},
 460         InitialPriority => $args{'InitialPriority'},
 461         FinalPriority   => $args{'FinalPriority'},
 462         Priority        => $args{'Priority'},
 463         Status          => $args{'Status'},
 464         TimeWorked      => $args{'TimeWorked'},
 465         TimeEstimated   => $args{'TimeEstimated'},
 466         TimeLeft        => $args{'TimeLeft'},
 467         Type            => $args{'Type'},
 468         Starts          => $Starts->ISO,
 469         Started         => $Started->ISO,
 470         Resolved        => $Resolved->ISO,
 471         Due             => $Due->ISO
 472     );
 473
 474 # Parameters passed in during an import that we probably don't want to touch, otherwise
 475     foreach my $attr qw(id Creator Created LastUpdated LastUpdatedBy) {
 476         $params{$attr} = $args{$attr} if $args{$attr};
 477     }
 478
 479     # Delete null integer parameters
 480     foreach my $attr
 481         qw(TimeWorked TimeLeft TimeEstimated InitialPriority FinalPriority)
 482     {
 483         delete $params{$attr}
 484           unless ( exists $params{$attr} && $params{$attr} );
 485     }
 486
 487     # Delete the time worked if we're counting it in the transaction
 488     delete $params{'TimeWorked'} if $args{'_RecordTransaction'};
 489
 490     my ($id,$ticket_message) = $self->SUPER::Create( %params );
 491     unless ($id) {
 492         $RT::Logger->crit( "Couldn't create a ticket: " . $ticket_message );
 493         $RT::Handle->Rollback();
 494         return ( 0, 0,
 495             $self->loc("Ticket could not be created due to an internal error")
 496         );
 497     }
 498
 499     #Set the ticket's effective ID now that we've created it.
 500     my ( $val, $msg ) = $self->__Set(
 501         Field => 'EffectiveId',
 502         Value => ( $args{'EffectiveId'} || $id )
 503     );
 504     unless ( $val ) {
 505         $RT::Logger->crit("Couldn't set EffectiveId: $msg");
 506         $RT::Handle->Rollback;
 507         return ( 0, 0,
 508             $self->loc("Ticket could not be created due to an internal error")
 509         );
 510     }
 511
 512     my $create_groups_ret = $self->_CreateTicketGroups();
 513     unless ($create_groups_ret) {
 514         $RT::Logger->crit( "Couldn't create ticket groups for ticket "
 515               . $self->Id
 516               . ". aborting Ticket creation." );
 517         $RT::Handle->Rollback();
 518         return ( 0, 0,
 519             $self->loc("Ticket could not be created due to an internal error")
 520         );
 521     }
 522
 523     # Set the owner in the Groups table
 524     # We denormalize it into the Ticket table too because doing otherwise would
 525     # kill performance, bigtime. It gets kept in lockstep thanks to the magic of transactionalization
 526     $self->OwnerGroup->_AddMember(
 527         PrincipalId       => $Owner->PrincipalId,
 528         InsideTransaction => 1
 529     ) unless $DeferOwner;
 530
 531
 532
 533     # {{{ Deal with setting up watchers
 534
 535     foreach my $type ( "Cc", "AdminCc", "Requestor" ) {
 536         # we know it's an array ref
 537         foreach my $watcher ( @{ $args{$type} } ) {
 538
 539             # Note that we're using AddWatcher, rather than _AddWatcher, as we
 540             # actually _want_ that ACL check. Otherwise, random ticket creators
 541             # could make themselves adminccs and maybe get ticket rights. that would
 542             # be poor
 543             my $method = $type eq 'AdminCc'? 'AddWatcher': '_AddWatcher';
 544
 545             my ($val, $msg) = $self->$method(
 546                 Type   => $type,
 547                 PrincipalId => $watcher,
 548                 Silent => 1,
 549             );
 550             push @non_fatal_errors, $self->loc("Couldn't set [_1] watcher: [_2]", $type, $msg)
 551                 unless $val;
 552         }
 553     }
 554
 555     if ($args{'SquelchMailTo'}) {
 556        my @squelch = ref( $args{'SquelchMailTo'} ) ? @{ $args{'SquelchMailTo'} }
 557         : $args{'SquelchMailTo'};
 558         $self->_SquelchMailTo( @squelch );
 559     }
 560
 561
 562     # }}}
 563
 564     # {{{ Add all the custom fields
 565
 566     foreach my $arg ( keys %args ) {
 567         next unless $arg =~ /^CustomField-(\d+)$/i;
 568         my $cfid = $1;
 569
 570         foreach my $value (
 571             UNIVERSAL::isa( $args{$arg} => 'ARRAY' ) ? @{ $args{$arg} } : ( $args{$arg} ) )
 572         {
 573             next unless defined $value && length $value;
 574
 575             # Allow passing in uploaded LargeContent etc by hash reference
 576             my ($status, $msg) = $self->_AddCustomFieldValue(
 577                 (UNIVERSAL::isa( $value => 'HASH' )
 578                     ? %$value
 579                     : (Value => $value)
 580                 ),
 581                 Field             => $cfid,
 582                 RecordTransaction => 0,
 583             );
 584             push @non_fatal_errors, $msg unless $status;
 585         }
 586     }
 587
 588     # }}}
 589
 590     # {{{ Deal with setting up links
 591
 592     # TODO: Adding link may fire scrips on other end and those scrips
 593     # could create transactions on this ticket before 'Create' transaction.
 594     #
 595     # We should implement different schema: record 'Create' transaction,
 596     # create links and only then fire create transaction's scrips.
 597     #
 598     # Ideal variant: add all links without firing scrips, record create
 599     # transaction and only then fire scrips on the other ends of links.
 600     #
 601     # //RUZ
 602
 603     foreach my $type ( keys %LINKTYPEMAP ) {
 604         next unless ( defined $args{$type} );
 605         foreach my $link (
 606             ref( $args{$type} ) ? @{ $args{$type} } : ( $args{$type} ) )
 607         {
 608             # Check rights on the other end of the link if we must
 609             # then run _AddLink that doesn't check for ACLs
 610             if ( RT->Config->Get( 'StrictLinkACL' ) ) {
 611                 my ($val, $msg, $obj) = $self->__GetTicketFromURI( URI => $link );
 612                 unless ( $val ) {
 613                     push @non_fatal_errors, $msg;
 614                     next;
 615                 }
 616                 if ( $obj && !$obj->CurrentUserHasRight('ModifyTicket') ) {
 617                     push @non_fatal_errors, $self->loc('Linking. Permission denied');
 618                     next;
 619                 }
 620             }
 621
 622             #don't show transactions for reminders
 623             my $silent = ( !$args{'_RecordTransaction'}
 624                            || $self->Type eq 'reminder'
 625                          );
 626
 627             my ( $wval, $wmsg ) = $self->_AddLink(
 628                 Type                          => $LINKTYPEMAP{$type}->{'Type'},
 629                 $LINKTYPEMAP{$type}->{'Mode'} => $link,
 630                 Silent                        => $silent,
 631                 'Silent'. ( $LINKTYPEMAP{$type}->{'Mode'} eq 'Base'? 'Target': 'Base' )
 632                                               => 1,
 633             );
 634
 635             push @non_fatal_errors, $wmsg unless ($wval);
 636         }
 637     }
 638
 639     # }}}
 640
 641     # {{{ Deal with auto-customer association
 642
 643     #unless we already have (a) customer(s)...
 644     unless ( $self->Customers->Count ) {
 645
 646       #first find any requestors with emails but *without* customer targets
 647       my @NoCust_Requestors =
 648         grep { $_->EmailAddress && ! $_->Customers->Count }
 649              @{ $self->_Requestors->UserMembersObj->ItemsArrayRef };
 650
 651       for my $Requestor (@NoCust_Requestors) {
 652
 653          #perhaps the stuff in here should be in a User method??
 654          my @Customers =
 655            &RT::URI::freeside::email_search( email=>$Requestor->EmailAddress );
 656
 657          foreach my $custnum ( map $_->{'custnum'}, @Customers ) {
 658
 659            ## false laziness w/RT/Interface/Web_Vendor.pm
 660            my @link = ( 'Type'   => 'MemberOf',
 661                         'Target' => "freeside://freeside/cust_main/$custnum",
 662                       );
 663
 664            my( $val, $msg ) = $Requestor->_AddLink(@link);
 665            #XXX should do something with $msg# push @non_fatal_errors, $msg;
 666
 667          }
 668
 669       }
 670
 671       #find any requestors with customer targets
 672
 673       my %cust_target = ();
 674
 675       my @Requestors =
 676         grep { $_->Customers->Count }
 677              @{ $self->_Requestors->UserMembersObj->ItemsArrayRef };
 678
 679       foreach my $Requestor ( @Requestors ) {
 680         foreach my $cust_link ( @{ $Requestor->Customers->ItemsArrayRef } ) {
 681           $cust_target{ $cust_link->Target } = 1;
 682         }
 683       }
 684
 685       #and then auto-associate this ticket with those customers
 686
 687       foreach my $cust_target ( keys %cust_target ) {
 688
 689         my @link = ( 'Type'   => 'MemberOf',
 690                      #'Target' => "freeside://freeside/cust_main/$custnum",
 691                      'Target' => $cust_target,
 692                    );
 693
 694         my( $val, $msg ) = $self->_AddLink(@link);
 695         push @non_fatal_errors, $msg;
 696
 697       }
 698
 699     }
 700
 701     # }}}
 702
 703     # Now that we've created the ticket and set up its metadata, we can actually go and check OwnTicket on the ticket itself.
 704     # This might be different than before in cases where extensions like RTIR are doing clever things with RT's ACL system
 705     if (  $DeferOwner ) {
 706             if (!$DeferOwner->HasRight( Object => $self, Right  => 'OwnTicket')) {
 707
 708             $RT::Logger->warning( "User " . $DeferOwner->Name . "(" . $DeferOwner->id
 709                 . ") was proposed as a ticket owner but has no rights to own "
 710                 . "tickets in " . $QueueObj->Name );
 711             push @non_fatal_errors, $self->loc(
 712                 "Owner '[_1]' does not have rights to own this ticket.",
 713                 $DeferOwner->Name
 714             );
 715         } else {
 716             $Owner = $DeferOwner;
 717             $self->__Set(Field => 'Owner', Value => $Owner->id);
 718         }
 719         $self->OwnerGroup->_AddMember(
 720             PrincipalId       => $Owner->PrincipalId,
 721             InsideTransaction => 1
 722         );
 723     }
 724
 725     #don't make a transaction or fire off any scrips for reminders either
 726     if ( $args{'_RecordTransaction'} && $self->Type ne 'reminder' ) {
 727
 728         # {{{ Add a transaction for the create
 729         my ( $Trans, $Msg, $TransObj ) = $self->_NewTransaction(
 730             Type         => "Create",
 731             TimeTaken    => $args{'TimeWorked'},
 732             MIMEObj      => $args{'MIMEObj'},
 733             CommitScrips => !$args{'DryRun'},
 734         );
 735
 736         if ( $self->Id && $Trans ) {
 737
 738           #$TransObj->UpdateCustomFields(ARGSRef => \%args);
 739             $TransObj->UpdateCustomFields(%args);
 740
 741             $RT::Logger->info( "Ticket " . $self->Id . " created in queue '" . $QueueObj->Name . "' by " . $self->CurrentUser->Name );
 742             $ErrStr = $self->loc( "Ticket [_1] created in queue '[_2]'", $self->Id, $QueueObj->Name );
 743             $ErrStr = join( "\n", $ErrStr, @non_fatal_errors );
 744         }
 745         else {
 746             $RT::Handle->Rollback();
 747
 748             $ErrStr = join( "\n", $ErrStr, @non_fatal_errors );
 749             $RT::Logger->error("Ticket couldn't be created: $ErrStr");
 750             return ( 0, 0, $self->loc( "Ticket could not be created due to an internal error"));
 751         }
 752
 753         if ( $args{'DryRun'} ) {
 754             $RT::Handle->Rollback();
 755             return ($self->id, $TransObj, $ErrStr);
 756         }
 757         $RT::Handle->Commit();
 758         return ( $self->Id, $TransObj->Id, $ErrStr );
 759
 760         # }}}
 761     }
 762     else {
 763
 764         # Not going to record a transaction
 765         $RT::Handle->Commit();
 766         $ErrStr = $self->loc( "Ticket [_1] created in queue '[_2]'", $self->Id, $QueueObj->Name );
 767         $ErrStr = join( "\n", $ErrStr, @non_fatal_errors );
 768         return ( $self->Id, 0, $ErrStr );
 769
 770     }
 771 }
 772
 773
 774 # }}}
 775
 776 # {{{ _Parse822HeadersForAttributes Content
 777
 778 =head2 _Parse822HeadersForAttributes Content
 779
 780 Takes an RFC822 style message and parses its attributes into a hash.
 781
 782 =cut
 783
 784 sub _Parse822HeadersForAttributes {
 785     my $self    = shift;
 786     my $content = shift;
 787     my %args;
 788
 789     my @lines = ( split ( /\n/, $content ) );
 790     while ( defined( my $line = shift @lines ) ) {
 791         if ( $line =~ /^(.*?):(?:\s+(.*))?$/ ) {
 792             my $value = $2;
 793             my $tag   = lc($1);
 794
 795             $tag =~ s/-//g;
 796             if ( defined( $args{$tag} ) )
 797             {    #if we're about to get a second value, make it an array
 798                 $args{$tag} = [ $args{$tag} ];
 799             }
 800             if ( ref( $args{$tag} ) )
 801             {    #If it's an array, we want to push the value
 802                 push @{ $args{$tag} }, $value;
 803             }
 804             else {    #if there's nothing there, just set the value
 805                 $args{$tag} = $value;
 806             }
 807         } elsif ($line =~ /^$/) {
 808
 809             #TODO: this won't work, since "" isn't of the form "foo:value"
 810
 811                 while ( defined( my $l = shift @lines ) ) {
 812                     push @{ $args{'content'} }, $l;
 813                 }
 814             }
 815
 816     }
 817
 818     foreach my $date qw(due starts started resolved) {
 819         my $dateobj = RT::Date->new($RT::SystemUser);
 820         if ( defined ($args{$date}) and $args{$date} =~ /^\d+$/ ) {
 821             $dateobj->Set( Format => 'unix', Value => $args{$date} );
 822         }
 823         else {
 824             $dateobj->Set( Format => 'unknown', Value => $args{$date} );
 825         }
 826         $args{$date} = $dateobj->ISO;
 827     }
 828     $args{'mimeobj'} = MIME::Entity->new();
 829     $args{'mimeobj'}->build(
 830         Type => ( $args{'contenttype'} || 'text/plain' ),
 831         Data => ($args{'content'} || '')
 832     );
 833
 834     return (%args);
 835 }
 836
 837 # }}}
 838
 839 # {{{ sub Import
 840
 841 =head2 Import PARAMHASH
 842
 843 Import a ticket.
 844 Doesn\'t create a transaction.
 845 Doesn\'t supply queue defaults, etc.
 846
 847 Returns: TICKETID
 848
 849 =cut
 850
 851 sub Import {
 852     my $self = shift;
 853     my ( $ErrStr, $QueueObj, $Owner );
 854
 855     my %args = (
 856         id              => undef,
 857         EffectiveId     => undef,
 858         Queue           => undef,
 859         Requestor       => undef,
 860         Type            => 'ticket',
 861         Owner           => $RT::Nobody->Id,
 862         Subject         => '[no subject]',
 863         InitialPriority => undef,
 864         FinalPriority   => undef,
 865         Status          => 'new',
 866         TimeWorked      => "0",
 867         Due             => undef,
 868         Created         => undef,
 869         Updated         => undef,
 870         Resolved        => undef,
 871         Told            => undef,
 872         @_
 873     );
 874
 875     if ( ( defined( $args{'Queue'} ) ) && ( !ref( $args{'Queue'} ) ) ) {
 876         $QueueObj = RT::Queue->new($RT::SystemUser);
 877         $QueueObj->Load( $args{'Queue'} );
 878
 879         #TODO error check this and return 0 if it\'s not loading properly +++
 880     }
 881     elsif ( ref( $args{'Queue'} ) eq 'RT::Queue' ) {
 882         $QueueObj = RT::Queue->new($RT::SystemUser);
 883         $QueueObj->Load( $args{'Queue'}->Id );
 884     }
 885     else {
 886         $RT::Logger->debug(
 887             "$self " . $args{'Queue'} . " not a recognised queue object." );
 888     }
 889
 890     #Can't create a ticket without a queue.
 891     unless ( defined($QueueObj) and $QueueObj->Id ) {
 892         $RT::Logger->debug("$self No queue given for ticket creation.");
 893         return ( 0, $self->loc('Could not create ticket. Queue not set') );
 894     }
 895
 896     #Now that we have a queue, Check the ACLS
 897     unless (
 898         $self->CurrentUser->HasRight(
 899             Right    => 'CreateTicket',
 900             Object => $QueueObj
 901         )
 902       )
 903     {
 904         return ( 0,
 905             $self->loc("No permission to create tickets in the queue '[_1]'"
 906               , $QueueObj->Name));
 907     }
 908
 909     # {{{ Deal with setting the owner
 910
 911     # Attempt to take user object, user name or user id.
 912     # Assign to nobody if lookup fails.
 913     if ( defined( $args{'Owner'} ) ) {
 914         if ( ref( $args{'Owner'} ) ) {
 915             $Owner = $args{'Owner'};
 916         }
 917         else {
 918             $Owner = new RT::User( $self->CurrentUser );
 919             $Owner->Load( $args{'Owner'} );
 920             if ( !defined( $Owner->id ) ) {
 921                 $Owner->Load( $RT::Nobody->id );
 922             }
 923         }
 924     }
 925
 926     #If we have a proposed owner and they don't have the right
 927     #to own a ticket, scream about it and make them not the owner
 928     if (
 929         ( defined($Owner) )
 930         and ( $Owner->Id != $RT::Nobody->Id )
 931         and (
 932             !$Owner->HasRight(
 933                 Object => $QueueObj,
 934                 Right    => 'OwnTicket'
 935             )
 936         )
 937       )
 938     {
 939
 940         $RT::Logger->warning( "$self user "
 941               . $Owner->Name . "("
 942               . $Owner->id
 943               . ") was proposed "
 944               . "as a ticket owner but has no rights to own "
 945               . "tickets in '"
 946               . $QueueObj->Name . "'" );
 947
 948         $Owner = undef;
 949     }
 950
 951     #If we haven't been handed a valid owner, make it nobody.
 952     unless ( defined($Owner) ) {
 953         $Owner = new RT::User( $self->CurrentUser );
 954         $Owner->Load( $RT::Nobody->UserObj->Id );
 955     }
 956
 957     # }}}
 958
 959     unless ( $self->ValidateStatus( $args{'Status'} ) ) {
 960         return ( 0, $self->loc("'[_1]' is an invalid value for status", $args{'Status'}) );
 961     }
 962
 963     $self->{'_AccessibleCache'}{Created}       = { 'read' => 1, 'write' => 1 };
 964     $self->{'_AccessibleCache'}{Creator}       = { 'read' => 1, 'auto'  => 1 };
 965     $self->{'_AccessibleCache'}{LastUpdated}   = { 'read' => 1, 'write' => 1 };
 966     $self->{'_AccessibleCache'}{LastUpdatedBy} = { 'read' => 1, 'auto'  => 1 };
 967
 968     # If we're coming in with an id, set that now.
 969     my $EffectiveId = undef;
 970     if ( $args{'id'} ) {
 971         $EffectiveId = $args{'id'};
 972
 973     }
 974
 975     my $id = $self->SUPER::Create(
 976         id              => $args{'id'},
 977         EffectiveId     => $EffectiveId,
 978         Queue           => $QueueObj->Id,
 979         Owner           => $Owner->Id,
 980         Subject         => $args{'Subject'},        # loc
 981         InitialPriority => $args{'InitialPriority'},    # loc
 982         FinalPriority   => $args{'FinalPriority'},    # loc
 983         Priority        => $args{'InitialPriority'},    # loc
 984         Status          => $args{'Status'},        # loc
 985         TimeWorked      => $args{'TimeWorked'},        # loc
 986         Type            => $args{'Type'},        # loc
 987         Created         => $args{'Created'},        # loc
 988         Told            => $args{'Told'},        # loc
 989         LastUpdated     => $args{'Updated'},        # loc
 990         Resolved        => $args{'Resolved'},        # loc
 991         Due             => $args{'Due'},        # loc
 992     );
 993
 994     # If the ticket didn't have an id
 995     # Set the ticket's effective ID now that we've created it.
 996     if ( $args{'id'} ) {
 997         $self->Load( $args{'id'} );
 998     }
 999     else {
1000         my ( $val, $msg ) =
1001           $self->__Set( Field => 'EffectiveId', Value => $id );
1002
1003         unless ($val) {
1004             $RT::Logger->err(
1005                 $self . "->Import couldn't set EffectiveId: $msg" );
1006         }
1007     }
1008
1009     my $create_groups_ret = $self->_CreateTicketGroups();
1010     unless ($create_groups_ret) {
1011         $RT::Logger->crit(
1012             "Couldn't create ticket groups for ticket " . $self->Id );
1013     }
1014
1015     $self->OwnerGroup->_AddMember( PrincipalId => $Owner->PrincipalId );
1016
1017     my $watcher;
1018     foreach $watcher ( @{ $args{'Cc'} } ) {
1019         $self->_AddWatcher( Type => 'Cc', Email => $watcher, Silent => 1 );
1020     }
1021     foreach $watcher ( @{ $args{'AdminCc'} } ) {
1022         $self->_AddWatcher( Type => 'AdminCc', Email => $watcher,
1023             Silent => 1 );
1024     }
1025     foreach $watcher ( @{ $args{'Requestor'} } ) {
1026         $self->_AddWatcher( Type => 'Requestor', Email => $watcher,
1027             Silent => 1 );
1028     }
1029
1030     return ( $self->Id, $ErrStr );
1031 }
1032
1033 # }}}
1034
1035 # {{{ Routines dealing with watchers.
1036
1037 # {{{ _CreateTicketGroups
1038
1039 =head2 _CreateTicketGroups
1040
1041 Create the ticket groups and links for this ticket.
1042 This routine expects to be called from Ticket->Create _inside of a transaction_
1043
1044 It will create four groups for this ticket: Requestor, Cc, AdminCc and Owner.
1045
1046 It will return true on success and undef on failure.
1047
1048
1049 =cut
1050
1051
1052 sub _CreateTicketGroups {
1053     my $self = shift;
1054
1055     my @types = qw(Requestor Owner Cc AdminCc);
1056
1057     foreach my $type (@types) {
1058         my $type_obj = RT::Group->new($self->CurrentUser);
1059         my ($id, $msg) = $type_obj->CreateRoleGroup(Domain => 'RT::Ticket-Role',
1060                                                        Instance => $self->Id,
1061                                                        Type => $type);
1062         unless ($id) {
1063             $RT::Logger->error("Couldn't create a ticket group of type '$type' for ticket ".
1064                                $self->Id.": ".$msg);
1065             return(undef);
1066         }
1067      }
1068     return(1);
1069
1070 }
1071
1072 # }}}
1073
1074 # {{{ sub OwnerGroup
1075
1076 =head2 OwnerGroup
1077
1078 A constructor which returns an RT::Group object containing the owner of this ticket.
1079
1080 =cut
1081
1082 sub OwnerGroup {
1083     my $self = shift;
1084     my $owner_obj = RT::Group->new($self->CurrentUser);
1085     $owner_obj->LoadTicketRoleGroup( Ticket => $self->Id,  Type => 'Owner');
1086     return ($owner_obj);
1087 }
1088
1089 # }}}
1090
1091
1092 # {{{ sub AddWatcher
1093
1094 =head2 AddWatcher
1095
1096 AddWatcher takes a parameter hash. The keys are as follows:
1097
1098 Type        One of Requestor, Cc, AdminCc
1099
1100 PrincipalId The RT::Principal id of the user or group that's being added as a watcher
1101
1102 Email       The email address of the new watcher. If a user with this
1103             email address can't be found, a new nonprivileged user will be created.
1104
1105 If the watcher you\'re trying to set has an RT account, set the PrincipalId paremeter to their User Id. Otherwise, set the Email parameter to their Email address.
1106
1107 =cut
1108
1109 sub AddWatcher {
1110     my $self = shift;
1111     my %args = (
1112         Type  => undef,
1113         PrincipalId => undef,
1114         Email => undef,
1115         @_
1116     );
1117
1118     # ModifyTicket works in any case
1119     return $self->_AddWatcher( %args )
1120         if $self->CurrentUserHasRight('ModifyTicket');
1121     if ( $args{'Email'} ) {
1122         my ($addr) = RT::EmailParser->ParseEmailAddress( $args{'Email'} );
1123         return (0, $self->loc("Couldn't parse address from '[_1]' string", $args{'Email'} ))
1124             unless $addr;
1125
1126         if ( lc $self->CurrentUser->UserObj->EmailAddress
1127             eq lc RT::User->CanonicalizeEmailAddress( $addr->address ) )
1128         {
1129             $args{'PrincipalId'} = $self->CurrentUser->id;
1130             delete $args{'Email'};
1131         }
1132     }
1133
1134     # If the watcher isn't the current user then the current user has no right
1135     # bail
1136     unless ( $args{'PrincipalId'} && $self->CurrentUser->id == $args{'PrincipalId'} ) {
1137         return ( 0, $self->loc("Permission Denied") );
1138     }
1139
1140     #  If it's an AdminCc and they don't have 'WatchAsAdminCc', bail
1141     if ( $args{'Type'} eq 'AdminCc' ) {
1142         unless ( $self->CurrentUserHasRight('WatchAsAdminCc') ) {
1143             return ( 0, $self->loc('Permission Denied') );
1144         }
1145     }
1146
1147     #  If it's a Requestor or Cc and they don't have 'Watch', bail
1148     elsif ( $args{'Type'} eq 'Cc' || $args{'Type'} eq 'Requestor' ) {
1149         unless ( $self->CurrentUserHasRight('Watch') ) {
1150             return ( 0, $self->loc('Permission Denied') );
1151         }
1152     }
1153     else {
1154         $RT::Logger->warning( "AddWatcher got passed a bogus type");
1155         return ( 0, $self->loc('Error in parameters to Ticket->AddWatcher') );
1156     }
1157
1158     return $self->_AddWatcher( %args );
1159 }
1160
1161 #This contains the meat of AddWatcher. but can be called from a routine like
1162 # Create, which doesn't need the additional acl check
1163 sub _AddWatcher {
1164     my $self = shift;
1165     my %args = (
1166         Type   => undef,
1167         Silent => undef,
1168         PrincipalId => undef,
1169         Email => undef,
1170         @_
1171     );
1172
1173
1174     my $principal = RT::Principal->new($self->CurrentUser);
1175     if ($args{'Email'}) {
1176         if ( RT::EmailParser->IsRTAddress( $args{'Email'} ) ) {
1177             return (0, $self->loc("[_1] is an address RT receives mail at. Adding it as a '[_2]' would create a mail loop", $args{'Email'}, $self->loc($args{'Type'})));
1178         }
1179         my $user = RT::User->new($RT::SystemUser);
1180         my ($pid, $msg) = $user->LoadOrCreateByEmail( $args{'Email'} );
1181         $args{'PrincipalId'} = $pid if $pid;
1182     }
1183     if ($args{'PrincipalId'}) {
1184         $principal->Load($args{'PrincipalId'});
1185         if ( $principal->id and $principal->IsUser and my $email = $principal->Object->EmailAddress ) {
1186             return (0, $self->loc("[_1] is an address RT receives mail at. Adding it as a '[_2]' would create a mail loop", $email, $self->loc($args{'Type'})))
1187                 if RT::EmailParser->IsRTAddress( $email );
1188
1189         }
1190     }
1191
1192
1193     # If we can't find this watcher, we need to bail.
1194     unless ($principal->Id) {
1195             $RT::Logger->error("Could not load create a user with the email address '".$args{'Email'}. "' to add as a watcher for ticket ".$self->Id);
1196         return(0, $self->loc("Could not find or create that user"));
1197     }
1198
1199
1200     my $group = RT::Group->new($self->CurrentUser);
1201     $group->LoadTicketRoleGroup(Type => $args{'Type'}, Ticket => $self->Id);
1202     unless ($group->id) {
1203         return(0,$self->loc("Group not found"));
1204     }
1205
1206     if ( $group->HasMember( $principal)) {
1207
1208         return ( 0, $self->loc('That principal is already a [_1] for this ticket', $self->loc($args{'Type'})) );
1209     }
1210
1211
1212     my ( $m_id, $m_msg ) = $group->_AddMember( PrincipalId => $principal->Id,
1213                                                InsideTransaction => 1 );
1214     unless ($m_id) {
1215         $RT::Logger->error("Failed to add ".$principal->Id." as a member of group ".$group->Id.": ".$m_msg);
1216
1217         return ( 0, $self->loc('Could not make that principal a [_1] for this ticket', $self->loc($args{'Type'})) );
1218     }
1219
1220     unless ( $args{'Silent'} ) {
1221         $self->_NewTransaction(
1222             Type     => 'AddWatcher',
1223             NewValue => $principal->Id,
1224             Field    => $args{'Type'}
1225         );
1226     }
1227
1228         return ( 1, $self->loc('Added principal as a [_1] for this ticket', $self->loc($args{'Type'})) );
1229 }
1230
1231 # }}}
1232
1233
1234 # {{{ sub DeleteWatcher
1235
1236 =head2 DeleteWatcher { Type => TYPE, PrincipalId => PRINCIPAL_ID, Email => EMAIL_ADDRESS }
1237
1238
1239 Deletes a Ticket watcher.  Takes two arguments:
1240
1241 Type  (one of Requestor,Cc,AdminCc)
1242
1243 and one of
1244
1245 PrincipalId (an RT::Principal Id of the watcher you want to remove)
1246     OR
1247 Email (the email address of an existing wathcer)
1248
1249
1250 =cut
1251
1252
1253 sub DeleteWatcher {
1254     my $self = shift;
1255
1256     my %args = ( Type        => undef,
1257                  PrincipalId => undef,
1258                  Email       => undef,
1259                  @_ );
1260
1261     unless ( $args{'PrincipalId'} || $args{'Email'} ) {
1262         return ( 0, $self->loc("No principal specified") );
1263     }
1264     my $principal = RT::Principal->new( $self->CurrentUser );
1265     if ( $args{'PrincipalId'} ) {
1266
1267         $principal->Load( $args{'PrincipalId'} );
1268     }
1269     else {
1270         my $user = RT::User->new( $self->CurrentUser );
1271         $user->LoadByEmail( $args{'Email'} );
1272         $principal->Load( $user->Id );
1273     }
1274
1275     # If we can't find this watcher, we need to bail.
1276     unless ( $principal->Id ) {
1277         return ( 0, $self->loc("Could not find that principal") );
1278     }
1279
1280     my $group = RT::Group->new( $self->CurrentUser );
1281     $group->LoadTicketRoleGroup( Type => $args{'Type'}, Ticket => $self->Id );
1282     unless ( $group->id ) {
1283         return ( 0, $self->loc("Group not found") );
1284     }
1285
1286     # {{{ Check ACLS
1287     #If the watcher we're trying to add is for the current user
1288     if ( $self->CurrentUser->PrincipalId == $principal->id ) {
1289
1290         #  If it's an AdminCc and they don't have
1291         #   'WatchAsAdminCc' or 'ModifyTicket', bail
1292         if ( $args{'Type'} eq 'AdminCc' ) {
1293             unless (    $self->CurrentUserHasRight('ModifyTicket')
1294                      or $self->CurrentUserHasRight('WatchAsAdminCc') ) {
1295                 return ( 0, $self->loc('Permission Denied') );
1296             }
1297         }
1298
1299         #  If it's a Requestor or Cc and they don't have
1300         #   'Watch' or 'ModifyTicket', bail
1301         elsif ( ( $args{'Type'} eq 'Cc' ) or ( $args{'Type'} eq 'Requestor' ) )
1302         {
1303             unless (    $self->CurrentUserHasRight('ModifyTicket')
1304                      or $self->CurrentUserHasRight('Watch') ) {
1305                 return ( 0, $self->loc('Permission Denied') );
1306             }
1307         }
1308         else {
1309             $RT::Logger->warn("$self -> DeleteWatcher got passed a bogus type");
1310             return ( 0,
1311                      $self->loc('Error in parameters to Ticket->DeleteWatcher') );
1312         }
1313     }
1314
1315     # If the watcher isn't the current user
1316     # and the current user  doesn't have 'ModifyTicket' bail
1317     else {
1318         unless ( $self->CurrentUserHasRight('ModifyTicket') ) {
1319             return ( 0, $self->loc("Permission Denied") );
1320         }
1321     }
1322
1323     # }}}
1324
1325     # see if this user is already a watcher.
1326
1327     unless ( $group->HasMember($principal) ) {
1328         return ( 0,
1329                  $self->loc( 'That principal is not a [_1] for this ticket',
1330                              $args{'Type'} ) );
1331     }
1332
1333     my ( $m_id, $m_msg ) = $group->_DeleteMember( $principal->Id );
1334     unless ($m_id) {
1335         $RT::Logger->error( "Failed to delete "
1336                             . $principal->Id
1337                             . " as a member of group "
1338                             . $group->Id . ": "
1339                             . $m_msg );
1340
1341         return (0,
1342                 $self->loc(
1343                     'Could not remove that principal as a [_1] for this ticket',
1344                     $args{'Type'} ) );
1345     }
1346
1347     unless ( $args{'Silent'} ) {
1348         $self->_NewTransaction( Type     => 'DelWatcher',
1349                                 OldValue => $principal->Id,
1350                                 Field    => $args{'Type'} );
1351     }
1352
1353     return ( 1,
1354              $self->loc( "[_1] is no longer a [_2] for this ticket.",
1355                          $principal->Object->Name,
1356                          $args{'Type'} ) );
1357 }
1358
1359
1360
1361 # }}}
1362
1363
1364 =head2 SquelchMailTo [EMAIL]
1365
1366 Takes an optional email address to never email about updates to this ticket.
1367
1368
1369 Returns an array of the RT::Attribute objects for this ticket's 'SquelchMailTo' attributes.
1370
1371
1372 =cut
1373
1374 sub SquelchMailTo {
1375     my $self = shift;
1376     if (@_) {
1377         unless ( $self->CurrentUserHasRight('ModifyTicket') ) {
1378             return undef;
1379         }
1380     } else {
1381         unless ( $self->CurrentUserHasRight('ShowTicket') ) {
1382             return undef;
1383         }
1384
1385     }
1386     return $self->_SquelchMailTo(@_);
1387 }
1388
1389 sub _SquelchMailTo {
1390     my $self = shift;
1391     if (@_) {
1392         my $attr = shift;
1393         $self->AddAttribute( Name => 'SquelchMailTo', Content => $attr )
1394             unless grep { $_->Content eq $attr }
1395                 $self->Attributes->Named('SquelchMailTo');
1396     }
1397     my @attributes = $self->Attributes->Named('SquelchMailTo');
1398     return (@attributes);
1399 }
1400
1401
1402 =head2 UnsquelchMailTo ADDRESS
1403
1404 Takes an address and removes it from this ticket's "SquelchMailTo" list. If an address appears multiple times, each instance is removed.
1405
1406 Returns a tuple of (status, message)
1407
1408 =cut
1409
1410 sub UnsquelchMailTo {
1411     my $self = shift;
1412
1413     my $address = shift;
1414     unless ( $self->CurrentUserHasRight('ModifyTicket') ) {
1415         return ( 0, $self->loc("Permission Denied") );
1416     }
1417
1418     my ($val, $msg) = $self->Attributes->DeleteEntry ( Name => 'SquelchMailTo', Content => $address);
1419     return ($val, $msg);
1420 }
1421
1422
1423 # {{{ a set of  [foo]AsString subs that will return the various sorts of watchers for a ticket/queue as a comma delineated string
1424
1425 =head2 RequestorAddresses
1426
1427  B<Returns> String: All Ticket Requestor email addresses as a string.
1428
1429 =cut
1430
1431 sub RequestorAddresses {
1432     my $self = shift;
1433
1434     unless ( $self->CurrentUserHasRight('ShowTicket') ) {
1435         return undef;
1436     }
1437
1438     return ( $self->Requestors->MemberEmailAddressesAsString );
1439 }
1440
1441
1442 =head2 AdminCcAddresses
1443
1444 returns String: All Ticket AdminCc email addresses as a string
1445
1446 =cut
1447
1448 sub AdminCcAddresses {
1449     my $self = shift;
1450
1451     unless ( $self->CurrentUserHasRight('ShowTicket') ) {
1452         return undef;
1453     }
1454
1455     return ( $self->AdminCc->MemberEmailAddressesAsString )
1456
1457 }
1458
1459 =head2 CcAddresses
1460
1461 returns String: All Ticket Ccs as a string of email addresses
1462
1463 =cut
1464
1465 sub CcAddresses {
1466     my $self = shift;
1467
1468     unless ( $self->CurrentUserHasRight('ShowTicket') ) {
1469         return undef;
1470     }
1471     return ( $self->Cc->MemberEmailAddressesAsString);
1472
1473 }
1474
1475 # }}}
1476
1477 # {{{ Routines that return RT::Watchers objects of Requestors, Ccs and AdminCcs
1478
1479 # {{{ sub Requestors
1480
1481 =head2 Requestors
1482
1483 Takes nothing.
1484 Returns this ticket's Requestors as an RT::Group object
1485
1486 =cut
1487
1488 sub Requestors {
1489     my $self = shift;
1490
1491     my $group = RT::Group->new($self->CurrentUser);
1492     if ( $self->CurrentUserHasRight('ShowTicket') ) {
1493         $group->LoadTicketRoleGroup(Type => 'Requestor', Ticket => $self->Id);
1494     }
1495     return ($group);
1496
1497 }
1498
1499 # }}}
1500
1501 # {{{ sub _Requestors
1502
1503 =head2 _Requestors
1504
1505 Private non-ACLed variant of Reqeustors so that we can look them up for the
1506 purposes of customer auto-association during create.
1507
1508 =cut
1509
1510 sub _Requestors {
1511     my $self = shift;
1512
1513     my $group = RT::Group->new($RT::SystemUser);
1514     $group->LoadTicketRoleGroup(Type => 'Requestor', Ticket => $self->Id);
1515     return ($group);
1516 }
1517
1518 # }}}
1519
1520 # {{{ sub Cc
1521
1522 =head2 Cc
1523
1524 Takes nothing.
1525 Returns an RT::Group object which contains this ticket's Ccs.
1526 If the user doesn't have "ShowTicket" permission, returns an empty group
1527
1528 =cut
1529
1530 sub Cc {
1531     my $self = shift;
1532
1533     my $group = RT::Group->new($self->CurrentUser);
1534     if ( $self->CurrentUserHasRight('ShowTicket') ) {
1535         $group->LoadTicketRoleGroup(Type => 'Cc', Ticket => $self->Id);
1536     }
1537     return ($group);
1538
1539 }
1540
1541 # }}}
1542
1543 # {{{ sub AdminCc
1544
1545 =head2 AdminCc
1546
1547 Takes nothing.
1548 Returns an RT::Group object which contains this ticket's AdminCcs.
1549 If the user doesn't have "ShowTicket" permission, returns an empty group
1550
1551 =cut
1552
1553 sub AdminCc {
1554     my $self = shift;
1555
1556     my $group = RT::Group->new($self->CurrentUser);
1557     if ( $self->CurrentUserHasRight('ShowTicket') ) {
1558         $group->LoadTicketRoleGroup(Type => 'AdminCc', Ticket => $self->Id);
1559     }
1560     return ($group);
1561
1562 }
1563
1564 # }}}
1565
1566 # }}}
1567
1568 # {{{ IsWatcher,IsRequestor,IsCc, IsAdminCc
1569
1570 # {{{ sub IsWatcher
1571 # a generic routine to be called by IsRequestor, IsCc and IsAdminCc
1572
1573 =head2 IsWatcher { Type => TYPE, PrincipalId => PRINCIPAL_ID, Email => EMAIL }
1574
1575 Takes a param hash with the attributes Type and either PrincipalId or Email
1576
1577 Type is one of Requestor, Cc, AdminCc and Owner
1578
1579 PrincipalId is an RT::Principal id, and Email is an email address.
1580
1581 Returns true if the specified principal (or the one corresponding to the
1582 specified address) is a member of the group Type for this ticket.
1583
1584 XX TODO: This should be Memoized.
1585
1586 =cut
1587
1588 sub IsWatcher {
1589     my $self = shift;
1590
1591     my %args = ( Type  => 'Requestor',
1592         PrincipalId    => undef,
1593         Email          => undef,
1594         @_
1595     );
1596
1597     # Load the relevant group.
1598     my $group = RT::Group->new($self->CurrentUser);
1599     $group->LoadTicketRoleGroup(Type => $args{'Type'}, Ticket => $self->id);
1600
1601     # Find the relevant principal.
1602     if (!$args{PrincipalId} && $args{Email}) {
1603         # Look up the specified user.
1604         my $user = RT::User->new($self->CurrentUser);
1605         $user->LoadByEmail($args{Email});
1606         if ($user->Id) {
1607             $args{PrincipalId} = $user->PrincipalId;
1608         }
1609         else {
1610             # A non-existent user can't be a group member.
1611             return 0;
1612         }
1613     }
1614
1615     # Ask if it has the member in question
1616     return $group->HasMember( $args{'PrincipalId'} );
1617 }
1618
1619 # }}}
1620
1621 # {{{ sub IsRequestor
1622
1623 =head2 IsRequestor PRINCIPAL_ID
1624
1625 Takes an L<RT::Principal> id.
1626
1627 Returns true if the principal is a requestor of the current ticket.
1628
1629 =cut
1630
1631 sub IsRequestor {
1632     my $self   = shift;
1633     my $person = shift;
1634
1635     return ( $self->IsWatcher( Type => 'Requestor', PrincipalId => $person ) );
1636
1637 };
1638
1639 # }}}
1640
1641 # {{{ sub IsCc
1642
1643 =head2 IsCc PRINCIPAL_ID
1644
1645   Takes an RT::Principal id.
1646   Returns true if the principal is a Cc of the current ticket.
1647
1648
1649 =cut
1650
1651 sub IsCc {
1652     my $self = shift;
1653     my $cc   = shift;
1654
1655     return ( $self->IsWatcher( Type => 'Cc', PrincipalId => $cc ) );
1656
1657 }
1658
1659 # }}}
1660
1661 # {{{ sub IsAdminCc
1662
1663 =head2 IsAdminCc PRINCIPAL_ID
1664
1665   Takes an RT::Principal id.
1666   Returns true if the principal is an AdminCc of the current ticket.
1667
1668 =cut
1669
1670 sub IsAdminCc {
1671     my $self   = shift;
1672     my $person = shift;
1673
1674     return ( $self->IsWatcher( Type => 'AdminCc', PrincipalId => $person ) );
1675
1676 }
1677
1678 # }}}
1679
1680 # {{{ sub IsOwner
1681
1682 =head2 IsOwner
1683
1684   Takes an RT::User object. Returns true if that user is this ticket's owner.
1685 returns undef otherwise
1686
1687 =cut
1688
1689 sub IsOwner {
1690     my $self   = shift;
1691     my $person = shift;
1692
1693     # no ACL check since this is used in acl decisions
1694     # unless ($self->CurrentUserHasRight('ShowTicket')) {
1695     #    return(undef);
1696     #   }
1697
1698     #Tickets won't yet have owners when they're being created.
1699     unless ( $self->OwnerObj->id ) {
1700         return (undef);
1701     }
1702
1703     if ( $person->id == $self->OwnerObj->id ) {
1704         return (1);
1705     }
1706     else {
1707         return (undef);
1708     }
1709 }
1710
1711 # }}}
1712
1713 # }}}
1714
1715 # }}}
1716
1717
1718 =head2 TransactionAddresses
1719
1720 Returns a composite hashref of the results of L<RT::Transaction/Addresses> for
1721 all this ticket's Create, Comment or Correspond transactions. The keys are
1722 stringified email addresses. Each value is an L<Email::Address> object.
1723
1724 NOTE: For performance reasons, this method might want to skip transactions and go straight for attachments. But to make that work right, we're going to need to go and walk around the access control in Attachment.pm's sub _Value.
1725
1726 =cut
1727
1728
1729 sub TransactionAddresses {
1730     my $self = shift;
1731     my $txns = $self->Transactions;
1732
1733     my %addresses = ();
1734     foreach my $type (qw(Create Comment Correspond)) {
1735     $txns->Limit(FIELD => 'Type', OPERATOR => '=', VALUE => $type , ENTRYAGGREGATOR => 'OR', CASESENSITIVE => 1);
1736         }
1737
1738     while (my $txn = $txns->Next) {
1739         my $txnaddrs = $txn->Addresses;
1740         foreach my $addrlist ( values %$txnaddrs ) {
1741                 foreach my $addr (@$addrlist) {
1742                     # Skip addresses without a phrase (things that are just raw addresses) if we have a phrase
1743                     next if ($addresses{$addr->address} && $addresses{$addr->address}->phrase && not $addr->phrase);
1744                     # skips "comment-only" addresses
1745                     next unless ($addr->address);
1746                     $addresses{$addr->address} = $addr;
1747                 }
1748         }
1749     }
1750
1751     return \%addresses;
1752
1753 }
1754
1755
1756
1757
1758 # {{{ Routines dealing with queues
1759
1760 # {{{ sub ValidateQueue
1761
1762 sub ValidateQueue {
1763     my $self  = shift;
1764     my $Value = shift;
1765
1766     if ( !$Value ) {
1767         $RT::Logger->warning( " RT:::Queue::ValidateQueue called with a null value. this isn't ok.");
1768         return (1);
1769     }
1770
1771     my $QueueObj = RT::Queue->new( $self->CurrentUser );
1772     my $id       = $QueueObj->Load($Value);
1773
1774     if ($id) {
1775         return (1);
1776     }
1777     else {
1778         return (undef);
1779     }
1780 }
1781
1782 # }}}
1783
1784 # {{{ sub SetQueue
1785
1786 sub SetQueue {
1787     my $self     = shift;
1788     my $NewQueue = shift;
1789
1790     #Redundant. ACL gets checked in _Set;
1791     unless ( $self->CurrentUserHasRight('ModifyTicket') ) {
1792         return ( 0, $self->loc("Permission Denied") );
1793     }
1794
1795     my $NewQueueObj = RT::Queue->new( $self->CurrentUser );
1796     $NewQueueObj->Load($NewQueue);
1797
1798     unless ( $NewQueueObj->Id() ) {
1799         return ( 0, $self->loc("That queue does not exist") );
1800     }
1801
1802     if ( $NewQueueObj->Id == $self->QueueObj->Id ) {
1803         return ( 0, $self->loc('That is the same value') );
1804     }
1805     unless (
1806         $self->CurrentUser->HasRight(
1807             Right    => 'CreateTicket',
1808             Object => $NewQueueObj
1809         )
1810       )
1811     {
1812         return ( 0, $self->loc("You may not create requests in that queue.") );
1813     }
1814
1815     unless (
1816         $self->OwnerObj->HasRight(
1817             Right    => 'OwnTicket',
1818             Object => $NewQueueObj
1819         )
1820       )
1821     {
1822         my $clone = RT::Ticket->new( $RT::SystemUser );
1823         $clone->Load( $self->Id );
1824         unless ( $clone->Id ) {
1825             return ( 0, $self->loc("Couldn't load copy of ticket #[_1].", $self->Id) );
1826         }
1827         my ($status, $msg) = $clone->SetOwner( $RT::Nobody->Id, 'Force' );
1828         $RT::Logger->error("Couldn't set owner on queue change: $msg") unless $status;
1829     }
1830
1831     my ($status, $msg) = $self->_Set( Field => 'Queue', Value => $NewQueueObj->Id() );
1832
1833     if ( $status ) {
1834         # On queue change, change queue for reminders too
1835         my $reminder_collection = $self->Reminders->Collection;
1836         while ( my $reminder = $reminder_collection->Next ) {
1837             my ($status, $msg) = $reminder->SetQueue($NewQueue);
1838             $RT::Logger->error('Queue change failed for reminder #' . $reminder->Id . ': ' . $msg) unless $status;
1839         }
1840     }
1841
1842     return ($status, $msg);
1843 }
1844
1845 # }}}
1846
1847 # {{{ sub QueueObj
1848
1849 =head2 QueueObj
1850
1851 Takes nothing. returns this ticket's queue object
1852
1853 =cut
1854
1855 sub QueueObj {
1856     my $self = shift;
1857
1858     my $queue_obj = RT::Queue->new( $self->CurrentUser );
1859
1860     #We call __Value so that we can avoid the ACL decision and some deep recursion
1861     my ($result) = $queue_obj->Load( $self->__Value('Queue') );
1862     return ($queue_obj);
1863 }
1864
1865 # }}}
1866
1867 # }}}
1868
1869 # {{{ Date printing routines
1870
1871 # {{{ sub DueObj
1872
1873 =head2 DueObj
1874
1875   Returns an RT::Date object containing this ticket's due date
1876
1877 =cut
1878
1879 sub DueObj {
1880     my $self = shift;
1881
1882     my $time = new RT::Date( $self->CurrentUser );
1883
1884     # -1 is RT::Date slang for never
1885     if ( my $due = $self->Due ) {
1886         $time->Set( Format => 'sql', Value => $due );
1887     }
1888     else {
1889         $time->Set( Format => 'unix', Value => -1 );
1890     }
1891
1892     return $time;
1893 }
1894
1895 # }}}
1896
1897 # {{{ sub DueAsString
1898
1899 =head2 DueAsString
1900
1901 Returns this ticket's due date as a human readable string
1902
1903 =cut
1904
1905 sub DueAsString {
1906     my $self = shift;
1907     return $self->DueObj->AsString();
1908 }
1909
1910 # }}}
1911
1912 # {{{ sub ResolvedObj
1913
1914 =head2 ResolvedObj
1915
1916   Returns an RT::Date object of this ticket's 'resolved' time.
1917
1918 =cut
1919
1920 sub ResolvedObj {
1921     my $self = shift;
1922
1923     my $time = new RT::Date( $self->CurrentUser );
1924     $time->Set( Format => 'sql', Value => $self->Resolved );
1925     return $time;
1926 }
1927
1928 # }}}
1929
1930 # {{{ sub SetStarted
1931
1932 =head2 SetStarted
1933
1934 Takes a date in ISO format or undef
1935 Returns a transaction id and a message
1936 The client calls "Start" to note that the project was started on the date in $date.
1937 A null date means "now"
1938
1939 =cut
1940
1941 sub SetStarted {
1942     my $self = shift;
1943     my $time = shift || 0;
1944
1945     unless ( $self->CurrentUserHasRight('ModifyTicket') ) {
1946         return ( 0, $self->loc("Permission Denied") );
1947     }
1948
1949     #We create a date object to catch date weirdness
1950     my $time_obj = new RT::Date( $self->CurrentUser() );
1951     if ( $time ) {
1952         $time_obj->Set( Format => 'ISO', Value => $time );
1953     }
1954     else {
1955         $time_obj->SetToNow();
1956     }
1957
1958     #Now that we're starting, open this ticket
1959     #TODO do we really want to force this as policy? it should be a scrip
1960
1961     #We need $TicketAsSystem, in case the current user doesn't have
1962     #ShowTicket
1963     #
1964     my $TicketAsSystem = new RT::Ticket($RT::SystemUser);
1965     $TicketAsSystem->Load( $self->Id );
1966     if ( $TicketAsSystem->Status eq 'new' ) {
1967         $TicketAsSystem->Open();
1968     }
1969
1970     return ( $self->_Set( Field => 'Started', Value => $time_obj->ISO ) );
1971
1972 }
1973
1974 # }}}
1975
1976 # {{{ sub StartedObj
1977
1978 =head2 StartedObj
1979
1980   Returns an RT::Date object which contains this ticket's
1981 'Started' time.
1982
1983 =cut
1984
1985 sub StartedObj {
1986     my $self = shift;
1987
1988     my $time = new RT::Date( $self->CurrentUser );
1989     $time->Set( Format => 'sql', Value => $self->Started );
1990     return $time;
1991 }
1992
1993 # }}}
1994
1995 # {{{ sub StartsObj
1996
1997 =head2 StartsObj
1998
1999   Returns an RT::Date object which contains this ticket's
2000 'Starts' time.
2001
2002 =cut
2003
2004 sub StartsObj {
2005     my $self = shift;
2006
2007     my $time = new RT::Date( $self->CurrentUser );
2008     $time->Set( Format => 'sql', Value => $self->Starts );
2009     return $time;
2010 }
2011
2012 # }}}
2013
2014 # {{{ sub ToldObj
2015
2016 =head2 ToldObj
2017
2018   Returns an RT::Date object which contains this ticket's
2019 'Told' time.
2020
2021 =cut
2022
2023 sub ToldObj {
2024     my $self = shift;
2025
2026     my $time = new RT::Date( $self->CurrentUser );
2027     $time->Set( Format => 'sql', Value => $self->Told );
2028     return $time;
2029 }
2030
2031 # }}}
2032
2033 # {{{ sub ToldAsString
2034
2035 =head2 ToldAsString
2036
2037 A convenience method that returns ToldObj->AsString
2038
2039 TODO: This should be deprecated
2040
2041 =cut
2042
2043 sub ToldAsString {
2044     my $self = shift;
2045     if ( $self->Told ) {
2046         return $self->ToldObj->AsString();
2047     }
2048     else {
2049         return ("Never");
2050     }
2051 }
2052
2053 # }}}
2054
2055 # {{{ sub TimeWorkedAsString
2056
2057 =head2 TimeWorkedAsString
2058
2059 Returns the amount of time worked on this ticket as a Text String
2060
2061 =cut
2062
2063 sub TimeWorkedAsString {
2064     my $self = shift;
2065     my $value = $self->TimeWorked;
2066
2067     # return the # of minutes worked turned into seconds and written as
2068     # a simple text string, this is not really a date object, but if we
2069     # diff a number of seconds vs the epoch, we'll get a nice description
2070     # of time worked.
2071     return "" unless $value;
2072     return RT::Date->new( $self->CurrentUser )
2073         ->DurationAsString( $value * 60 );
2074 }
2075
2076 # }}}
2077
2078 # {{{ sub TimeLeftAsString
2079
2080 =head2  TimeLeftAsString
2081
2082 Returns the amount of time left on this ticket as a Text String
2083
2084 =cut
2085
2086 sub TimeLeftAsString {
2087     my $self = shift;
2088     my $value = $self->TimeLeft;
2089     return "" unless $value;
2090     return RT::Date->new( $self->CurrentUser )
2091         ->DurationAsString( $value * 60 );
2092 }
2093
2094 # }}}
2095
2096 # {{{ Routines dealing with correspondence/comments
2097
2098 # {{{ sub Comment
2099
2100 =head2 Comment
2101
2102 Comment on this ticket.
2103 Takes a hash with the following attributes:
2104 If MIMEObj is undefined, Content will be used to build a MIME::Entity for this
2105 comment.
2106
2107 MIMEObj, TimeTaken, CcMessageTo, BccMessageTo, Content, DryRun
2108
2109 If DryRun is defined, this update WILL NOT BE RECORDED. Scrips will not be committed.
2110 They will, however, be prepared and you'll be able to access them through the TransactionObj
2111
2112 Returns: Transaction id, Error Message, Transaction Object
2113 (note the different order from Create()!)
2114
2115 =cut
2116
2117 sub Comment {
2118     my $self = shift;
2119
2120     my %args = ( CcMessageTo  => undef,
2121                  BccMessageTo => undef,
2122                  MIMEObj      => undef,
2123                  Content      => undef,
2124                  TimeTaken => 0,
2125                  DryRun     => 0,
2126                  @_ );
2127
2128     unless (    ( $self->CurrentUserHasRight('CommentOnTicket') )
2129              or ( $self->CurrentUserHasRight('ModifyTicket') ) ) {
2130         return ( 0, $self->loc("Permission Denied"), undef );
2131     }
2132     $args{'NoteType'} = 'Comment';
2133
2134     if ($args{'DryRun'}) {
2135         $RT::Handle->BeginTransaction();
2136         $args{'CommitScrips'} = 0;
2137     }
2138
2139     my @results = $self->_RecordNote(%args);
2140     if ($args{'DryRun'}) {
2141         $RT::Handle->Rollback();
2142     }
2143
2144     return(@results);
2145 }
2146 # }}}
2147
2148 # {{{ sub Correspond
2149
2150 =head2 Correspond
2151
2152 Correspond on this ticket.
2153 Takes a hashref with the following attributes:
2154
2155
2156 MIMEObj, TimeTaken, CcMessageTo, BccMessageTo, Content, DryRun
2157
2158 if there's no MIMEObj, Content is used to build a MIME::Entity object
2159
2160 If DryRun is defined, this update WILL NOT BE RECORDED. Scrips will not be committed.
2161 They will, however, be prepared and you'll be able to access them through the TransactionObj
2162
2163 Returns: Transaction id, Error Message, Transaction Object
2164 (note the different order from Create()!)
2165
2166
2167 =cut
2168
2169 sub Correspond {
2170     my $self = shift;
2171     my %args = ( CcMessageTo  => undef,
2172                  BccMessageTo => undef,
2173                  MIMEObj      => undef,
2174                  Content      => undef,
2175                  TimeTaken    => 0,
2176                  @_ );
2177
2178     unless (    ( $self->CurrentUserHasRight('ReplyToTicket') )
2179              or ( $self->CurrentUserHasRight('ModifyTicket') ) ) {
2180         return ( 0, $self->loc("Permission Denied"), undef );
2181     }
2182
2183     $args{'NoteType'} = 'Correspond';
2184     if ($args{'DryRun'}) {
2185         $RT::Handle->BeginTransaction();
2186         $args{'CommitScrips'} = 0;
2187     }
2188
2189     my @results = $self->_RecordNote(%args);
2190
2191     #Set the last told date to now if this isn't mail from the requestor.
2192     #TODO: Note that this will wrongly ack mail from any non-requestor as a "told"
2193     $self->_SetTold unless ( $self->IsRequestor($self->CurrentUser->id));
2194
2195     if ($args{'DryRun'}) {
2196         $RT::Handle->Rollback();
2197     }
2198
2199     return (@results);
2200
2201 }
2202
2203 # }}}
2204
2205 # {{{ sub _RecordNote
2206
2207 =head2 _RecordNote
2208
2209 the meat of both comment and correspond.
2210
2211 Performs no access control checks. hence, dangerous.
2212
2213 =cut
2214
2215 sub _RecordNote {
2216     my $self = shift;
2217     my %args = (
2218         CcMessageTo  => undef,
2219         BccMessageTo => undef,
2220         Encrypt      => undef,
2221         Sign         => undef,
2222         MIMEObj      => undef,
2223         Content      => undef,
2224         NoteType     => 'Correspond',
2225         TimeTaken    => 0,
2226         CommitScrips => 1,
2227         CustomFields => {},
2228         @_
2229     );
2230
2231     unless ( $args{'MIMEObj'} || $args{'Content'} ) {
2232         return ( 0, $self->loc("No message attached"), undef );
2233     }
2234
2235     unless ( $args{'MIMEObj'} ) {
2236         $args{'MIMEObj'} = MIME::Entity->build(
2237             Data => ( ref $args{'Content'}? $args{'Content'}: [ $args{'Content'} ] )
2238         );
2239     }
2240
2241     # convert text parts into utf-8
2242     RT::I18N::SetMIMEEntityToUTF8( $args{'MIMEObj'} );
2243
2244     # If we've been passed in CcMessageTo and BccMessageTo fields,
2245     # add them to the mime object for passing on to the transaction handler
2246     # The "NotifyOtherRecipients" scripAction will look for RT-Send-Cc: and
2247     # RT-Send-Bcc: headers
2248
2249
2250     foreach my $type (qw/Cc Bcc/) {
2251         if ( defined $args{ $type . 'MessageTo' } ) {
2252
2253             my $addresses = join ', ', (
2254                 map { RT::User->CanonicalizeEmailAddress( $_->address ) }
2255                     Email::Address->parse( $args{ $type . 'MessageTo' } ) );
2256             $args{'MIMEObj'}->head->add( 'RT-Send-' . $type, Encode::encode_utf8( $addresses ) );
2257         }
2258     }
2259
2260     foreach my $argument (qw(Encrypt Sign)) {
2261         $args{'MIMEObj'}->head->add(
2262             "X-RT-$argument" => Encode::encode_utf8( $args{ $argument } )
2263         ) if defined $args{ $argument };
2264     }
2265
2266     # If this is from an external source, we need to come up with its
2267     # internal Message-ID now, so all emails sent because of this
2268     # message have a common Message-ID
2269     my $org = RT->Config->Get('Organization');
2270     my $msgid = $args{'MIMEObj'}->head->get('Message-ID');
2271     unless (defined $msgid && $msgid =~ /<(rt-.*?-\d+-\d+)\.(\d+-0-0)\@\Q$org\E>/) {
2272         $args{'MIMEObj'}->head->set(
2273             'RT-Message-ID' => RT::Interface::Email::GenMessageId( Ticket => $self )
2274         );
2275     }
2276
2277     #Record the correspondence (write the transaction)
2278     my ( $Trans, $msg, $TransObj ) = $self->_NewTransaction(
2279              Type => $args{'NoteType'},
2280              Data => ( $args{'MIMEObj'}->head->get('subject') || 'No Subject' ),
2281              TimeTaken => $args{'TimeTaken'},
2282              MIMEObj   => $args{'MIMEObj'},
2283              CommitScrips => $args{'CommitScrips'},
2284              CustomFields => $args{'CustomFields'},
2285     );
2286
2287     unless ($Trans) {
2288         $RT::Logger->err("$self couldn't init a transaction $msg");
2289         return ( $Trans, $self->loc("Message could not be recorded"), undef );
2290     }
2291
2292     return ( $Trans, $self->loc("Message recorded"), $TransObj );
2293 }
2294
2295 # }}}
2296
2297 # }}}
2298
2299 # {{{ sub _Links
2300
2301 sub _Links {
2302     my $self = shift;
2303
2304     #TODO: Field isn't the right thing here. but I ahave no idea what mnemonic ---
2305     #tobias meant by $f
2306     my $field = shift;
2307     my $type  = shift || "";
2308
2309     my $cache_key = "$field$type";
2310     return $self->{ $cache_key } if $self->{ $cache_key };
2311
2312     my $links = $self->{ $cache_key }
2313               = RT::Links->new( $self->CurrentUser );
2314     unless ( $self->CurrentUserHasRight('ShowTicket') ) {
2315         $links->Limit( FIELD => 'id', VALUE => 0 );
2316         return $links;
2317     }
2318
2319     # without this you will also get RT::User(s) instead of tickets!
2320     if ($field == 'Base' and $type == 'MemberOf') {
2321         my $rtname = RT->Config->Get('rtname');
2322         $links->Limit(
2323                        FIELD    => 'Base',
2324                        OPERATOR => 'STARTSWITH',
2325                        VALUE    => "fsck.com-rt://$rtname/ticket/",
2326                      );
2327     }
2328
2329     # Maybe this ticket is a merge ticket
2330     my $limit_on = 'Local'. $field;
2331     # at least to myself
2332     $links->Limit(
2333         FIELD           => $limit_on,
2334         VALUE           => $self->id,
2335         ENTRYAGGREGATOR => 'OR',
2336     );
2337     $links->Limit(
2338         FIELD           => $limit_on,
2339         VALUE           => $_,
2340         ENTRYAGGREGATOR => 'OR',
2341     ) foreach $self->Merged;
2342     $links->Limit(
2343         FIELD => 'Type',
2344         VALUE => $type,
2345     ) if $type;
2346
2347     return $links;
2348 }
2349
2350 # }}}
2351
2352 # {{{ sub DeleteLink
2353
2354 =head2 DeleteLink
2355
2356 Delete a link. takes a paramhash of Base, Target, Type, Silent,
2357 SilentBase and SilentTarget. Either Base or Target must be null.
2358 The null value will be replaced with this ticket\'s id.
2359
2360 If Silent is true then no transaction would be recorded, in other
2361 case you can control creation of transactions on both base and
2362 target with SilentBase and SilentTarget respectively. By default
2363 both transactions are created.
2364
2365 =cut
2366
2367 sub DeleteLink {
2368     my $self = shift;
2369     my %args = (
2370         Base   => undef,
2371         Target => undef,
2372         Type   => undef,
2373         Silent => undef,
2374         SilentBase   => undef,
2375         SilentTarget => undef,
2376         @_
2377     );
2378
2379     unless ( $args{'Target'} || $args{'Base'} ) {
2380         $RT::Logger->error("Base or Target must be specified");
2381         return ( 0, $self->loc('Either base or target must be specified') );
2382     }
2383
2384     #check acls
2385     my $right = 0;
2386     $right++ if $self->CurrentUserHasRight('ModifyTicket');
2387     if ( !$right && RT->Config->Get( 'StrictLinkACL' ) ) {
2388         return ( 0, $self->loc("Permission Denied") );
2389     }
2390
2391     # If the other URI is an RT::Ticket, we want to make sure the user
2392     # can modify it too...
2393     my ($status, $msg, $other_ticket) = $self->__GetTicketFromURI( URI => $args{'Target'} || $args{'Base'} );
2394     return (0, $msg) unless $status;
2395     if ( !$other_ticket || $other_ticket->CurrentUserHasRight('ModifyTicket') ) {
2396         $right++;
2397     }
2398     if ( ( !RT->Config->Get( 'StrictLinkACL' ) && $right == 0 ) ||
2399          ( RT->Config->Get( 'StrictLinkACL' ) && $right < 2 ) )
2400     {
2401         return ( 0, $self->loc("Permission Denied") );
2402     }
2403
2404     my ($val, $Msg) = $self->SUPER::_DeleteLink(%args);
2405     return ( 0, $Msg ) unless $val;
2406
2407     return ( $val, $Msg ) if $args{'Silent'};
2408
2409     my ($direction, $remote_link);
2410
2411     if ( $args{'Base'} ) {
2412         $remote_link = $args{'Base'};
2413         $direction = 'Target';
2414     }
2415     elsif ( $args{'Target'} ) {
2416         $remote_link = $args{'Target'};
2417         $direction = 'Base';
2418     }
2419
2420     my $remote_uri = RT::URI->new( $self->CurrentUser );
2421     $remote_uri->FromURI( $remote_link );
2422
2423     unless ( $args{ 'Silent'. $direction } ) {
2424         my ( $Trans, $Msg, $TransObj ) = $self->_NewTransaction(
2425             Type      => 'DeleteLink',
2426             Field     => $LINKDIRMAP{$args{'Type'}}->{$direction},
2427             OldValue  => $remote_uri->URI || $remote_link,
2428             TimeTaken => 0
2429         );
2430         $RT::Logger->error("Couldn't create transaction: $Msg") unless $Trans;
2431     }
2432
2433     if ( !$args{ 'Silent'. ( $direction eq 'Target'? 'Base': 'Target' ) } && $remote_uri->IsLocal ) {
2434         my $OtherObj = $remote_uri->Object;
2435         my ( $val, $Msg ) = $OtherObj->_NewTransaction(
2436             Type           => 'DeleteLink',
2437             Field          => $direction eq 'Target' ? $LINKDIRMAP{$args{'Type'}}->{Base}
2438                                             : $LINKDIRMAP{$args{'Type'}}->{Target},
2439             OldValue       => $self->URI,
2440             ActivateScrips => !RT->Config->Get('LinkTransactionsRun1Scrip'),
2441             TimeTaken      => 0,
2442         );
2443         $RT::Logger->error("Couldn't create transaction: $Msg") unless $val;
2444     }
2445
2446     return ( $val, $Msg );
2447 }
2448
2449 # }}}
2450
2451 # {{{ sub AddLink
2452
2453 =head2 AddLink
2454
2455 Takes a paramhash of Type and one of Base or Target. Adds that link to this ticket.
2456
2457 If Silent is true then no transaction would be recorded, in other
2458 case you can control creation of transactions on both base and
2459 target with SilentBase and SilentTarget respectively. By default
2460 both transactions are created.
2461
2462 =cut
2463
2464 sub AddLink {
2465     my $self = shift;
2466     my %args = ( Target       => '',
2467                  Base         => '',
2468                  Type         => '',
2469                  Silent       => undef,
2470                  SilentBase   => undef,
2471                  SilentTarget => undef,
2472                  @_ );
2473
2474     unless ( $args{'Target'} || $args{'Base'} ) {
2475         $RT::Logger->error("Base or Target must be specified");
2476         return ( 0, $self->loc('Either base or target must be specified') );
2477     }
2478
2479     my $right = 0;
2480     $right++ if $self->CurrentUserHasRight('ModifyTicket');
2481     if ( !$right && RT->Config->Get( 'StrictLinkACL' ) ) {
2482         return ( 0, $self->loc("Permission Denied") );
2483     }
2484
2485     # If the other URI is an RT::Ticket, we want to make sure the user
2486     # can modify it too...
2487     my ($status, $msg, $other_ticket) = $self->__GetTicketFromURI( URI => $args{'Target'} || $args{'Base'} );
2488     return (0, $msg) unless $status;
2489     if ( !$other_ticket || $other_ticket->CurrentUserHasRight('ModifyTicket') ) {
2490         $right++;
2491     }
2492     if ( ( !RT->Config->Get( 'StrictLinkACL' ) && $right == 0 ) ||
2493          ( RT->Config->Get( 'StrictLinkACL' ) && $right < 2 ) )
2494     {
2495         return ( 0, $self->loc("Permission Denied") );
2496     }
2497
2498     return $self->_AddLink(%args);
2499 }
2500
2501 sub __GetTicketFromURI {
2502     my $self = shift;
2503     my %args = ( URI => '', @_ );
2504
2505     # If the other URI is an RT::Ticket, we want to make sure the user
2506     # can modify it too...
2507     my $uri_obj = RT::URI->new( $self->CurrentUser );
2508     $uri_obj->FromURI( $args{'URI'} );
2509
2510     unless ( $uri_obj->Resolver && $uri_obj->Scheme ) {
2511         my $msg = $self->loc( "Couldn't resolve '[_1]' into a URI.", $args{'URI'} );
2512         $RT::Logger->warning( $msg );
2513         return( 0, $msg );
2514     }
2515     my $obj = $uri_obj->Resolver->Object;
2516     unless ( UNIVERSAL::isa($obj, 'RT::Ticket') && $obj->id ) {
2517         return (1, 'Found not a ticket', undef);
2518     }
2519     return (1, 'Found ticket', $obj);
2520 }
2521
2522 =head2 _AddLink
2523
2524 Private non-acled variant of AddLink so that links can be added during create.
2525
2526 =cut
2527
2528 sub _AddLink {
2529     my $self = shift;
2530     my %args = ( Target       => '',
2531                  Base         => '',
2532                  Type         => '',
2533                  Silent       => undef,
2534                  SilentBase   => undef,
2535                  SilentTarget => undef,
2536                  @_ );
2537
2538     my ($val, $msg, $exist) = $self->SUPER::_AddLink(%args);
2539     return ($val, $msg) if !$val || $exist;
2540     return ($val, $msg) if $args{'Silent'};
2541
2542     my ($direction, $remote_link);
2543     if ( $args{'Target'} ) {
2544         $remote_link  = $args{'Target'};
2545         $direction    = 'Base';
2546     } elsif ( $args{'Base'} ) {
2547         $remote_link  = $args{'Base'};
2548         $direction    = 'Target';
2549     }
2550
2551     my $remote_uri = RT::URI->new( $self->CurrentUser );
2552     $remote_uri->FromURI( $remote_link );
2553
2554     unless ( $args{ 'Silent'. $direction } ) {
2555         my ( $Trans, $Msg, $TransObj ) = $self->_NewTransaction(
2556             Type      => 'AddLink',
2557             Field     => $LINKDIRMAP{$args{'Type'}}->{$direction},
2558             NewValue  =>  $remote_uri->URI || $remote_link,
2559             TimeTaken => 0
2560         );
2561         $RT::Logger->error("Couldn't create transaction: $Msg") unless $Trans;
2562     }
2563
2564     if ( !$args{ 'Silent'. ( $direction eq 'Target'? 'Base': 'Target' ) } && $remote_uri->IsLocal ) {
2565         my $OtherObj = $remote_uri->Object;
2566         my ( $val, $msg ) = $OtherObj->_NewTransaction(
2567             Type           => 'AddLink',
2568             Field          => $direction eq 'Target' ? $LINKDIRMAP{$args{'Type'}}->{Base}
2569                                             : $LINKDIRMAP{$args{'Type'}}->{Target},
2570             NewValue       => $self->URI,
2571             ActivateScrips => !RT->Config->Get('LinkTransactionsRun1Scrip'),
2572             TimeTaken      => 0,
2573         );
2574         $RT::Logger->error("Couldn't create transaction: $msg") unless $val;
2575     }
2576
2577     return ( $val, $msg );
2578 }
2579
2580 # }}}
2581
2582
2583 # {{{ sub MergeInto
2584
2585 =head2 MergeInto
2586
2587 MergeInto take the id of the ticket to merge this ticket into.
2588
2589 =cut
2590
2591 sub MergeInto {
2592     my $self      = shift;
2593     my $ticket_id = shift;
2594
2595     unless ( $self->CurrentUserHasRight('ModifyTicket') ) {
2596         return ( 0, $self->loc("Permission Denied") );
2597     }
2598
2599     # Load up the new ticket.
2600     my $MergeInto = RT::Ticket->new($self->CurrentUser);
2601     $MergeInto->Load($ticket_id);
2602
2603     # make sure it exists.
2604     unless ( $MergeInto->Id ) {
2605         return ( 0, $self->loc("New ticket doesn't exist") );
2606     }
2607
2608     # Make sure the current user can modify the new ticket.
2609     unless ( $MergeInto->CurrentUserHasRight('ModifyTicket') ) {
2610         return ( 0, $self->loc("Permission Denied") );
2611     }
2612
2613     delete $MERGE_CACHE{'effective'}{ $self->id };
2614     delete @{ $MERGE_CACHE{'merged'} }{
2615         $ticket_id, $MergeInto->id, $self->id
2616     };
2617
2618     $RT::Handle->BeginTransaction();
2619
2620     # We use EffectiveId here even though it duplicates information from
2621     # the links table becasue of the massive performance hit we'd take
2622     # by trying to do a separate database query for merge info everytime
2623     # loaded a ticket.
2624
2625     #update this ticket's effective id to the new ticket's id.
2626     my ( $id_val, $id_msg ) = $self->__Set(
2627         Field => 'EffectiveId',
2628         Value => $MergeInto->Id()
2629     );
2630
2631     unless ($id_val) {
2632         $RT::Handle->Rollback();
2633         return ( 0, $self->loc("Merge failed. Couldn't set EffectiveId") );
2634     }
2635
2636
2637     if ( $self->__Value('Status') ne 'resolved' ) {
2638
2639         my ( $status_val, $status_msg )
2640             = $self->__Set( Field => 'Status', Value => 'resolved' );
2641
2642         unless ($status_val) {
2643             $RT::Handle->Rollback();
2644             $RT::Logger->error(
2645                 $self->loc(
2646                     "[_1] couldn't set status to resolved. RT's Database may be inconsistent.",
2647                     $self
2648                 )
2649             );
2650             return ( 0, $self->loc("Merge failed. Couldn't set Status") );
2651         }
2652     }
2653
2654     # update all the links that point to that old ticket
2655     my $old_links_to = RT::Links->new($self->CurrentUser);
2656     $old_links_to->Limit(FIELD => 'Target', VALUE => $self->URI);
2657
2658     my %old_seen;
2659     while (my $link = $old_links_to->Next) {
2660         if (exists $old_seen{$link->Base."-".$link->Type}) {
2661             $link->Delete;
2662         }
2663         elsif ($link->Base eq $MergeInto->URI) {
2664             $link->Delete;
2665         } else {
2666             # First, make sure the link doesn't already exist. then move it over.
2667             my $tmp = RT::Link->new($RT::SystemUser);
2668             $tmp->LoadByCols(Base => $link->Base, Type => $link->Type, LocalTarget => $MergeInto->id);
2669             if ($tmp->id)   {
2670                     $link->Delete;
2671             } else {
2672                 $link->SetTarget($MergeInto->URI);
2673                 $link->SetLocalTarget($MergeInto->id);
2674             }
2675             $old_seen{$link->Base."-".$link->Type} =1;
2676         }
2677
2678     }
2679
2680     my $old_links_from = RT::Links->new($self->CurrentUser);
2681     $old_links_from->Limit(FIELD => 'Base', VALUE => $self->URI);
2682
2683     while (my $link = $old_links_from->Next) {
2684         if (exists $old_seen{$link->Type."-".$link->Target}) {
2685             $link->Delete;
2686         }
2687         if ($link->Target eq $MergeInto->URI) {
2688             $link->Delete;
2689         } else {
2690             # First, make sure the link doesn't already exist. then move it over.
2691             my $tmp = RT::Link->new($RT::SystemUser);
2692             $tmp->LoadByCols(Target => $link->Target, Type => $link->Type, LocalBase => $MergeInto->id);
2693             if ($tmp->id)   {
2694                     $link->Delete;
2695             } else {
2696                 $link->SetBase($MergeInto->URI);
2697                 $link->SetLocalBase($MergeInto->id);
2698                 $old_seen{$link->Type."-".$link->Target} =1;
2699             }
2700         }
2701
2702     }
2703
2704     # Update time fields
2705     foreach my $type qw(TimeEstimated TimeWorked TimeLeft) {
2706
2707         my $mutator = "Set$type";
2708         $MergeInto->$mutator(
2709             ( $MergeInto->$type() || 0 ) + ( $self->$type() || 0 ) );
2710
2711     }
2712 #add all of this ticket's watchers to that ticket.
2713     foreach my $watcher_type qw(Requestors Cc AdminCc) {
2714
2715         my $people = $self->$watcher_type->MembersObj;
2716         my $addwatcher_type =  $watcher_type;
2717         $addwatcher_type  =~ s/s$//;
2718
2719         while ( my $watcher = $people->Next ) {
2720
2721            my ($val, $msg) =  $MergeInto->_AddWatcher(
2722                 Type        => $addwatcher_type,
2723                 Silent => 1,
2724                 PrincipalId => $watcher->MemberId
2725             );
2726             unless ($val) {
2727                 $RT::Logger->warning($msg);
2728             }
2729     }
2730
2731     }
2732
2733     #find all of the tickets that were merged into this ticket.
2734     my $old_mergees = new RT::Tickets( $self->CurrentUser );
2735     $old_mergees->Limit(
2736         FIELD    => 'EffectiveId',
2737         OPERATOR => '=',
2738         VALUE    => $self->Id
2739     );
2740
2741     #   update their EffectiveId fields to the new ticket's id
2742     while ( my $ticket = $old_mergees->Next() ) {
2743         my ( $val, $msg ) = $ticket->__Set(
2744             Field => 'EffectiveId',
2745             Value => $MergeInto->Id()
2746         );
2747     }
2748
2749     #make a new link: this ticket is merged into that other ticket.
2750     $self->AddLink( Type   => 'MergedInto', Target => $MergeInto->Id());
2751
2752     $MergeInto->_SetLastUpdated;
2753
2754     $RT::Handle->Commit();
2755     return ( 1, $self->loc("Merge Successful") );
2756 }
2757
2758 =head2 Merged
2759
2760 Returns list of tickets' ids that's been merged into this ticket.
2761
2762 =cut
2763
2764 sub Merged {
2765     my $self = shift;
2766
2767     my $id = $self->id;
2768     return @{ $MERGE_CACHE{'merged'}{ $id } }
2769         if $MERGE_CACHE{'merged'}{ $id };
2770
2771     my $mergees = RT::Tickets->new( $self->CurrentUser );
2772     $mergees->Limit(
2773         FIELD    => 'EffectiveId',
2774         VALUE    => $id,
2775     );
2776     $mergees->Limit(
2777         FIELD    => 'id',
2778         OPERATOR => '!=',
2779         VALUE    => $id,
2780     );
2781     return @{ $MERGE_CACHE{'merged'}{ $id } ||= [] }
2782         = map $_->id, @{ $mergees->ItemsArrayRef || [] };
2783 }
2784
2785 # }}}
2786
2787 # }}}
2788
2789 # {{{ Routines dealing with ownership
2790
2791 # {{{ sub OwnerObj
2792
2793 =head2 OwnerObj
2794
2795 Takes nothing and returns an RT::User object of
2796 this ticket's owner
2797
2798 =cut
2799
2800 sub OwnerObj {
2801     my $self = shift;
2802
2803     #If this gets ACLed, we lose on a rights check in User.pm and
2804     #get deep recursion. if we need ACLs here, we need
2805     #an equiv without ACLs
2806
2807     my $owner = new RT::User( $self->CurrentUser );
2808     $owner->Load( $self->__Value('Owner') );
2809
2810     #Return the owner object
2811     return ($owner);
2812 }
2813
2814 # }}}
2815
2816 # {{{ sub OwnerAsString
2817
2818 =head2 OwnerAsString
2819
2820 Returns the owner's email address
2821
2822 =cut
2823
2824 sub OwnerAsString {
2825     my $self = shift;
2826     return ( $self->OwnerObj->EmailAddress );
2827
2828 }
2829
2830 # }}}
2831
2832 # {{{ sub SetOwner
2833
2834 =head2 SetOwner
2835
2836 Takes two arguments:
2837      the Id or Name of the owner
2838 and  (optionally) the type of the SetOwner Transaction. It defaults
2839 to 'Give'.  'Steal' is also a valid option.
2840
2841
2842 =cut
2843
2844 sub SetOwner {
2845     my $self     = shift;
2846     my $NewOwner = shift;
2847     my $Type     = shift || "Give";
2848
2849     $RT::Handle->BeginTransaction();
2850
2851     $self->_SetLastUpdated(); # lock the ticket
2852     $self->Load( $self->id ); # in case $self changed while waiting for lock
2853
2854     my $OldOwnerObj = $self->OwnerObj;
2855
2856     my $NewOwnerObj = RT::User->new( $self->CurrentUser );
2857     $NewOwnerObj->Load( $NewOwner );
2858     unless ( $NewOwnerObj->Id ) {
2859         $RT::Handle->Rollback();
2860         return ( 0, $self->loc("That user does not exist") );
2861     }
2862
2863
2864     # must have ModifyTicket rights
2865     # or TakeTicket/StealTicket and $NewOwner is self
2866     # see if it's a take
2867     if ( $OldOwnerObj->Id == $RT::Nobody->Id ) {
2868         unless (    $self->CurrentUserHasRight('ModifyTicket')
2869                  || $self->CurrentUserHasRight('TakeTicket') ) {
2870             $RT::Handle->Rollback();
2871             return ( 0, $self->loc("Permission Denied") );
2872         }
2873     }
2874
2875     # see if it's a steal
2876     elsif (    $OldOwnerObj->Id != $RT::Nobody->Id
2877             && $OldOwnerObj->Id != $self->CurrentUser->id ) {
2878
2879         unless (    $self->CurrentUserHasRight('ModifyTicket')
2880                  || $self->CurrentUserHasRight('StealTicket') ) {
2881             $RT::Handle->Rollback();
2882             return ( 0, $self->loc("Permission Denied") );
2883         }
2884     }
2885     else {
2886         unless ( $self->CurrentUserHasRight('ModifyTicket') ) {
2887             $RT::Handle->Rollback();
2888             return ( 0, $self->loc("Permission Denied") );
2889         }
2890     }
2891
2892     # If we're not stealing and the ticket has an owner and it's not
2893     # the current user
2894     if ( $Type ne 'Steal' and $Type ne 'Force'
2895          and $OldOwnerObj->Id != $RT::Nobody->Id
2896          and $OldOwnerObj->Id != $self->CurrentUser->Id )
2897     {
2898         $RT::Handle->Rollback();
2899         return ( 0, $self->loc("You can only take tickets that are unowned") )
2900             if $NewOwnerObj->id == $self->CurrentUser->id;
2901         return (
2902             0,
2903             $self->loc("You can only reassign tickets that you own or that are unowned" )
2904         );
2905     }
2906
2907     #If we've specified a new owner and that user can't modify the ticket
2908     elsif ( !$NewOwnerObj->HasRight( Right => 'OwnTicket', Object => $self ) ) {
2909         $RT::Handle->Rollback();
2910         return ( 0, $self->loc("That user may not own tickets in that queue") );
2911     }
2912
2913     # If the ticket has an owner and it's the new owner, we don't need
2914     # To do anything
2915     elsif ( $NewOwnerObj->Id == $OldOwnerObj->Id ) {
2916         $RT::Handle->Rollback();
2917         return ( 0, $self->loc("That user already owns that ticket") );
2918     }
2919
2920     # Delete the owner in the owner group, then add a new one
2921     # TODO: is this safe? it's not how we really want the API to work
2922     # for most things, but it's fast.
2923     my ( $del_id, $del_msg );
2924     for my $owner (@{$self->OwnerGroup->MembersObj->ItemsArrayRef}) {
2925         ($del_id, $del_msg) = $owner->Delete();
2926         last unless ($del_id);
2927     }
2928
2929     unless ($del_id) {
2930         $RT::Handle->Rollback();
2931         return ( 0, $self->loc("Could not change owner: [_1]", $del_msg) );
2932     }
2933
2934     my ( $add_id, $add_msg ) = $self->OwnerGroup->_AddMember(
2935                                        PrincipalId => $NewOwnerObj->PrincipalId,
2936                                        InsideTransaction => 1 );
2937     unless ($add_id) {
2938         $RT::Handle->Rollback();
2939         return ( 0, $self->loc("Could not change owner: [_1]", $add_msg ) );
2940     }
2941
2942     # We call set twice with slightly different arguments, so
2943     # as to not have an SQL transaction span two RT transactions
2944
2945     my ( $val, $msg ) = $self->_Set(
2946                       Field             => 'Owner',
2947                       RecordTransaction => 0,
2948                       Value             => $NewOwnerObj->Id,
2949                       TimeTaken         => 0,
2950                       TransactionType   => $Type,
2951                       CheckACL          => 0,                  # don't check acl
2952     );
2953
2954     unless ($val) {
2955         $RT::Handle->Rollback;
2956         return ( 0, $self->loc("Could not change owner: [_1]", $msg) );
2957     }
2958
2959     ($val, $msg) = $self->_NewTransaction(
2960         Type      => $Type,
2961         Field     => 'Owner',
2962         NewValue  => $NewOwnerObj->Id,
2963         OldValue  => $OldOwnerObj->Id,
2964         TimeTaken => 0,
2965     );
2966
2967     if ( $val ) {
2968         $msg = $self->loc( "Owner changed from [_1] to [_2]",
2969                            $OldOwnerObj->Name, $NewOwnerObj->Name );
2970     }
2971     else {
2972         $RT::Handle->Rollback();
2973         return ( 0, $msg );
2974     }
2975
2976     $RT::Handle->Commit();
2977
2978     return ( $val, $msg );
2979 }
2980
2981 # }}}
2982
2983 # {{{ sub Take
2984
2985 =head2 Take
2986
2987 A convenince method to set the ticket's owner to the current user
2988
2989 =cut
2990
2991 sub Take {
2992     my $self = shift;
2993     return ( $self->SetOwner( $self->CurrentUser->Id, 'Take' ) );
2994 }
2995
2996 # }}}
2997
2998 # {{{ sub Untake
2999
3000 =head2 Untake
3001
3002 Convenience method to set the owner to 'nobody' if the current user is the owner.
3003
3004 =cut
3005
3006 sub Untake {
3007     my $self = shift;
3008     return ( $self->SetOwner( $RT::Nobody->UserObj->Id, 'Untake' ) );
3009 }
3010
3011 # }}}
3012
3013 # {{{ sub Steal
3014
3015 =head2 Steal
3016
3017 A convenience method to change the owner of the current ticket to the
3018 current user. Even if it's owned by another user.
3019
3020 =cut
3021
3022 sub Steal {
3023     my $self = shift;
3024
3025     if ( $self->IsOwner( $self->CurrentUser ) ) {
3026         return ( 0, $self->loc("You already own this ticket") );
3027     }
3028     else {
3029         return ( $self->SetOwner( $self->CurrentUser->Id, 'Steal' ) );
3030
3031     }
3032
3033 }
3034
3035 # }}}
3036
3037 # }}}
3038
3039 # {{{ Routines dealing with status
3040
3041 # {{{ sub ValidateStatus
3042
3043 =head2 ValidateStatus STATUS
3044
3045 Takes a string. Returns true if that status is a valid status for this ticket.
3046 Returns false otherwise.
3047
3048 =cut
3049
3050 sub ValidateStatus {
3051     my $self   = shift;
3052     my $status = shift;
3053
3054     #Make sure the status passed in is valid
3055     unless ( $self->QueueObj->IsValidStatus($status) ) {
3056         return (undef);
3057     }
3058
3059     return (1);
3060
3061 }
3062
3063 # }}}
3064
3065 # {{{ sub SetStatus
3066
3067 =head2 SetStatus STATUS
3068
3069 Set this ticket\'s status. STATUS can be one of: new, open, stalled, resolved, rejected or deleted.
3070
3071 Alternatively, you can pass in a list of named parameters (Status => STATUS, Force => FORCE).  If FORCE is true, ignore unresolved dependencies and force a status change.
3072
3073
3074
3075 =cut
3076
3077 sub SetStatus {
3078     my $self   = shift;
3079     my %args;
3080
3081     if (@_ == 1) {
3082     $args{Status} = shift;
3083     }
3084     else {
3085     %args = (@_);
3086     }
3087
3088     #Check ACL
3089     if ( $args{Status} eq 'deleted') {
3090             unless ($self->CurrentUserHasRight('DeleteTicket')) {
3091             return ( 0, $self->loc('Permission Denied') );
3092        }
3093     } else {
3094             unless ($self->CurrentUserHasRight('ModifyTicket')) {
3095             return ( 0, $self->loc('Permission Denied') );
3096        }
3097     }
3098
3099     if (!$args{Force} && ($args{'Status'} eq 'resolved') && $self->HasUnresolvedDependencies) {
3100         return (0, $self->loc('That ticket has unresolved dependencies'));
3101     }
3102
3103     my $now = RT::Date->new( $self->CurrentUser );
3104     $now->SetToNow();
3105
3106     #If we're changing the status from new, record that we've started
3107     if ( $self->Status eq 'new' && $args{Status} ne 'new' ) {
3108
3109         #Set the Started time to "now"
3110         $self->_Set( Field             => 'Started',
3111                      Value             => $now->ISO,
3112                      RecordTransaction => 0 );
3113     }
3114
3115     #When we close a ticket, set the 'Resolved' attribute to now.
3116     # It's misnamed, but that's just historical.
3117     if ( $self->QueueObj->IsInactiveStatus($args{Status}) ) {
3118         $self->_Set( Field             => 'Resolved',
3119                      Value             => $now->ISO,
3120                      RecordTransaction => 0 );
3121     }
3122
3123     #Actually update the status
3124    my ($val, $msg)= $self->_Set( Field           => 'Status',
3125                           Value           => $args{Status},
3126                           TimeTaken       => 0,
3127                           CheckACL      => 0,
3128                           TransactionType => 'Status'  );
3129
3130     return($val,$msg);
3131 }
3132
3133 # }}}
3134
3135 # {{{ sub Delete
3136
3137 =head2 Delete
3138
3139 Takes no arguments. Marks this ticket for garbage collection
3140
3141 =cut
3142
3143 sub Delete {
3144     my $self = shift;
3145     return ( $self->SetStatus('deleted') );
3146
3147     # TODO: garbage collection
3148 }
3149
3150 # }}}
3151
3152 # {{{ sub Stall
3153
3154 =head2 Stall
3155
3156 Sets this ticket's status to stalled
3157
3158 =cut
3159
3160 sub Stall {
3161     my $self = shift;
3162     return ( $self->SetStatus('stalled') );
3163 }
3164
3165 # }}}
3166
3167 # {{{ sub Reject
3168
3169 =head2 Reject
3170
3171 Sets this ticket's status to rejected
3172
3173 =cut
3174
3175 sub Reject {
3176     my $self = shift;
3177     return ( $self->SetStatus('rejected') );
3178 }
3179
3180 # }}}
3181
3182 # {{{ sub Open
3183
3184 =head2 Open
3185
3186 Sets this ticket\'s status to Open
3187
3188 =cut
3189
3190 sub Open {
3191     my $self = shift;
3192     return ( $self->SetStatus('open') );
3193 }
3194
3195 # }}}
3196
3197 # {{{ sub Resolve
3198
3199 =head2 Resolve
3200
3201 Sets this ticket\'s status to Resolved
3202
3203 =cut
3204
3205 sub Resolve {
3206     my $self = shift;
3207     return ( $self->SetStatus('resolved') );
3208 }
3209
3210 # }}}
3211
3212 # }}}
3213
3214
3215 # {{{ Actions + Routines dealing with transactions
3216
3217 # {{{ sub SetTold and _SetTold
3218
3219 =head2 SetTold ISO  [TIMETAKEN]
3220
3221 Updates the told and records a transaction
3222
3223 =cut
3224
3225 sub SetTold {
3226     my $self = shift;
3227     my $told;
3228     $told = shift if (@_);
3229     my $timetaken = shift || 0;
3230
3231     unless ( $self->CurrentUserHasRight('ModifyTicket') ) {
3232         return ( 0, $self->loc("Permission Denied") );
3233     }
3234
3235     my $datetold = new RT::Date( $self->CurrentUser );
3236     if ($told) {
3237         $datetold->Set( Format => 'iso',
3238                         Value  => $told );
3239     }
3240     else {
3241         $datetold->SetToNow();
3242     }
3243
3244     return ( $self->_Set( Field           => 'Told',
3245                           Value           => $datetold->ISO,
3246                           TimeTaken       => $timetaken,
3247                           TransactionType => 'Told' ) );
3248 }
3249
3250 =head2 _SetTold
3251
3252 Updates the told without a transaction or acl check. Useful when we're sending replies.
3253
3254 =cut
3255
3256 sub _SetTold {
3257     my $self = shift;
3258
3259     my $now = new RT::Date( $self->CurrentUser );
3260     $now->SetToNow();
3261
3262     #use __Set to get no ACLs ;)
3263     return ( $self->__Set( Field => 'Told',
3264                            Value => $now->ISO ) );
3265 }
3266
3267 =head2 SeenUpTo
3268
3269
3270 =cut
3271
3272 sub SeenUpTo {
3273     my $self = shift;
3274     my $uid = $self->CurrentUser->id;
3275     my $attr = $self->FirstAttribute( "User-". $uid ."-SeenUpTo" );
3276     return if $attr && $attr->Content gt $self->LastUpdated;
3277
3278     my $txns = $self->Transactions;
3279     $txns->Limit( FIELD => 'Type', VALUE => 'Comment' );
3280     $txns->Limit( FIELD => 'Type', VALUE => 'Correspond' );
3281     $txns->Limit( FIELD => 'Creator', OPERATOR => '!=', VALUE => $uid );
3282     $txns->Limit(
3283         FIELD => 'Created',
3284         OPERATOR => '>',
3285         VALUE => $attr->Content
3286     ) if $attr;
3287     $txns->RowsPerPage(1);
3288     return $txns->First;
3289 }
3290
3291 # }}}
3292
3293 =head2 TransactionBatch
3294
3295 Returns an array reference of all transactions created on this ticket during
3296 this ticket object's lifetime or since last application of a batch, or undef
3297 if there were none.
3298
3299 Only works when the C<UseTransactionBatch> config option is set to true.
3300
3301 =cut
3302
3303 sub TransactionBatch {
3304     my $self = shift;
3305     return $self->{_TransactionBatch};
3306 }
3307
3308 =head2 ApplyTransactionBatch
3309
3310 Applies scrips on the current batch of transactions and shinks it. Usually
3311 batch is applied when object is destroyed, but in some cases it's too late.
3312
3313 =cut
3314
3315 sub ApplyTransactionBatch {
3316     my $self = shift;
3317
3318     my $batch = $self->TransactionBatch;
3319     return unless $batch && @$batch;
3320
3321     $self->_ApplyTransactionBatch;
3322
3323     $self->{_TransactionBatch} = [];
3324 }
3325
3326 sub _ApplyTransactionBatch {
3327     my $self = shift;
3328     my $batch = $self->TransactionBatch;
3329
3330     my %seen;
3331     my $types = join ',', grep !$seen{$_}++, grep defined, map $_->Type, grep defined, @{$batch};
3332
3333     require RT::Scrips;
3334     RT::Scrips->new($RT::SystemUser)->Apply(
3335         Stage          => 'TransactionBatch',
3336         TicketObj      => $self,
3337         TransactionObj => $batch->[0],
3338         Type           => $types,
3339     );
3340
3341     # Entry point of the rule system
3342     my $rules = RT::Ruleset->FindAllRules(
3343         Stage          => 'TransactionBatch',
3344         TicketObj      => $self,
3345         TransactionObj => $batch->[0],
3346         Type           => $types,
3347     );
3348     RT::Ruleset->CommitRules($rules);
3349 }
3350
3351 sub DESTROY {
3352     my $self = shift;
3353
3354     # DESTROY methods need to localize $@, or it may unset it.  This
3355     # causes $m->abort to not bubble all of the way up.  See perlbug
3356     # http://rt.perl.org/rt3/Ticket/Display.html?id=17650
3357     local $@;
3358
3359     # The following line eliminates reentrancy.
3360     # It protects against the fact that perl doesn't deal gracefully
3361     # when an object's refcount is changed in its destructor.
3362     return if $self->{_Destroyed}++;
3363
3364     my $batch = $self->TransactionBatch;
3365     return unless $batch && @$batch;
3366
3367     return $self->_ApplyTransactionBatch;
3368 }
3369
3370 # }}}
3371
3372 # {{{ PRIVATE UTILITY METHODS. Mostly needed so Ticket can be a DBIx::Record
3373
3374 # {{{ sub _OverlayAccessible
3375
3376 sub _OverlayAccessible {
3377     {
3378         EffectiveId       => { 'read' => 1,  'write' => 1,  'public' => 1 },
3379           Queue           => { 'read' => 1,  'write' => 1 },
3380           Requestors      => { 'read' => 1,  'write' => 1 },
3381           Owner           => { 'read' => 1,  'write' => 1 },
3382           Subject         => { 'read' => 1,  'write' => 1 },
3383           InitialPriority => { 'read' => 1,  'write' => 1 },
3384           FinalPriority   => { 'read' => 1,  'write' => 1 },
3385           Priority        => { 'read' => 1,  'write' => 1 },
3386           Status          => { 'read' => 1,  'write' => 1 },
3387           TimeEstimated      => { 'read' => 1,  'write' => 1 },
3388           TimeWorked      => { 'read' => 1,  'write' => 1 },
3389           TimeLeft        => { 'read' => 1,  'write' => 1 },
3390           Told            => { 'read' => 1,  'write' => 1 },
3391           Resolved        => { 'read' => 1 },
3392           Type            => { 'read' => 1 },
3393           Starts        => { 'read' => 1, 'write' => 1 },
3394           Started       => { 'read' => 1, 'write' => 1 },
3395           Due           => { 'read' => 1, 'write' => 1 },
3396           Creator       => { 'read' => 1, 'auto'  => 1 },
3397           Created       => { 'read' => 1, 'auto'  => 1 },
3398           LastUpdatedBy => { 'read' => 1, 'auto'  => 1 },
3399           LastUpdated   => { 'read' => 1, 'auto'  => 1 }
3400     };
3401
3402 }
3403
3404 # }}}
3405
3406 # {{{ sub _Set
3407
3408 sub _Set {
3409     my $self = shift;
3410
3411     my %args = ( Field             => undef,
3412                  Value             => undef,
3413                  TimeTaken         => 0,
3414                  RecordTransaction => 1,
3415                  UpdateTicket      => 1,
3416                  CheckACL          => 1,
3417                  TransactionType   => 'Set',
3418                  @_ );
3419
3420     if ($args{'CheckACL'}) {
3421       unless ( $self->CurrentUserHasRight('ModifyTicket')) {
3422           return ( 0, $self->loc("Permission Denied"));
3423       }
3424    }
3425
3426     unless ($args{'UpdateTicket'} || $args{'RecordTransaction'}) {
3427         $RT::Logger->error("Ticket->_Set called without a mandate to record an update or update the ticket");
3428         return(0, $self->loc("Internal Error"));
3429     }
3430
3431     #if the user is trying to modify the record
3432
3433     #Take care of the old value we really don't want to get in an ACL loop.
3434     # so ask the super::_Value
3435     my $Old = $self->SUPER::_Value("$args{'Field'}");
3436
3437     my ($ret, $msg);
3438     if ( $args{'UpdateTicket'}  ) {
3439
3440         #Set the new value
3441         ( $ret, $msg ) = $self->SUPER::_Set( Field => $args{'Field'},
3442                                                 Value => $args{'Value'} );
3443
3444         #If we can't actually set the field to the value, don't record
3445         # a transaction. instead, get out of here.
3446         return ( 0, $msg ) unless $ret;
3447     }
3448
3449     if ( $args{'RecordTransaction'} == 1 ) {
3450
3451         my ( $Trans, $Msg, $TransObj ) = $self->_NewTransaction(
3452                                                Type => $args{'TransactionType'},
3453                                                Field     => $args{'Field'},
3454                                                NewValue  => $args{'Value'},
3455                                                OldValue  => $Old,
3456                                                TimeTaken => $args{'TimeTaken'},
3457         );
3458         return ( $Trans, scalar $TransObj->BriefDescription );
3459     }
3460     else {
3461         return ( $ret, $msg );
3462     }
3463 }
3464
3465 # }}}
3466
3467 # {{{ sub _Value
3468
3469 =head2 _Value
3470
3471 Takes the name of a table column.
3472 Returns its value as a string, if the user passes an ACL check
3473
3474 =cut
3475
3476 sub _Value {
3477
3478     my $self  = shift;
3479     my $field = shift;
3480
3481     #if the field is public, return it.
3482     if ( $self->_Accessible( $field, 'public' ) ) {
3483
3484         #$RT::Logger->debug("Skipping ACL check for $field");
3485         return ( $self->SUPER::_Value($field) );
3486
3487     }
3488
3489     #If the current user doesn't have ACLs, don't let em at it.
3490
3491     unless ( $self->CurrentUserHasRight('ShowTicket') ) {
3492         return (undef);
3493     }
3494     return ( $self->SUPER::_Value($field) );
3495
3496 }
3497
3498 # }}}
3499
3500 # {{{ sub _UpdateTimeTaken
3501
3502 =head2 _UpdateTimeTaken
3503
3504 This routine will increment the timeworked counter. it should
3505 only be called from _NewTransaction
3506
3507 =cut
3508
3509 sub _UpdateTimeTaken {
3510     my $self    = shift;
3511     my $Minutes = shift;
3512     my ($Total);
3513
3514     $Total = $self->SUPER::_Value("TimeWorked");
3515     $Total = ( $Total || 0 ) + ( $Minutes || 0 );
3516     $self->SUPER::_Set(
3517         Field => "TimeWorked",
3518         Value => $Total
3519     );
3520
3521     return ($Total);
3522 }
3523
3524 # }}}
3525
3526 # }}}
3527
3528 # {{{ Routines dealing with ACCESS CONTROL
3529
3530 # {{{ sub CurrentUserHasRight
3531
3532 =head2 CurrentUserHasRight
3533
3534   Takes the textual name of a Ticket scoped right (from RT::ACE) and returns
3535 1 if the user has that right. It returns 0 if the user doesn't have that right.
3536
3537 =cut
3538
3539 sub CurrentUserHasRight {
3540     my $self  = shift;
3541     my $right = shift;
3542
3543     return $self->CurrentUser->PrincipalObj->HasRight(
3544         Object => $self,
3545         Right  => $right,
3546     )
3547 }
3548
3549 # }}}
3550
3551 # {{{ sub HasRight
3552
3553 =head2 HasRight
3554
3555  Takes a paramhash with the attributes 'Right' and 'Principal'
3556   'Right' is a ticket-scoped textual right from RT::ACE
3557   'Principal' is an RT::User object
3558
3559   Returns 1 if the principal has the right. Returns undef if not.
3560
3561 =cut
3562
3563 sub HasRight {
3564     my $self = shift;
3565     my %args = (
3566         Right     => undef,
3567         Principal => undef,
3568         @_
3569     );
3570
3571     unless ( ( defined $args{'Principal'} ) and ( ref( $args{'Principal'} ) ) )
3572     {
3573         Carp::cluck("Principal attrib undefined for Ticket::HasRight");
3574         $RT::Logger->crit("Principal attrib undefined for Ticket::HasRight");
3575         return(undef);
3576     }
3577
3578     return (
3579         $args{'Principal'}->HasRight(
3580             Object => $self,
3581             Right     => $args{'Right'}
3582           )
3583     );
3584 }
3585
3586 # }}}
3587
3588 # }}}
3589
3590 =head2 Reminders
3591
3592 Return the Reminders object for this ticket. (It's an RT::Reminders object.)
3593 It isn't acutally a searchbuilder collection itself.
3594
3595 =cut
3596
3597 sub Reminders {
3598     my $self = shift;
3599
3600     unless ($self->{'__reminders'}) {
3601         $self->{'__reminders'} = RT::Reminders->new($self->CurrentUser);
3602         $self->{'__reminders'}->Ticket($self->id);
3603     }
3604     return $self->{'__reminders'};
3605
3606 }
3607
3608
3609
3610 # {{{ sub Transactions
3611
3612 =head2 Transactions
3613
3614   Returns an RT::Transactions object of all transactions on this ticket
3615
3616 =cut
3617
3618 sub Transactions {
3619     my $self = shift;
3620
3621     my $transactions = RT::Transactions->new( $self->CurrentUser );
3622
3623     #If the user has no rights, return an empty object
3624     if ( $self->CurrentUserHasRight('ShowTicket') ) {
3625         $transactions->LimitToTicket($self->id);
3626
3627         # if the user may not see comments do not return them
3628         unless ( $self->CurrentUserHasRight('ShowTicketComments') ) {
3629             $transactions->Limit(
3630                 SUBCLAUSE => 'acl',
3631                 FIELD    => 'Type',
3632                 OPERATOR => '!=',
3633                 VALUE    => "Comment"
3634             );
3635             $transactions->Limit(
3636                 SUBCLAUSE => 'acl',
3637                 FIELD    => 'Type',
3638                 OPERATOR => '!=',
3639                 VALUE    => "CommentEmailRecord",
3640                 ENTRYAGGREGATOR => 'AND'
3641             );
3642
3643         }
3644     } else {
3645         $transactions->Limit(
3646             SUBCLAUSE => 'acl',
3647             FIELD    => 'id',
3648             VALUE    => 0,
3649             ENTRYAGGREGATOR => 'AND'
3650         );
3651     }
3652
3653     return ($transactions);
3654 }
3655
3656 # }}}
3657
3658
3659 # {{{ TransactionCustomFields
3660
3661 =head2 TransactionCustomFields
3662
3663     Returns the custom fields that transactions on tickets will have.
3664
3665 =cut
3666
3667 sub TransactionCustomFields {
3668     my $self = shift;
3669     return $self->QueueObj->TicketTransactionCustomFields;
3670 }
3671
3672 # }}}
3673
3674 # {{{ sub CustomFieldValues
3675
3676 =head2 CustomFieldValues
3677
3678 # Do name => id mapping (if needed) before falling back to
3679 # RT::Record's CustomFieldValues
3680
3681 See L<RT::Record>
3682
3683 =cut
3684
3685 sub CustomFieldValues {
3686     my $self  = shift;
3687     my $field = shift;
3688
3689     return $self->SUPER::CustomFieldValues( $field ) if !$field || $field =~ /^\d+$/;
3690
3691     my $cf = RT::CustomField->new( $self->CurrentUser );
3692     $cf->SetContextObject( $self );
3693     $cf->LoadByNameAndQueue( Name => $field, Queue => $self->Queue );
3694     unless ( $cf->id ) {
3695         $cf->LoadByNameAndQueue( Name => $field, Queue => 0 );
3696     }
3697
3698     # If we didn't find a valid cfid, give up.
3699     return RT::ObjectCustomFieldValues->new( $self->CurrentUser ) unless $cf->id;
3700
3701     return $self->SUPER::CustomFieldValues( $cf->id );
3702 }
3703
3704 # }}}
3705
3706 # {{{ sub CustomFieldLookupType
3707
3708 =head2 CustomFieldLookupType
3709
3710 Returns the RT::Ticket lookup type, which can be passed to
3711 RT::CustomField->Create() via the 'LookupType' hash key.
3712
3713 =cut
3714
3715 # }}}
3716
3717 sub CustomFieldLookupType {
3718     "RT::Queue-RT::Ticket";
3719 }
3720
3721 =head2 ACLEquivalenceObjects
3722
3723 This method returns a list of objects for which a user's rights also apply
3724 to this ticket. Generally, this is only the ticket's queue, but some RT
3725 extensions may make other objects available too.
3726
3727 This method is called from L<RT::Principal/HasRight>.
3728
3729 =cut
3730
3731 sub ACLEquivalenceObjects {
3732     my $self = shift;
3733     return $self->QueueObj;
3734
3735 }
3736
3737
3738 1;
3739
3740 =head1 AUTHOR
3741
3742 Jesse Vincent, jesse@bestpractical.com
3743
3744 =head1 SEE ALSO
3745
3746 RT
3747
3748 =cut
3749