rt/lib/RT/Template.pm

   1 # BEGIN BPS TAGGED BLOCK {{{
   2 #
   3 # COPYRIGHT:
   4 #
   5 # This software is Copyright (c) 1996-2012 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 # Portions Copyright 2000 Tobias Brox <tobix@cpan.org>
  50
  51 =head1 NAME
  52
  53   RT::Template - RT's template object
  54
  55 =head1 SYNOPSIS
  56
  57   use RT::Template;
  58
  59 =head1 DESCRIPTION
  60
  61
  62 =head1 METHODS
  63
  64
  65 =cut
  66
  67
  68 package RT::Template;
  69
  70 use strict;
  71 use warnings;
  72
  73
  74
  75 use Text::Template;
  76 use MIME::Entity;
  77 use MIME::Parser;
  78 use Scalar::Util 'blessed';
  79
  80 sub _Accessible {
  81     my $self = shift;
  82     my %Cols = (
  83         id            => 'read',
  84         Name          => 'read/write',
  85         Description   => 'read/write',
  86         Type          => 'read/write',    #Type is one of Perl or Simple
  87         Content       => 'read/write',
  88         Queue         => 'read/write',
  89         Creator       => 'read/auto',
  90         Created       => 'read/auto',
  91         LastUpdatedBy => 'read/auto',
  92         LastUpdated   => 'read/auto'
  93     );
  94     return $self->SUPER::_Accessible( @_, %Cols );
  95 }
  96
  97 sub _Set {
  98     my $self = shift;
  99     my %args = (
 100         Field => undef,
 101         Value => undef,
 102         @_,
 103     );
 104
 105     unless ( $self->CurrentUserHasQueueRight('ModifyTemplate') ) {
 106         return ( 0, $self->loc('Permission Denied') );
 107     }
 108
 109     if (exists $args{Value}) {
 110         if ($args{Field} eq 'Queue') {
 111             if ($args{Value}) {
 112                 # moving to another queue
 113                 my $queue = RT::Queue->new( $self->CurrentUser );
 114                 $queue->Load($args{Value});
 115                 unless ($queue->Id and $queue->CurrentUserHasRight('ModifyTemplate')) {
 116                     return ( 0, $self->loc('Permission Denied') );
 117                 }
 118             } else {
 119                 # moving to global
 120                 unless ($self->CurrentUser->HasRight( Object => RT->System, Right => 'ModifyTemplate' )) {
 121                     return ( 0, $self->loc('Permission Denied') );
 122                 }
 123             }
 124         }
 125     }
 126
 127     return $self->SUPER::_Set( @_ );
 128 }
 129
 130 =head2 _Value
 131
 132 Takes the name of a table column. Returns its value as a string,
 133 if the user passes an ACL check, otherwise returns undef.
 134
 135 =cut
 136
 137 sub _Value {
 138     my $self  = shift;
 139
 140     unless ( $self->CurrentUserCanRead() ) {
 141         return undef;
 142     }
 143     return $self->__Value( @_ );
 144
 145 }
 146
 147 =head2 Load <identifier>
 148
 149 Load a template, either by number or by name.
 150
 151 Note that loading templates by name using this method B<is
 152 ambiguous>. Several queues may have template with the same name
 153 and as well global template with the same name may exist.
 154 Use L</LoadGlobalTemplate> and/or L<LoadQueueTemplate> to get
 155 precise result.
 156
 157 =cut
 158
 159 sub Load {
 160     my $self       = shift;
 161     my $identifier = shift;
 162     return undef unless $identifier;
 163
 164     if ( $identifier =~ /\D/ ) {
 165         return $self->LoadByCol( 'Name', $identifier );
 166     }
 167     return $self->LoadById( $identifier );
 168 }
 169
 170 =head2 LoadGlobalTemplate NAME
 171
 172 Load the global template with the name NAME
 173
 174 =cut
 175
 176 sub LoadGlobalTemplate {
 177     my $self = shift;
 178     my $name = shift;
 179
 180     return ( $self->LoadQueueTemplate( Queue => 0, Name => $name ) );
 181 }
 182
 183 =head2 LoadQueueTemplate (Queue => QUEUEID, Name => NAME)
 184
 185 Loads the Queue template named NAME for Queue QUEUE.
 186
 187 Note that this method doesn't load a global template with the same name
 188 if template in the queue doesn't exist. THe following code can be used:
 189
 190     $template->LoadQueueTemplate( Queue => $queue_id, Name => $template_name );
 191     unless ( $template->id ) {
 192         $template->LoadGlobalTemplate( $template_name );
 193         unless ( $template->id ) {
 194             # no template
 195             ...
 196         }
 197     }
 198     # ok, template either queue's or global
 199     ...
 200
 201 =cut
 202
 203 sub LoadQueueTemplate {
 204     my $self = shift;
 205     my %args = (
 206         Queue => undef,
 207         Name  => undef,
 208         @_
 209     );
 210
 211     return ( $self->LoadByCols( Name => $args{'Name'}, Queue => $args{'Queue'} ) );
 212
 213 }
 214
 215 =head2 Create
 216
 217 Takes a paramhash of Content, Queue, Name and Description.
 218 Name should be a unique string identifying this Template.
 219 Description and Content should be the template's title and content.
 220 Queue should be 0 for a global template and the queue # for a queue-specific
 221 template.
 222
 223 Returns the Template's id # if the create was successful. Returns undef for
 224 unknown database failure.
 225
 226 =cut
 227
 228 sub Create {
 229     my $self = shift;
 230     my %args = (
 231         Content     => undef,
 232         Queue       => 0,
 233         Description => '[no description]',
 234         Type        => 'Perl',
 235         Name        => undef,
 236         @_
 237     );
 238
 239     if ( $args{Type} eq 'Perl' && !$self->CurrentUser->HasRight(Right => 'ExecuteCode', Object => $RT::System) ) {
 240         return ( undef, $self->loc('Permission Denied') );
 241     }
 242
 243     unless ( $args{'Queue'} ) {
 244         unless ( $self->CurrentUser->HasRight(Right =>'ModifyTemplate', Object => $RT::System) ) {
 245             return ( undef, $self->loc('Permission Denied') );
 246         }
 247         $args{'Queue'} = 0;
 248     }
 249     else {
 250         my $QueueObj = RT::Queue->new( $self->CurrentUser );
 251         $QueueObj->Load( $args{'Queue'} ) || return ( undef, $self->loc('Invalid queue') );
 252
 253         unless ( $QueueObj->CurrentUserHasRight('ModifyTemplate') ) {
 254             return ( undef, $self->loc('Permission Denied') );
 255         }
 256         $args{'Queue'} = $QueueObj->Id;
 257     }
 258
 259     my $result = $self->SUPER::Create(
 260         Content     => $args{'Content'},
 261         Queue       => $args{'Queue'},
 262         Description => $args{'Description'},
 263         Name        => $args{'Name'},
 264         Type        => $args{'Type'},
 265     );
 266
 267     return ($result);
 268
 269 }
 270
 271 =head2 Delete
 272
 273 Delete this template.
 274
 275 =cut
 276
 277 sub Delete {
 278     my $self = shift;
 279
 280     unless ( $self->CurrentUserHasQueueRight('ModifyTemplate') ) {
 281         return ( 0, $self->loc('Permission Denied') );
 282     }
 283
 284     return ( $self->SUPER::Delete(@_) );
 285 }
 286
 287 =head2 IsEmpty
 288
 289 Returns true value if content of the template is empty, otherwise
 290 returns false.
 291
 292 =cut
 293
 294 sub IsEmpty {
 295     my $self = shift;
 296     my $content = $self->Content;
 297     return 0 if defined $content && length $content;
 298     return 1;
 299 }
 300
 301 =head2 MIMEObj
 302
 303 Returns L<MIME::Entity> object parsed using L</Parse> method. Returns
 304 undef if last call to L</Parse> failed or never be called.
 305
 306 Note that content of the template is UTF-8, but L<MIME::Parser> is not
 307 good at handling it and all data of the entity should be treated as
 308 octets and converted to perl strings using Encode::decode_utf8 or
 309 something else.
 310
 311 =cut
 312
 313 sub MIMEObj {
 314     my $self = shift;
 315     return ( $self->{'MIMEObj'} );
 316 }
 317
 318 =head2 Parse
 319
 320 This routine performs L<Text::Template> parsing on the template and then
 321 imports the results into a L<MIME::Entity> so we can really use it. Use
 322 L</MIMEObj> method to get the L<MIME::Entity> object.
 323
 324 Takes a hash containing Argument, TicketObj, and TransactionObj and other
 325 arguments that will be available in the template's code. TicketObj and
 326 TransactionObj are not mandatory, but highly recommended.
 327
 328 It returns a tuple of (val, message). If val is false, the message contains
 329 an error message.
 330
 331 =cut
 332
 333 sub Parse {
 334     my $self = shift;
 335     my ($rv, $msg);
 336
 337
 338     if ($self->Content =~ m{^Content-Type:\s+text/html\b}im) {
 339         local $RT::Transaction::PreferredContentType = 'text/html';
 340         ($rv, $msg) = $self->_Parse(@_);
 341     }
 342     else {
 343         ($rv, $msg) = $self->_Parse(@_);
 344     }
 345
 346     return ($rv, $msg) unless $rv;
 347
 348     my $mime_type   = $self->MIMEObj->mime_type;
 349     if (defined $mime_type and $mime_type eq 'text/html') {
 350         $self->_DowngradeFromHTML(@_);
 351     }
 352
 353     return ($rv, $msg);
 354 }
 355
 356 sub _Parse {
 357     my $self = shift;
 358
 359     # clear prev MIME object
 360     $self->{'MIMEObj'} = undef;
 361
 362     #We're passing in whatever we were passed. it's destined for _ParseContent
 363     my ($content, $msg) = $self->_ParseContent(@_);
 364     return ( 0, $msg ) unless defined $content && length $content;
 365
 366     if ( $content =~ /^\S/s && $content !~ /^\S+:/ ) {
 367         $RT::Logger->error(
 368             "Template #". $self->id ." has leading line that doesn't"
 369             ." look like header field, if you don't want to override"
 370             ." any headers and don't want to see this error message"
 371             ." then leave first line of the template empty"
 372         );
 373         $content = "\n".$content;
 374     }
 375
 376     my $parser = MIME::Parser->new();
 377     $parser->output_to_core(1);
 378     $parser->tmp_to_core(1);
 379     $parser->use_inner_files(1);
 380
 381     ### Should we forgive normally-fatal errors?
 382     $parser->ignore_errors(1);
 383     # MIME::Parser doesn't play well with perl strings
 384     utf8::encode($content);
 385     $self->{'MIMEObj'} = eval { $parser->parse_data( \$content ) };
 386     if ( my $error = $@ || $parser->last_error ) {
 387         $RT::Logger->error( "$error" );
 388         return ( 0, $error );
 389     }
 390
 391     # Unfold all headers
 392     $self->{'MIMEObj'}->head->unfold;
 393
 394     return ( 1, $self->loc("Template parsed") );
 395
 396 }
 397
 398 # Perform Template substitutions on the template
 399
 400 sub _ParseContent {
 401     my $self = shift;
 402     my %args = (
 403         Argument       => undef,
 404         TicketObj      => undef,
 405         TransactionObj => undef,
 406         @_
 407     );
 408
 409     unless ( $self->CurrentUserCanRead() ) {
 410         return (undef, $self->loc("Permission Denied"));
 411     }
 412
 413     if ( $self->IsEmpty ) {
 414         return ( undef, $self->loc("Template is empty") );
 415     }
 416
 417     my $content = $self->SUPER::_Value('Content');
 418     # We need to untaint the content of the template, since we'll be working
 419     # with it
 420     $content =~ s/^(.*)$/$1/;
 421
 422     $args{'Ticket'} = delete $args{'TicketObj'} if $args{'TicketObj'};
 423     $args{'Transaction'} = delete $args{'TransactionObj'} if $args{'TransactionObj'};
 424     $args{'Requestor'} = eval { $args{'Ticket'}->Requestors->UserMembersObj->First->Name }
 425         if $args{'Ticket'};
 426     $args{'rtname'}    = RT->Config->Get('rtname');
 427     if ( $args{'Ticket'} ) {
 428         my $t = $args{'Ticket'}; # avoid memory leak
 429         $args{'loc'} = sub { $t->loc(@_) };
 430     } else {
 431         $args{'loc'} = sub { $self->loc(@_) };
 432     }
 433
 434     if ($self->Type eq 'Perl') {
 435         return $self->_ParseContentPerl(
 436             Content      => $content,
 437             TemplateArgs => \%args,
 438         );
 439     }
 440     else {
 441         return $self->_ParseContentSimple(
 442             Content      => $content,
 443             TemplateArgs => \%args,
 444         );
 445     }
 446 }
 447
 448 # uses Text::Template for Perl templates
 449 sub _ParseContentPerl {
 450     my $self = shift;
 451     my %args = (
 452         Content      => undef,
 453         TemplateArgs => {},
 454         @_,
 455     );
 456
 457     foreach my $key ( keys %{ $args{TemplateArgs} } ) {
 458         my $val = $args{TemplateArgs}{ $key };
 459         next unless ref $val;
 460         next if ref $val =~ /^(ARRAY|HASH|SCALAR|CODE)$/;
 461         $args{TemplateArgs}{ $key } = \$val;
 462     }
 463
 464     my $template = Text::Template->new(
 465         TYPE   => 'STRING',
 466         SOURCE => $args{Content},
 467     );
 468     my $is_broken = 0;
 469     my $retval = $template->fill_in(
 470         HASH => $args{TemplateArgs},
 471         BROKEN => sub {
 472             my (%args) = @_;
 473             $RT::Logger->error("Template parsing error: $args{error}")
 474                 unless $args{error} =~ /^Died at /; # ignore intentional die()
 475             $is_broken++;
 476             return undef;
 477         },
 478     );
 479     return ( undef, $self->loc('Template parsing error') ) if $is_broken;
 480
 481     return ($retval);
 482 }
 483
 484 sub _ParseContentSimple {
 485     my $self = shift;
 486     my %args = (
 487         Content      => undef,
 488         TemplateArgs => {},
 489         @_,
 490     );
 491
 492     $self->_MassageSimpleTemplateArgs(%args);
 493
 494     my $template = Text::Template->new(
 495         TYPE   => 'STRING',
 496         SOURCE => $args{Content},
 497     );
 498     my ($ok) = $template->compile;
 499     return ( undef, $self->loc('Template parsing error: [_1]', $Text::Template::ERROR) ) if !$ok;
 500
 501     # copied from Text::Template::fill_in and refactored to be simple variable
 502     # interpolation
 503     my $fi_r = '';
 504     foreach my $fi_item (@{$template->{SOURCE}}) {
 505         my ($fi_type, $fi_text, $fi_lineno) = @$fi_item;
 506         if ($fi_type eq 'TEXT') {
 507             $fi_r .= $fi_text;
 508         } elsif ($fi_type eq 'PROG') {
 509             my $fi_res;
 510             my $original_fi_text = $fi_text;
 511
 512             # strip surrounding whitespace for simpler regexes
 513             $fi_text =~ s/^\s+//;
 514             $fi_text =~ s/\s+$//;
 515
 516             # if the codeblock is a simple $Variable lookup, use the value from
 517             # the TemplateArgs hash...
 518             if (my ($var) = $fi_text =~ /^\$(\w+)$/) {
 519                 if (exists $args{TemplateArgs}{$var}) {
 520                     $fi_res = $args{TemplateArgs}{$var};
 521                 }
 522             }
 523
 524             # if there was no substitution then just reinsert the codeblock
 525             if (!defined $fi_res) {
 526                 $fi_res = "{$original_fi_text}";
 527             }
 528
 529             # If the value of the filled-in text really was undef,
 530             # change it to an explicit empty string to avoid undefined
 531             # value warnings later.
 532             $fi_res = '' unless defined $fi_res;
 533
 534             $fi_r .= $fi_res;
 535         }
 536     }
 537
 538     return $fi_r;
 539 }
 540
 541 sub _MassageSimpleTemplateArgs {
 542     my $self = shift;
 543     my %args = (
 544         TemplateArgs => {},
 545         @_,
 546     );
 547
 548     my $template_args = $args{TemplateArgs};
 549
 550     if (my $ticket = $template_args->{Ticket}) {
 551         for my $column (qw/Id Subject Type InitialPriority FinalPriority Priority TimeEstimated TimeWorked Status TimeLeft Told Starts Started Due Resolved RequestorAddresses AdminCcAddresses CcAddresses/) {
 552             $template_args->{"Ticket".$column} = $ticket->$column;
 553         }
 554
 555         $template_args->{"TicketQueueId"}   = $ticket->Queue;
 556         $template_args->{"TicketQueueName"} = $ticket->QueueObj->Name;
 557
 558         $template_args->{"TicketOwnerId"}    = $ticket->Owner;
 559         $template_args->{"TicketOwnerName"}  = $ticket->OwnerObj->Name;
 560         $template_args->{"TicketOwnerEmailAddress"} = $ticket->OwnerObj->EmailAddress;
 561
 562         my $cfs = $ticket->CustomFields;
 563         while (my $cf = $cfs->Next) {
 564             $template_args->{"TicketCF" . $cf->Name} = $ticket->CustomFieldValuesAsString($cf->Name);
 565         }
 566     }
 567
 568     if (my $txn = $template_args->{Transaction}) {
 569         for my $column (qw/Id TimeTaken Type Field OldValue NewValue Data Content Subject Description BriefDescription/) {
 570             $template_args->{"Transaction".$column} = $txn->$column;
 571         }
 572
 573         my $cfs = $txn->CustomFields;
 574         while (my $cf = $cfs->Next) {
 575             $template_args->{"TransactionCF" . $cf->Name} = $txn->CustomFieldValuesAsString($cf->Name);
 576         }
 577     }
 578 }
 579
 580 sub _DowngradeFromHTML {
 581     my $self = shift;
 582     my $orig_entity = $self->MIMEObj;
 583
 584     my $new_entity = $orig_entity->dup; # this will fail badly if we go away from InCore parsing
 585     $new_entity->head->mime_attr( "Content-Type" => 'text/plain' );
 586     $new_entity->head->mime_attr( "Content-Type.charset" => 'utf-8' );
 587
 588     $orig_entity->head->mime_attr( "Content-Type" => 'text/html' );
 589     $orig_entity->head->mime_attr( "Content-Type.charset" => 'utf-8' );
 590     $orig_entity->make_multipart('alternative', Force => 1);
 591
 592     require HTML::FormatText;
 593     require HTML::TreeBuilder;
 594     require Encode;
 595     # need to decode_utf8, see the doc of MIMEObj method
 596     my $tree = HTML::TreeBuilder->new_from_content(
 597         Encode::decode_utf8($new_entity->bodyhandle->as_string)
 598     );
 599     $new_entity->bodyhandle(MIME::Body::InCore->new(
 600         \(scalar HTML::FormatText->new(
 601             leftmargin  => 0,
 602             rightmargin => 78,
 603         )->format( $tree ))
 604     ));
 605     $tree->delete;
 606
 607     $orig_entity->add_part($new_entity, 0); # plain comes before html
 608     $self->{MIMEObj} = $orig_entity;
 609
 610     return;
 611 }
 612
 613 =head2 CurrentUserHasQueueRight
 614
 615 Helper function to call the template's queue's CurrentUserHasQueueRight with the passed in args.
 616
 617 =cut
 618
 619 sub CurrentUserHasQueueRight {
 620     my $self = shift;
 621     return ( $self->QueueObj->CurrentUserHasRight(@_) );
 622 }
 623
 624 =head2 SetType
 625
 626 If setting Type to Perl, require the ExecuteCode right.
 627
 628 =cut
 629
 630 sub SetType {
 631     my $self    = shift;
 632     my $NewType = shift;
 633
 634     if ($NewType eq 'Perl' && !$self->CurrentUser->HasRight(Right => 'ExecuteCode', Object => $RT::System)) {
 635         return ( undef, $self->loc('Permission Denied') );
 636     }
 637
 638     return $self->_Set( Field => 'Type', Value => $NewType );
 639 }
 640
 641 =head2 SetContent
 642
 643 If changing content and the type is Perl, require the ExecuteCode right.
 644
 645 =cut
 646
 647 sub SetContent {
 648     my $self       = shift;
 649     my $NewContent = shift;
 650
 651     if ($self->Type eq 'Perl' && !$self->CurrentUser->HasRight(Right => 'ExecuteCode', Object => $RT::System)) {
 652         return ( undef, $self->loc('Permission Denied') );
 653     }
 654
 655     return $self->_Set( Field => 'Content', Value => $NewContent );
 656 }
 657
 658 sub _UpdateAttributes {
 659     my $self = shift;
 660     my %args = (
 661         NewValues => {},
 662         @_,
 663     );
 664
 665     my $type = $args{NewValues}{Type} || $self->Type;
 666
 667     # forbid updating content when the (possibly new) value of Type is Perl
 668     if ($type eq 'Perl' && exists $args{NewValues}{Content}) {
 669         if (!$self->CurrentUser->HasRight(Right => 'ExecuteCode', Object => $RT::System)) {
 670             return $self->loc('Permission Denied');
 671         }
 672     }
 673
 674     return $self->SUPER::_UpdateAttributes(%args);
 675 }
 676
 677 =head2 CompileCheck
 678
 679 If the template's Type is Perl, then compile check all the codeblocks to see if
 680 they are syntactically valid. We eval them in a codeblock to avoid actually
 681 executing the code.
 682
 683 Returns an (ok, message) pair.
 684
 685 =cut
 686
 687 sub CompileCheck {
 688     my $self = shift;
 689
 690     return (1, $self->loc("Template does not include Perl code"))
 691         unless $self->Type eq 'Perl';
 692
 693     my $content = $self->Content;
 694     $content = '' if !defined($content);
 695
 696     my $template = Text::Template->new(
 697         TYPE   => 'STRING',
 698         SOURCE => $content,
 699     );
 700     my ($ok) = $template->compile;
 701     return ( undef, $self->loc('Template parsing error: [_1]', $Text::Template::ERROR) ) if !$ok;
 702
 703     # copied from Text::Template::fill_in and refactored to be compile checks
 704     foreach my $fi_item (@{$template->{SOURCE}}) {
 705         my ($fi_type, $fi_text, $fi_lineno) = @$fi_item;
 706         next unless $fi_type eq 'PROG';
 707
 708         do {
 709             no strict 'vars';
 710             eval "sub { $fi_text }";
 711         };
 712         next if !$@;
 713
 714         my $error = $@;
 715
 716         # provide a (hopefully) useful line number for the error, but clean up
 717         # all the other extraneous garbage
 718         $error =~ s/\(eval \d+\) line (\d+).*/"template line " . ($1+$fi_lineno-1)/es;
 719
 720         return (0, $self->loc("Couldn't compile template codeblock '[_1]': [_2]", $fi_text, $error));
 721     }
 722
 723     return (1, $self->loc("Template compiles"));
 724 }
 725
 726 =head2 CurrentUserCanRead
 727
 728 =cut
 729
 730 sub CurrentUserCanRead {
 731     my $self =shift;
 732
 733     return 1 if $self->CurrentUserHasQueueRight('ShowTemplate');
 734
 735     return $self->CurrentUser->HasRight( Right =>'ShowGlobalTemplates', Object => $RT::System )
 736         if !$self->QueueObj->Id;
 737
 738     return;
 739 }
 740
 741 1;
 742
 743 use RT::Queue;
 744 use base 'RT::Record';
 745
 746 sub Table {'Templates'}
 747
 748
 749
 750
 751
 752
 753 =head2 id
 754
 755 Returns the current value of id.
 756 (In the database, id is stored as int(11).)
 757
 758
 759 =cut
 760
 761
 762 =head2 Queue
 763
 764 Returns the current value of Queue.
 765 (In the database, Queue is stored as int(11).)
 766
 767
 768
 769 =head2 SetQueue VALUE
 770
 771
 772 Set Queue to VALUE.
 773 Returns (1, 'Status message') on success and (0, 'Error Message') on failure.
 774 (In the database, Queue will be stored as a int(11).)
 775
 776
 777 =cut
 778
 779
 780 =head2 QueueObj
 781
 782 Returns the Queue Object which has the id returned by Queue
 783
 784
 785 =cut
 786
 787 sub QueueObj {
 788         my $self = shift;
 789         my $Queue =  RT::Queue->new($self->CurrentUser);
 790         $Queue->Load($self->__Value('Queue'));
 791         return($Queue);
 792 }
 793
 794 =head2 Name
 795
 796 Returns the current value of Name.
 797 (In the database, Name is stored as varchar(200).)
 798
 799
 800
 801 =head2 SetName VALUE
 802
 803
 804 Set Name to VALUE.
 805 Returns (1, 'Status message') on success and (0, 'Error Message') on failure.
 806 (In the database, Name will be stored as a varchar(200).)
 807
 808
 809 =cut
 810
 811
 812 =head2 Description
 813
 814 Returns the current value of Description.
 815 (In the database, Description is stored as varchar(255).)
 816
 817
 818
 819 =head2 SetDescription VALUE
 820
 821
 822 Set Description to VALUE.
 823 Returns (1, 'Status message') on success and (0, 'Error Message') on failure.
 824 (In the database, Description will be stored as a varchar(255).)
 825
 826
 827 =cut
 828
 829
 830 =head2 Type
 831
 832 Returns the current value of Type.
 833 (In the database, Type is stored as varchar(16).)
 834
 835
 836
 837 =head2 SetType VALUE
 838
 839
 840 Set Type to VALUE.
 841 Returns (1, 'Status message') on success and (0, 'Error Message') on failure.
 842 (In the database, Type will be stored as a varchar(16).)
 843
 844
 845 =cut
 846
 847
 848 =head2 Language
 849
 850 Returns the current value of Language.
 851 (In the database, Language is stored as varchar(16).)
 852
 853
 854
 855 =head2 SetLanguage VALUE
 856
 857
 858 Set Language to VALUE.
 859 Returns (1, 'Status message') on success and (0, 'Error Message') on failure.
 860 (In the database, Language will be stored as a varchar(16).)
 861
 862
 863 =cut
 864
 865
 866 =head2 TranslationOf
 867
 868 Returns the current value of TranslationOf.
 869 (In the database, TranslationOf is stored as int(11).)
 870
 871
 872
 873 =head2 SetTranslationOf VALUE
 874
 875
 876 Set TranslationOf to VALUE.
 877 Returns (1, 'Status message') on success and (0, 'Error Message') on failure.
 878 (In the database, TranslationOf will be stored as a int(11).)
 879
 880
 881 =cut
 882
 883
 884 =head2 Content
 885
 886 Returns the current value of Content.
 887 (In the database, Content is stored as text.)
 888
 889
 890
 891 =head2 SetContent VALUE
 892
 893
 894 Set Content to VALUE.
 895 Returns (1, 'Status message') on success and (0, 'Error Message') on failure.
 896 (In the database, Content will be stored as a text.)
 897
 898
 899 =cut
 900
 901
 902 =head2 LastUpdated
 903
 904 Returns the current value of LastUpdated.
 905 (In the database, LastUpdated is stored as datetime.)
 906
 907
 908 =cut
 909
 910
 911 =head2 LastUpdatedBy
 912
 913 Returns the current value of LastUpdatedBy.
 914 (In the database, LastUpdatedBy is stored as int(11).)
 915
 916
 917 =cut
 918
 919
 920 =head2 Creator
 921
 922 Returns the current value of Creator.
 923 (In the database, Creator is stored as int(11).)
 924
 925
 926 =cut
 927
 928
 929 =head2 Created
 930
 931 Returns the current value of Created.
 932 (In the database, Created is stored as datetime.)
 933
 934
 935 =cut
 936
 937
 938
 939 sub _CoreAccessible {
 940     {
 941
 942         id =>
 943                 {read => 1, sql_type => 4, length => 11,  is_blob => 0,  is_numeric => 1,  type => 'int(11)', default => ''},
 944         Queue =>
 945                 {read => 1, write => 1, sql_type => 4, length => 11,  is_blob => 0,  is_numeric => 1,  type => 'int(11)', default => '0'},
 946         Name =>
 947                 {read => 1, write => 1, sql_type => 12, length => 200,  is_blob => 0,  is_numeric => 0,  type => 'varchar(200)', default => ''},
 948         Description =>
 949                 {read => 1, write => 1, sql_type => 12, length => 255,  is_blob => 0,  is_numeric => 0,  type => 'varchar(255)', default => ''},
 950         Type =>
 951                 {read => 1, write => 1, sql_type => 12, length => 16,  is_blob => 0,  is_numeric => 0,  type => 'varchar(16)', default => ''},
 952         Language =>
 953                 {read => 1, write => 1, sql_type => 12, length => 16,  is_blob => 0,  is_numeric => 0,  type => 'varchar(16)', default => ''},
 954         TranslationOf =>
 955                 {read => 1, write => 1, sql_type => 4, length => 11,  is_blob => 0,  is_numeric => 1,  type => 'int(11)', default => '0'},
 956         Content =>
 957                 {read => 1, write => 1, sql_type => -4, length => 0,  is_blob => 1,  is_numeric => 0,  type => 'text', default => ''},
 958         LastUpdated =>
 959                 {read => 1, auto => 1, sql_type => 11, length => 0,  is_blob => 0,  is_numeric => 0,  type => 'datetime', default => ''},
 960         LastUpdatedBy =>
 961                 {read => 1, auto => 1, sql_type => 4, length => 11,  is_blob => 0,  is_numeric => 1,  type => 'int(11)', default => '0'},
 962         Creator =>
 963                 {read => 1, auto => 1, sql_type => 4, length => 11,  is_blob => 0,  is_numeric => 1,  type => 'int(11)', default => '0'},
 964         Created =>
 965                 {read => 1, auto => 1, sql_type => 11, length => 0,  is_blob => 0,  is_numeric => 0,  type => 'datetime', default => ''},
 966
 967  }
 968 };
 969
 970 RT::Base->_ImportOverlays();
 971
 972 1;