Added LDAP-lookup for the forgotten password field.
[usit-rt.git] / lib / RT.pm
1 # BEGIN BPS TAGGED BLOCK {{{
2 #
3 # COPYRIGHT:
4 #
5 # This software is Copyright (c) 1996-2013 Best Practical Solutions, LLC
6 #                                          <sales@bestpractical.com>
7 #
8 # (Except where explicitly superseded by other copyright notices)
9 #
10 #
11 # LICENSE:
12 #
13 # This work is made available to you under the terms of Version 2 of
14 # the GNU General Public License. A copy of that license should have
15 # been provided with this software, but in any event can be snarfed
16 # from www.gnu.org.
17 #
18 # This work is distributed in the hope that it will be useful, but
19 # WITHOUT ANY WARRANTY; without even the implied warranty of
20 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21 # General Public License for more details.
22 #
23 # You should have received a copy of the GNU General Public License
24 # along with this program; if not, write to the Free Software
25 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
26 # 02110-1301 or visit their web page on the internet at
27 # http://www.gnu.org/licenses/old-licenses/gpl-2.0.html.
28 #
29 #
30 # CONTRIBUTION SUBMISSION POLICY:
31 #
32 # (The following paragraph is not intended to limit the rights granted
33 # to you to modify and distribute this software under the terms of
34 # the GNU General Public License and is only of importance to you if
35 # you choose to contribute your changes and enhancements to the
36 # community by submitting them to Best Practical Solutions, LLC.)
37 #
38 # By intentionally submitting any modifications, corrections or
39 # derivatives to this work, or any other work intended for use with
40 # Request Tracker, to Best Practical Solutions, LLC, you confirm that
41 # you are the copyright holder for those contributions and you grant
42 # Best Practical Solutions,  LLC a nonexclusive, worldwide, irrevocable,
43 # royalty-free, perpetual, license to use, copy, create derivative
44 # works based on those contributions, and sublicense and distribute
45 # those contributions and any derivatives thereof.
46 #
47 # END BPS TAGGED BLOCK }}}
48
49 use strict;
50 use warnings;
51
52 package RT;
53
54
55 use File::Spec ();
56 use Cwd ();
57
58 use vars qw($Config $System $SystemUser $Nobody $Handle $Logger $_Privileged $_Unprivileged $_INSTALL_MODE);
59
60 use vars qw($BasePath
61  $EtcPath
62  $BinPath
63  $SbinPath
64  $VarPath
65  $LexiconPath
66  $PluginPath
67  $LocalPath
68  $LocalEtcPath
69  $LocalLibPath
70  $LocalLexiconPath
71  $LocalPluginPath
72  $MasonComponentRoot
73  $MasonLocalComponentRoot
74  $MasonDataDir
75  $MasonSessionDir);
76
77
78 RT->LoadGeneratedData();
79
80 =head1 NAME
81
82 RT - Request Tracker
83
84 =head1 SYNOPSIS
85
86 A fully featured request tracker package
87
88 =head1 DESCRIPTION
89
90 =head2 INITIALIZATION
91
92 =head2 LoadConfig
93
94 Load RT's config file.  First, the site configuration file
95 (F<RT_SiteConfig.pm>) is loaded, in order to establish overall site
96 settings like hostname and name of RT instance.  Then, the core
97 configuration file (F<RT_Config.pm>) is loaded to set fallback values
98 for all settings; it bases some values on settings from the site
99 configuration file.
100
101 In order for the core configuration to not override the site's
102 settings, the function C<Set> is used; it only sets values if they
103 have not been set already.
104
105 =cut
106
107 sub LoadConfig {
108     require RT::Config;
109     $Config = RT::Config->new;
110     $Config->LoadConfigs;
111     require RT::I18N;
112
113     # RT::Essentials mistakenly recommends that WebPath be set to '/'.
114     # If the user does that, do what they mean.
115     $RT::WebPath = '' if ($RT::WebPath eq '/');
116
117     # fix relative LogDir and GnuPG homedir
118     unless ( File::Spec->file_name_is_absolute( $Config->Get('LogDir') ) ) {
119         $Config->Set( LogDir =>
120               File::Spec->catfile( $BasePath, $Config->Get('LogDir') ) );
121     }
122
123     my $gpgopts = $Config->Get('GnuPGOptions');
124     unless ( File::Spec->file_name_is_absolute( $gpgopts->{homedir} ) ) {
125         $gpgopts->{homedir} = File::Spec->catfile( $BasePath, $gpgopts->{homedir} );
126     }
127
128     return $Config;
129 }
130
131 =head2 Init
132
133 L<Connects to the database|/ConnectToDatabase>, L<initilizes system
134 objects|/InitSystemObjects>, L<preloads classes|/InitClasses>, L<sets
135 up logging|/InitLogging>, and L<loads plugins|/InitPlugins>.
136
137 =cut
138
139 sub Init {
140
141     CheckPerlRequirements();
142
143     InitPluginPaths();
144
145     #Get a database connection
146     ConnectToDatabase();
147     InitSystemObjects();
148     InitClasses();
149     InitLogging();
150     InitPlugins();
151     RT::I18N->Init;
152     RT->Config->PostLoadCheck;
153
154 }
155
156 =head2 ConnectToDatabase
157
158 Get a database connection. See also L</Handle>.
159
160 =cut
161
162 sub ConnectToDatabase {
163     require RT::Handle;
164     $Handle = RT::Handle->new unless $Handle;
165     $Handle->Connect;
166     return $Handle;
167 }
168
169 =head2 InitLogging
170
171 Create the Logger object and set up signal handlers.
172
173 =cut
174
175 sub InitLogging {
176
177     # We have to set the record separator ($, man perlvar)
178     # or Log::Dispatch starts getting
179     # really pissy, as some other module we use unsets it.
180     $, = '';
181     use Log::Dispatch 1.6;
182
183     my %level_to_num = (
184         map( { $_ => } 0..7 ),
185         debug     => 0,
186         info      => 1,
187         notice    => 2,
188         warning   => 3,
189         error     => 4, 'err' => 4,
190         critical  => 5, crit  => 5,
191         alert     => 6,
192         emergency => 7, emerg => 7,
193     );
194
195     unless ( $RT::Logger ) {
196
197         $RT::Logger = Log::Dispatch->new;
198
199         my $stack_from_level;
200         if ( $stack_from_level = RT->Config->Get('LogStackTraces') ) {
201             # if option has old style '\d'(true) value
202             $stack_from_level = 0 if $stack_from_level =~ /^\d+$/;
203             $stack_from_level = $level_to_num{ $stack_from_level } || 0;
204         } else {
205             $stack_from_level = 99; # don't log
206         }
207
208         my $simple_cb = sub {
209             # if this code throw any warning we can get segfault
210             no warnings;
211             my %p = @_;
212
213             # skip Log::* stack frames
214             my $frame = 0;
215             $frame++ while caller($frame) && caller($frame) =~ /^Log::/;
216             my ($package, $filename, $line) = caller($frame);
217
218             $p{'message'} =~ s/(?:\r*\n)+$//;
219             return "[". gmtime(time) ."] [". $p{'level'} ."]: "
220                 . $p{'message'} ." ($filename:$line)\n";
221         };
222
223         my $syslog_cb = sub {
224             # if this code throw any warning we can get segfault
225             no warnings;
226             my %p = @_;
227
228             my $frame = 0; # stack frame index
229             # skip Log::* stack frames
230             $frame++ while caller($frame) && caller($frame) =~ /^Log::/;
231             my ($package, $filename, $line) = caller($frame);
232
233             # syswrite() cannot take utf8; turn it off here.
234             Encode::_utf8_off($p{message});
235
236             $p{message} =~ s/(?:\r*\n)+$//;
237             if ($p{level} eq 'debug') {
238                 return "$p{message}\n";
239             } else {
240                 return "$p{message} ($filename:$line)\n";
241             }
242         };
243
244         my $stack_cb = sub {
245             no warnings;
246             my %p = @_;
247             return $p{'message'} unless $level_to_num{ $p{'level'} } >= $stack_from_level;
248
249             require Devel::StackTrace;
250             my $trace = Devel::StackTrace->new( ignore_class => [ 'Log::Dispatch', 'Log::Dispatch::Base' ] );
251             return $p{'message'} . $trace->as_string;
252
253             # skip calling of the Log::* subroutins
254             my $frame = 0;
255             $frame++ while caller($frame) && caller($frame) =~ /^Log::/;
256             $frame++ while caller($frame) && (caller($frame))[3] =~ /^Log::/;
257
258             $p{'message'} .= "\nStack trace:\n";
259             while( my ($package, $filename, $line, $sub) = caller($frame++) ) {
260                 $p{'message'} .= "\t$sub(...) called at $filename:$line\n";
261             }
262             return $p{'message'};
263         };
264
265         if ( $Config->Get('LogToFile') ) {
266             my ($filename, $logdir) = (
267                 $Config->Get('LogToFileNamed') || 'rt.log',
268                 $Config->Get('LogDir') || File::Spec->catdir( $VarPath, 'log' ),
269             );
270             if ( $filename =~ m![/\\]! ) { # looks like an absolute path.
271                 ($logdir) = $filename =~ m{^(.*[/\\])};
272             }
273             else {
274                 $filename = File::Spec->catfile( $logdir, $filename );
275             }
276
277             unless ( -d $logdir && ( ( -f $filename && -w $filename ) || -w $logdir ) ) {
278                 # localizing here would be hard when we don't have a current user yet
279                 die "Log file '$filename' couldn't be written or created.\n RT can't run.";
280             }
281
282             require Log::Dispatch::File;
283             $RT::Logger->add( Log::Dispatch::File->new
284                            ( name=>'file',
285                              min_level=> $Config->Get('LogToFile'),
286                              filename=> $filename,
287                              mode=>'append',
288                              callbacks => [ $simple_cb, $stack_cb ],
289                            ));
290         }
291         if ( $Config->Get('LogToScreen') ) {
292             require Log::Dispatch::Screen;
293             $RT::Logger->add( Log::Dispatch::Screen->new
294                          ( name => 'screen',
295                            min_level => $Config->Get('LogToScreen'),
296                            callbacks => [ $simple_cb, $stack_cb ],
297                            stderr => 1,
298                          ));
299         }
300         if ( $Config->Get('LogToSyslog') ) {
301             require Log::Dispatch::Syslog;
302             $RT::Logger->add(Log::Dispatch::Syslog->new
303                          ( name => 'syslog',
304                            ident => 'RT',
305                            min_level => $Config->Get('LogToSyslog'),
306                            callbacks => [ $syslog_cb, $stack_cb ],
307                            stderr => 1,
308                            $Config->Get('LogToSyslogConf'),
309                          ));
310         }
311     }
312     InitSignalHandlers();
313 }
314
315 {   # Work around bug in Log::Dispatch < 2.30, wherein the short forms
316     # of ->warn, ->err, and ->crit do not usefully propagate out, unlike
317     # ->warning, ->error, and ->critical
318     package Log::Dispatch;
319     no warnings 'redefine';
320     sub warn { shift->warning(@_) }
321     sub err  { shift->error(@_) }
322     sub crit { shift->critical(@_) }
323 }
324
325 sub InitSignalHandlers {
326
327 # Signal handlers
328 ## This is the default handling of warnings and die'ings in the code
329 ## (including other used modules - maybe except for errors catched by
330 ## Mason).  It will log all problems through the standard logging
331 ## mechanism (see above).
332
333     $SIG{__WARN__} = sub {
334         # The 'wide character' warnings has to be silenced for now, at least
335         # until HTML::Mason offers a sane way to process both raw output and
336         # unicode strings.
337         # use 'goto &foo' syntax to hide ANON sub from stack
338         if( index($_[0], 'Wide character in ') != 0 ) {
339             unshift @_, $RT::Logger, qw(level warning message);
340             goto &Log::Dispatch::log;
341         }
342         # Return value is used only by RT::Test to filter warnings from
343         # reaching the Test::NoWarnings catcher.  If Log::Dispatch::log() ever
344         # starts returning 'IGNORE', we'll need to switch to something more
345         # clever.  I don't expect that to happen.
346         return 'IGNORE';
347     };
348
349 #When we call die, trap it and log->crit with the value of the die.
350
351     $SIG{__DIE__}  = sub {
352         # if we are not in eval and perl is not parsing code
353         # then rollback transactions and log RT error
354         unless ($^S || !defined $^S ) {
355             $RT::Handle->Rollback(1) if $RT::Handle;
356             $RT::Logger->crit("$_[0]") if $RT::Logger;
357         }
358         die $_[0];
359     };
360 }
361
362
363 sub CheckPerlRequirements {
364     if ($^V < 5.008003) {
365         die sprintf "RT requires Perl v5.8.3 or newer.  Your current Perl is v%vd\n", $^V;
366     }
367
368     # use $error here so the following "die" can still affect the global $@
369     my $error;
370     {
371         local $@;
372         eval {
373             my $x = '';
374             my $y = \$x;
375             require Scalar::Util;
376             Scalar::Util::weaken($y);
377         };
378         $error = $@;
379     }
380
381     if ($error) {
382         die <<"EOF";
383
384 RT requires the Scalar::Util module be built with support for  the 'weaken'
385 function.
386
387 It is sometimes the case that operating system upgrades will replace
388 a working Scalar::Util with a non-working one. If your system was working
389 correctly up until now, this is likely the cause of the problem.
390
391 Please reinstall Scalar::Util, being careful to let it build with your C
392 compiler. Usually this is as simple as running the following command as
393 root.
394
395     perl -MCPAN -e'install Scalar::Util'
396
397 EOF
398
399     }
400 }
401
402 =head2 InitClasses
403
404 Load all modules that define base classes.
405
406 =cut
407
408 sub InitClasses {
409     shift if @_%2; # so we can call it as a function or method
410     my %args = (@_);
411     require RT::Tickets;
412     require RT::Transactions;
413     require RT::Attachments;
414     require RT::Users;
415     require RT::Principals;
416     require RT::CurrentUser;
417     require RT::Templates;
418     require RT::Queues;
419     require RT::ScripActions;
420     require RT::ScripConditions;
421     require RT::Scrips;
422     require RT::Groups;
423     require RT::GroupMembers;
424     require RT::CustomFields;
425     require RT::CustomFieldValues;
426     require RT::ObjectCustomFields;
427     require RT::ObjectCustomFieldValues;
428     require RT::Attributes;
429     require RT::Dashboard;
430     require RT::Approval;
431     require RT::Lifecycle;
432     require RT::Link;
433     require RT::Links;
434     require RT::Article;
435     require RT::Articles;
436     require RT::Class;
437     require RT::Classes;
438     require RT::ObjectClass;
439     require RT::ObjectClasses;
440     require RT::ObjectTopic;
441     require RT::ObjectTopics;
442     require RT::Topic;
443     require RT::Topics;
444
445     # on a cold server (just after restart) people could have an object
446     # in the session, as we deserialize it so we never call constructor
447     # of the class, so the list of accessible fields is empty and we die
448     # with "Method xxx is not implemented in RT::SomeClass"
449
450     # without this, we also can never call _ClassAccessible, because we
451     # won't have filled RT::Record::_TABLE_ATTR
452     $_->_BuildTableAttributes foreach qw(
453         RT::Ticket
454         RT::Transaction
455         RT::Attachment
456         RT::User
457         RT::Principal
458         RT::Template
459         RT::Queue
460         RT::ScripAction
461         RT::ScripCondition
462         RT::Scrip
463         RT::Group
464         RT::GroupMember
465         RT::CustomField
466         RT::CustomFieldValue
467         RT::ObjectCustomField
468         RT::ObjectCustomFieldValue
469         RT::Attribute
470         RT::ACE
471         RT::Link
472         RT::Article
473         RT::Class
474         RT::ObjectClass
475         RT::ObjectTopic
476         RT::Topic
477     );
478
479     if ( $args{'Heavy'} ) {
480         # load scrips' modules
481         my $scrips = RT::Scrips->new(RT->SystemUser);
482         $scrips->Limit( FIELD => 'Stage', OPERATOR => '!=', VALUE => 'Disabled' );
483         while ( my $scrip = $scrips->Next ) {
484             local $@;
485             eval { $scrip->LoadModules } or
486                 $RT::Logger->error("Invalid Scrip ".$scrip->Id.".  Unable to load the Action or Condition.  ".
487                                    "You should delete or repair this Scrip in the admin UI.\n$@\n");
488         }
489
490         foreach my $class ( grep $_, RT->Config->Get('CustomFieldValuesSources') ) {
491             local $@;
492             eval "require $class; 1" or $RT::Logger->error(
493                 "Class '$class' is listed in CustomFieldValuesSources option"
494                 ." in the config, but we failed to load it:\n$@\n"
495             );
496         }
497
498     }
499 }
500
501 =head2 InitSystemObjects
502
503 Initializes system objects: C<$RT::System>, C<< RT->SystemUser >>
504 and C<< RT->Nobody >>.
505
506 =cut
507
508 sub InitSystemObjects {
509
510     #RT's system user is a genuine database user. its id lives here
511     require RT::CurrentUser;
512     $SystemUser = RT::CurrentUser->new;
513     $SystemUser->LoadByName('RT_System');
514
515     #RT's "nobody user" is a genuine database user. its ID lives here.
516     $Nobody = RT::CurrentUser->new;
517     $Nobody->LoadByName('Nobody');
518
519     require RT::System;
520     $System = RT::System->new( $SystemUser );
521 }
522
523 =head1 CLASS METHODS
524
525 =head2 Config
526
527 Returns the current L<config object|RT::Config>, but note that
528 you must L<load config|/LoadConfig> first otherwise this method
529 returns undef.
530
531 Method can be called as class method.
532
533 =cut
534
535 sub Config { return $Config || shift->LoadConfig(); }
536
537 =head2 DatabaseHandle
538
539 Returns the current L<database handle object|RT::Handle>.
540
541 See also L</ConnectToDatabase>.
542
543 =cut
544
545 sub DatabaseHandle { return $Handle }
546
547 =head2 Logger
548
549 Returns the logger. See also L</InitLogging>.
550
551 =cut
552
553 sub Logger { return $Logger }
554
555 =head2 System
556
557 Returns the current L<system object|RT::System>. See also
558 L</InitSystemObjects>.
559
560 =cut
561
562 sub System { return $System }
563
564 =head2 SystemUser
565
566 Returns the system user's object, it's object of
567 L<RT::CurrentUser> class that represents the system. See also
568 L</InitSystemObjects>.
569
570 =cut
571
572 sub SystemUser { return $SystemUser }
573
574 =head2 Nobody
575
576 Returns object of Nobody. It's object of L<RT::CurrentUser> class
577 that represents a user who can own ticket and nothing else. See
578 also L</InitSystemObjects>.
579
580 =cut
581
582 sub Nobody { return $Nobody }
583
584 sub PrivilegedUsers {
585     if (!$_Privileged) {
586     $_Privileged = RT::Group->new(RT->SystemUser);
587     $_Privileged->LoadSystemInternalGroup('Privileged');
588     }
589     return $_Privileged;
590 }
591
592 sub UnprivilegedUsers {
593     if (!$_Unprivileged) {
594     $_Unprivileged = RT::Group->new(RT->SystemUser);
595     $_Unprivileged->LoadSystemInternalGroup('Unprivileged');
596     }
597     return $_Unprivileged;
598 }
599
600
601 =head2 Plugins
602
603 Returns a listref of all Plugins currently configured for this RT instance.
604 You can define plugins by adding them to the @Plugins list in your RT_SiteConfig
605
606 =cut
607
608 our @PLUGINS = ();
609 sub Plugins {
610     my $self = shift;
611     unless (@PLUGINS) {
612         $self->InitPluginPaths;
613         @PLUGINS = $self->InitPlugins;
614     }
615     return \@PLUGINS;
616 }
617
618 =head2 PluginDirs
619
620 Takes an optional subdir (e.g. po, lib, etc.) and returns a list of
621 directories from plugins where that subdirectory exists.
622
623 This code does not check plugin names, plugin validitity, or load
624 plugins (see L</InitPlugins>) in any way, and requires that RT's
625 configuration have been already loaded.
626
627 =cut
628
629 sub PluginDirs {
630     my $self = shift;
631     my $subdir = shift;
632
633     require RT::Plugin;
634
635     my @res;
636     foreach my $plugin (grep $_, RT->Config->Get('Plugins')) {
637         my $path = RT::Plugin->new( name => $plugin )->Path( $subdir );
638         next unless -d $path;
639         push @res, $path;
640     }
641     return @res;
642 }
643
644 =head2 InitPluginPaths
645
646 Push plugins' lib paths into @INC right after F<local/lib>.
647 In case F<local/lib> isn't in @INC, append them to @INC
648
649 =cut
650
651 sub InitPluginPaths {
652     my $self = shift || __PACKAGE__;
653
654     my @lib_dirs = $self->PluginDirs('lib');
655
656     my @tmp_inc;
657     my $added;
658     for (@INC) {
659         if ( Cwd::realpath($_) eq $RT::LocalLibPath) {
660             push @tmp_inc, $_, @lib_dirs;
661             $added = 1;
662         } else {
663             push @tmp_inc, $_;
664         }
665     }
666
667     # append @lib_dirs in case $RT::LocalLibPath isn't in @INC
668     push @tmp_inc, @lib_dirs unless $added;
669
670     my %seen;
671     @INC = grep !$seen{$_}++, @tmp_inc;
672 }
673
674 =head2 InitPlugins
675
676 Initialize all Plugins found in the RT configuration file, setting up
677 their lib and L<HTML::Mason> component roots.
678
679 =cut
680
681 sub InitPlugins {
682     my $self    = shift;
683     my @plugins;
684     require RT::Plugin;
685     foreach my $plugin (grep $_, RT->Config->Get('Plugins')) {
686         $plugin->require;
687         die $UNIVERSAL::require::ERROR if ($UNIVERSAL::require::ERROR);
688         push @plugins, RT::Plugin->new(name =>$plugin);
689     }
690     return @plugins;
691 }
692
693
694 sub InstallMode {
695     my $self = shift;
696     if (@_) {
697         my ($integrity, $state, $msg) = RT::Handle->CheckIntegrity;
698         if ($_[0] and $integrity) {
699             # Trying to turn install mode on but we have a good DB!
700             require Carp;
701             $RT::Logger->error(
702                 Carp::longmess("Something tried to turn on InstallMode but we have DB integrity!")
703             );
704         }
705         else {
706             $_INSTALL_MODE = shift;
707             if($_INSTALL_MODE) {
708                 require RT::CurrentUser;
709                $SystemUser = RT::CurrentUser->new();
710             }
711         }
712     }
713     return $_INSTALL_MODE;
714 }
715
716 sub LoadGeneratedData {
717     my $class = shift;
718     my $pm_path = ( File::Spec->splitpath( $INC{'RT.pm'} ) )[1];
719
720     require "$pm_path/RT/Generated.pm" || die "Couldn't load RT::Generated: $@";
721     $class->CanonicalizeGeneratedPaths();
722 }
723
724 sub CanonicalizeGeneratedPaths {
725     my $class = shift;
726     unless ( File::Spec->file_name_is_absolute($EtcPath) ) {
727
728    # if BasePath exists and is absolute, we won't infer it from $INC{'RT.pm'}.
729    # otherwise RT.pm will make the source dir(where we configure RT) be the
730    # BasePath instead of the one specified by --prefix
731         unless ( -d $BasePath
732                  && File::Spec->file_name_is_absolute($BasePath) )
733         {
734             my $pm_path = ( File::Spec->splitpath( $INC{'RT.pm'} ) )[1];
735
736      # need rel2abs here is to make sure path is absolute, since $INC{'RT.pm'}
737      # is not always absolute
738             $BasePath = File::Spec->rel2abs(
739                           File::Spec->catdir( $pm_path, File::Spec->updir ) );
740         }
741
742         $BasePath = Cwd::realpath($BasePath);
743
744         for my $path (
745                     qw/EtcPath BinPath SbinPath VarPath LocalPath LocalEtcPath
746                     LocalLibPath LexiconPath LocalLexiconPath PluginPath
747                     LocalPluginPath MasonComponentRoot MasonLocalComponentRoot
748                     MasonDataDir MasonSessionDir/
749                      )
750         {
751             no strict 'refs';
752
753             # just change relative ones
754             $$path = File::Spec->catfile( $BasePath, $$path )
755                 unless File::Spec->file_name_is_absolute($$path);
756         }
757     }
758
759 }
760
761 =head2 AddJavaScript
762
763 helper method to add js files to C<JSFiles> config.
764 to add extra js files, you can add the following line
765 in the plugin's main file:
766
767     RT->AddJavaScript( 'foo.js', 'bar.js' ); 
768
769 =cut
770
771 sub AddJavaScript {
772     my $self = shift;
773
774     my @old = RT->Config->Get('JSFiles');
775     RT->Config->Set( 'JSFiles', @old, @_ );
776     return RT->Config->Get('JSFiles');
777 }
778
779 =head2 AddStyleSheets
780
781 helper method to add css files to C<CSSFiles> config
782
783 to add extra css files, you can add the following line
784 in the plugin's main file:
785
786     RT->AddStyleSheets( 'foo.css', 'bar.css' ); 
787
788 =cut
789
790 sub AddStyleSheets {
791     my $self = shift;
792     my @old = RT->Config->Get('CSSFiles');
793     RT->Config->Set( 'CSSFiles', @old, @_ );
794     return RT->Config->Get('CSSFiles');
795 }
796
797 =head2 JavaScript
798
799 helper method of RT->Config->Get('JSFiles')
800
801 =cut
802
803 sub JavaScript {
804     return RT->Config->Get('JSFiles');
805 }
806
807 =head2 StyleSheets
808
809 helper method of RT->Config->Get('CSSFiles')
810
811 =cut
812
813 sub StyleSheets {
814     return RT->Config->Get('CSSFiles');
815 }
816
817 =head1 BUGS
818
819 Please report them to rt-bugs@bestpractical.com, if you know what's
820 broken and have at least some idea of what needs to be fixed.
821
822 If you're not sure what's going on, report them rt-devel@lists.bestpractical.com.
823
824 =head1 SEE ALSO
825
826 L<RT::StyleGuide>
827 L<DBIx::SearchBuilder>
828
829 =cut
830
831 require RT::Base;
832 RT::Base->_ImportOverlays();
833
834 1;