From 3ef62a0570055da710328937e7f65dbb2c027c62 Mon Sep 17 00:00:00 2001 From: ivan Date: Mon, 12 Aug 2002 06:17:09 +0000 Subject: import rt 2.0.14 --- rt/lib/RT/Interface/CLI.pm | 224 ++++++++ rt/lib/RT/Interface/Email.pm | 581 +++++++++++++++++++ rt/lib/RT/Interface/Web.pm | 1287 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 2092 insertions(+) create mode 100644 rt/lib/RT/Interface/CLI.pm create mode 100755 rt/lib/RT/Interface/Email.pm create mode 100644 rt/lib/RT/Interface/Web.pm (limited to 'rt/lib/RT/Interface') diff --git a/rt/lib/RT/Interface/CLI.pm b/rt/lib/RT/Interface/CLI.pm new file mode 100644 index 000000000..a3bf92d5f --- /dev/null +++ b/rt/lib/RT/Interface/CLI.pm @@ -0,0 +1,224 @@ +# $Header: /home/cvs/cvsroot/freeside/rt/lib/RT/Interface/CLI.pm,v 1.1 2002-08-12 06:17:08 ivan Exp $ +# RT is (c) 1996-2001 Jesse Vincent + +package RT::Interface::CLI; + +use strict; + + +BEGIN { + use Exporter (); + use vars qw ($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS); + + # set the version for version checking + $VERSION = do { my @r = (q$Revision: 1.1 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r }; # must be all one line, for MakeMaker + + @ISA = qw(Exporter); + + # your exported package globals go here, + # as well as any optionally exported functions + @EXPORT_OK = qw(&CleanEnv &LoadConfig &DBConnect + &GetCurrentUser &GetMessageContent &debug); +} + +=head1 NAME + + RT::Interface::CLI - helper functions for creating a commandline RT interface + +=head1 SYNOPSIS + + use lib "!!RT_LIB_PATH!!"; + use lib "!!RT_ETC_PATH!!"; + + use RT::Interface::CLI qw(CleanEnv LoadConfig DBConnect + GetCurrentUser GetMessageContent); + + #Clean out all the nasties from the environment + CleanEnv(); + + #Load etc/config.pm and drop privs + LoadConfig(); + + #Connect to the database and get RT::SystemUser and RT::Nobody loaded + DBConnect(); + + + #Get the current user all loaded + my $CurrentUser = GetCurrentUser(); + +=head1 DESCRIPTION + + +=head1 METHODS + +=begin testing + +ok(require RT::TestHarness); +ok(require RT::Interface::CLI); + +=end testing + +=cut + + +=head2 CleanEnv + +Removes some of the nastiest nasties from the user\'s environment. + +=cut + +sub CleanEnv { + $ENV{'PATH'} = '/bin:/usr/bin'; # or whatever you need + $ENV{'CDPATH'} = '' if defined $ENV{'CDPATH'}; + $ENV{'SHELL'} = '/bin/sh' if defined $ENV{'SHELL'}; + $ENV{'ENV'} = '' if defined $ENV{'ENV'}; + $ENV{'IFS'} = '' if defined $ENV{'IFS'}; +} + + + +=head2 LoadConfig + +Loads RT's config file and then drops setgid privileges. + +=cut + +sub LoadConfig { + + #This drags in RT's config.pm + use config; + +} + + + +=head2 DBConnect + + Calls RT::Init, which creates a database connection and then creates $RT::Nobody + and $RT::SystemUser + +=cut + + +sub DBConnect { + use RT; + RT::Init(); +} + + + +# {{{ sub GetCurrentUser + +=head2 GetCurrentUser + + Figures out the uid of the current user and returns an RT::CurrentUser object +loaded with that user. if the current user isn't found, returns a copy of RT::Nobody. + +=cut +sub GetCurrentUser { + + my ($Gecos, $CurrentUser); + + require RT::CurrentUser; + + #Instantiate a user object + + $Gecos=(getpwuid($<))[0]; + + #If the current user is 0, then RT will assume that the User object + #is that of the currentuser. + + $CurrentUser = new RT::CurrentUser(); + $CurrentUser->LoadByGecos($Gecos); + + unless ($CurrentUser->Id) { + $RT::Logger->debug("No user with a unix login of '$Gecos' was found. "); + } + return($CurrentUser); +} +# }}} + +# {{{ sub GetMessageContent + +=head2 GetMessageContent + +Takes two arguments a source file and a boolean "edit". If the source file +is undef or "", assumes an empty file. Returns an edited file as an +array of lines. + +=cut + +sub GetMessageContent { + my %args = ( Source => undef, + Content => undef, + Edit => undef, + CurrentUser => undef, + @_); + my $source = $args{'Source'}; + + my $edit = $args{'Edit'}; + + my $currentuser = $args{'CurrentUser'}; + my @lines; + + use File::Temp qw/ tempfile/; + + #Load the sourcefile, if it's been handed to us + if ($source) { + open (SOURCE, "<$source"); + @lines = (); + close (SOURCE); + } + elsif ($args{'Content'}) { + @lines = split('\n',$args{'Content'}); + } + #get us a tempfile. + my ($fh, $filename) = tempfile(); + + #write to a tmpfile + for (@lines) { + print $fh $_; + } + close ($fh); + + #Edit the file if we need to + if ($edit) { + + unless ($ENV{'EDITOR'}) { + $RT::Logger->crit('No $EDITOR variable defined'. "\n"); + return undef; + } + system ($ENV{'EDITOR'}, $filename); + } + + open (READ, "<$filename"); + my @newlines = (); + close (READ); + + unlink ($filename) unless (debug()); + return(\@newlines); + +} + +# }}} + +# {{{ sub debug + +sub debug { + my $val = shift; + my ($debug); + if ($val) { + $RT::Logger->debug($val."\n"); + if ($debug) { + print STDERR "$val\n"; + } + } + if ($debug) { + return(1); + } +} + +# }}} + + +1; diff --git a/rt/lib/RT/Interface/Email.pm b/rt/lib/RT/Interface/Email.pm new file mode 100755 index 000000000..e95436091 --- /dev/null +++ b/rt/lib/RT/Interface/Email.pm @@ -0,0 +1,581 @@ +# $Header: /home/cvs/cvsroot/freeside/rt/lib/RT/Interface/Email.pm,v 1.1 2002-08-12 06:17:08 ivan Exp $ +# RT is (c) 1996-2001 Jesse Vincent + +package RT::Interface::Email; + +use strict; +use Mail::Address; +use MIME::Entity; + +BEGIN { + use Exporter (); + use vars qw ($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS); + + # set the version for version checking + $VERSION = do { my @r = (q$Revision: 1.1 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r }; # must be all one line, for MakeMaker + + @ISA = qw(Exporter); + + # your exported package globals go here, + # as well as any optionally exported functions + @EXPORT_OK = qw(&CleanEnv + &LoadConfig + &DBConnect + &GetCurrentUser + &GetMessageContent + &CheckForLoops + &CheckForSuspiciousSender + &CheckForAutoGenerated + &ParseMIMEEntityFromSTDIN + &ParseTicketId + &MailError + &ParseCcAddressesFromHead + &ParseSenderAddressFromHead + &ParseErrorsToAddressFromHead + &ParseAddressFromHeader + + + &debug); +} + +=head1 NAME + + RT::Interface::CLI - helper functions for creating a commandline RT interface + +=head1 SYNOPSIS + + use lib "!!RT_LIB_PATH!!"; + use lib "!!RT_ETC_PATH!!"; + + use RT::Interface::Email qw(CleanEnv LoadConfig DBConnect + ); + + #Clean out all the nasties from the environment + CleanEnv(); + + #Load etc/config.pm and drop privs + LoadConfig(); + + #Connect to the database and get RT::SystemUser and RT::Nobody loaded + DBConnect(); + + + #Get the current user all loaded + my $CurrentUser = GetCurrentUser(); + +=head1 DESCRIPTION + + +=begin testing + +ok(require RT::TestHarness); +ok(require RT::Interface::Email); + +=end testing + + +=head1 METHODS + +=cut + + +=head2 CleanEnv + +Removes some of the nastiest nasties from the user\'s environment. + +=cut + +sub CleanEnv { + $ENV{'PATH'} = '/bin:/usr/bin'; # or whatever you need + $ENV{'CDPATH'} = '' if defined $ENV{'CDPATH'}; + $ENV{'SHELL'} = '/bin/sh' if defined $ENV{'SHELL'}; + $ENV{'ENV'} = '' if defined $ENV{'ENV'}; + $ENV{'IFS'} = '' if defined $ENV{'IFS'}; +} + + + +=head2 LoadConfig + +Loads RT's config file and then drops setgid privileges. + +=cut + +sub LoadConfig { + + #This drags in RT's config.pm + use config; + +} + + + +=head2 DBConnect + + Calls RT::Init, which creates a database connection and then creates $RT::Nobody + and $RT::SystemUser + +=cut + + +sub DBConnect { + use RT; + RT::Init(); +} + + + +# {{{ sub debug + +sub debug { + my $val = shift; + my ($debug); + if ($val) { + $RT::Logger->debug($val."\n"); + if ($debug) { + print STDERR "$val\n"; + } + } + if ($debug) { + return(1); + } +} + +# }}} + + +# {{{ sub CheckForLoops + +sub CheckForLoops { + my $head = shift; + + #If this instance of RT sent it our, we don't want to take it in + my $RTLoop = $head->get("X-RT-Loop-Prevention") || ""; + chomp ($RTLoop); #remove that newline + if ($RTLoop eq "$RT::rtname") { + return (1); + } + + # TODO: We might not trap the case where RT instance A sends a mail + # to RT instance B which sends a mail to ... + return (undef); +} + +# }}} + +# {{{ sub CheckForSuspiciousSender + +sub CheckForSuspiciousSender { + my $head = shift; + + #if it's from a postmaster or mailer daemon, it's likely a bounce. + + #TODO: better algorithms needed here - there is no standards for + #bounces, so it's very difficult to separate them from anything + #else. At the other hand, the Return-To address is only ment to be + #used as an error channel, we might want to put up a separate + #Return-To address which is treated differently. + + #TODO: search through the whole email and find the right Ticket ID. + + my ($From, $junk) = ParseSenderAddressFromHead($head); + + if (($From =~ /^mailer-daemon/i) or + ($From =~ /^postmaster/i)){ + return (1); + + } + + return (undef); + +} + +# }}} + +# {{{ sub CheckForAutoGenerated +sub CheckForAutoGenerated { + my $head = shift; + + my $Precedence = $head->get("Precedence") || "" ; + if ($Precedence =~ /^(bulk|junk)/i) { + return (1); + } + else { + return (0); + } +} + +# }}} + +# {{{ sub ParseMIMEEntityFromSTDIN + +sub ParseMIMEEntityFromSTDIN { + + # Create a new parser object: + + my $parser = new MIME::Parser; + + # {{{ Config $parser to store large attacments in temp dir + + ## TODO: Does it make sense storing to disk at all? After all, we + ## need to put each msg as an in-core scalar before saving it to + ## the database, don't we? + + ## At the same time, we should make sure that we nuke attachments + ## Over max size and return them + + ## TODO: Remove the temp dir when we don't need it any more. + + my $AttachmentDir = File::Temp::tempdir (TMPDIR => 1, CLEANUP => 1); + + # Set up output directory for files: + $parser->output_dir("$AttachmentDir"); + + #If someone includes a message, don't extract it + $parser->extract_nested_messages(0); + + + # Set up the prefix for files with auto-generated names: + $parser->output_prefix("part"); + + # If content length is <= 20000 bytes, store each msg as in-core scalar; + # Else, write to a disk file (the default action): + + $parser->output_to_core(20000); + + # }}} (temporary directory) + + #Ok. now that we're set up, let's get the stdin. + my $entity; + unless ($entity = $parser->read(\*STDIN)) { + die "couldn't parse MIME stream"; + } + #Now we've got a parsed mime object. + + # Get the head, a MIME::Head: + my $head = $entity->head; + + + # Unfold headers that are have embedded newlines + $head->unfold; + + # TODO - information about the charset is lost here! + $head->decode; + + return ($entity, $head); + +} +# }}} + +# {{{ sub ParseTicketId + +sub ParseTicketId { + my $Subject = shift; + my ($Id); + + if ($Subject =~ s/\[$RT::rtname \#(\d+)\]//i) { + $Id = $1; + $RT::Logger->debug("Found a ticket ID. It's $Id"); + return($Id); + } + else { + return(undef); + } +} +# }}} + +# {{{ sub MailError +sub MailError { + my %args = (To => $RT::OwnerEmail, + Bcc => undef, + From => $RT::CorrespondAddress, + Subject => 'There has been an error', + Explanation => 'Unexplained error', + MIMEObj => undef, + LogLevel => 'crit', + @_); + + + $RT::Logger->log(level => $args{'LogLevel'}, + message => $args{'Explanation'} + ); + my $entity = MIME::Entity->build( Type =>"multipart/mixed", + From => $args{'From'}, + Bcc => $args{'Bcc'}, + To => $args{'To'}, + Subject => $args{'Subject'}, + 'X-RT-Loop-Prevention' => $RT::rtname, + ); + + $entity->attach( Data => $args{'Explanation'}."\n"); + + my $mimeobj = $args{'MIMEObj'}; + if ($mimeobj) { + $mimeobj->sync_headers(); + $entity->add_part($mimeobj); + } + + if ($RT::MailCommand eq 'sendmailpipe') { + open (MAIL, "|$RT::SendmailPath $RT::SendmailArguments") || return(0); + print MAIL $entity->as_string; + close(MAIL); + } + else { + $entity->send($RT::MailCommand, $RT::MailParams); + } +} + +# }}} + +# {{{ sub GetCurrentUser + +sub GetCurrentUser { + my $head = shift; + my $entity = shift; + my $ErrorsTo = shift; + + my %UserInfo = (); + + #Suck the address of the sender out of the header + my ($Address, $Name) = ParseSenderAddressFromHead($head); + + #This will apply local address canonicalization rules + $Address = RT::CanonicalizeAddress($Address); + + #If desired, synchronize with an external database + + my $UserFoundInExternalDatabase = 0; + + # Username is the 'Name' attribute of the user that RT uses for things + # like authentication + my $Username = undef; + if ($RT::LookupSenderInExternalDatabase) { + ($UserFoundInExternalDatabase, %UserInfo) = + RT::LookupExternalUserInfo($Address, $Name); + + $Address = $UserInfo{'EmailAddress'}; + $Username = $UserInfo{'Name'}; + } + + my $CurrentUser = RT::CurrentUser->new(); + + # First try looking up by a username, if we got one from the external + # db lookup. Next, try looking up by email address. Failing that, + # try looking up by users who have this user's email address as their + # username. + + if ($Username) { + $CurrentUser->LoadByName($Username); + } + + unless ($CurrentUser->Id) { + $CurrentUser->LoadByEmail($Address); + } + + #If we can't get it by email address, try by name. + unless ($CurrentUser->Id) { + $CurrentUser->LoadByName($Address); + } + + + unless ($CurrentUser->Id) { + #If we couldn't load a user, determine whether to create a user + + # {{{ If we require an incoming address to be found in the external + # user database, reject the incoming message appropriately + if ( $RT::LookupSenderInExternalDatabase && + $RT::SenderMustExistInExternalDatabase && + !$UserFoundInExternalDatabase) { + + my $Message = "Sender's email address was not found in the user database."; + + # {{{ This code useful only if you've defined an AutoRejectRequest template + + require RT::Template; + my $template = new RT::Template($RT::Nobody); + $template->Load('AutoRejectRequest'); + $Message = $template->Content || $Message; + + # }}} + + MailError( To => $ErrorsTo, + Subject => "Ticket Creation failed: user could not be created", + Explanation => $Message, + MIMEObj => $entity, + LogLevel => 'notice' + ); + + return($CurrentUser); + + } + # }}} + + else { + my $NewUser = RT::User->new($RT::SystemUser); + + my ($Val, $Message) = + $NewUser->Create(Name => ($Username || $Address), + EmailAddress => $Address, + RealName => "$Name", + Password => undef, + Privileged => 0, + Comments => 'Autocreated on ticket submission' + ); + + unless ($Val) { + + # Deal with the race condition of two account creations at once + # + if ($Username) { + $NewUser->LoadByName($Username); + } + + unless ($NewUser->Id) { + $NewUser->LoadByEmail($Address); + } + + unless ($NewUser->Id) { + MailError( To => $ErrorsTo, + Subject => "User could not be created", + Explanation => "User creation failed in mailgateway: $Message", + MIMEObj => $entity, + LogLevel => 'crit' + ); + } + } + } + + #Load the new user object + $CurrentUser->LoadByEmail($Address); + + unless ($CurrentUser->id) { + $RT::Logger->warning("Couldn't load user '$Address'.". "giving up"); + MailError( To => $ErrorsTo, + Subject => "User could not be loaded", + Explanation => "User '$Address' could not be loaded in the mail gateway", + MIMEObj => $entity, + LogLevel => 'crit' + ); + + } + } + + return ($CurrentUser); + +} +# }}} + +# {{{ ParseCcAddressesFromHead + +=head2 ParseCcAddressesFromHead HASHREF + +Takes a hashref object containing QueueObj, Head and CurrentUser objects. +Returns a list of all email addresses in the To and Cc +headers b the current Queue\'s email addresses, the CurrentUser\'s +email address and anything that the configuration sub RT::IsRTAddress matches. + +=cut + +sub ParseCcAddressesFromHead { + my %args = ( Head => undef, + QueueObj => undef, + CurrentUser => undef, + @_ ); + + my (@Addresses); + + my @ToObjs = Mail::Address->parse($args{'Head'}->get('To')); + my @CcObjs = Mail::Address->parse($args{'Head'}->get('Cc')); + + foreach my $AddrObj (@ToObjs, @CcObjs) { + my $Address = $AddrObj->address; + $Address = RT::CanonicalizeAddress($Address); + next if ($args{'CurrentUser'}->EmailAddress =~ /^$Address$/i); + next if ($args{'QueueObj'}->CorrespondAddress =~ /^$Address$/i); + next if ($args{'QueueObj'}->CommentAddress =~ /^$Address$/i); + next if (RT::IsRTAddress($Address)); + + push (@Addresses, $Address); + } + return (@Addresses); +} + + +# }}} + +# {{{ ParseSenderAdddressFromHead + +=head2 ParseSenderAddressFromHead + +Takes a MIME::Header object. Returns a tuple: (user@host, friendly name) +of the From (evaluated in order of Reply-To:, From:, Sender) + +=cut + +sub ParseSenderAddressFromHead { + my $head = shift; + #Figure out who's sending this message. + my $From = $head->get('Reply-To') || + $head->get('From') || + $head->get('Sender'); + return (ParseAddressFromHeader($From)); +} +# }}} + +# {{{ ParseErrorsToAdddressFromHead + +=head2 ParseErrorsToAddressFromHead + +Takes a MIME::Header object. Return a single value : user@host +of the From (evaluated in order of Errors-To:,Reply-To:, From:, Sender) + +=cut + +sub ParseErrorsToAddressFromHead { + my $head = shift; + #Figure out who's sending this message. + + foreach my $header ('Errors-To' , 'Reply-To', 'From', 'Sender' ) { + # If there's a header of that name + my $headerobj = $head->get($header); + if ($headerobj) { + my ($addr, $name ) = ParseAddressFromHeader($headerobj); + # If it's got actual useful content... + return ($addr) if ($addr); + } + } +} +# }}} + +# {{{ ParseAddressFromHeader + +=head2 ParseAddressFromHeader ADDRESS + +Takes an address from $head->get('Line') and returns a tuple: user@host, friendly name + +=cut + + +sub ParseAddressFromHeader{ + my $Addr = shift; + + my @Addresses = Mail::Address->parse($Addr); + + my $AddrObj = $Addresses[0]; + + unless (ref($AddrObj)) { + return(undef,undef); + } + + my $Name = ($AddrObj->phrase || $AddrObj->comment || $AddrObj->address); + + + #Lets take the from and load a user object. + my $Address = $AddrObj->address; + + return ($Address, $Name); +} +# }}} + + +1; diff --git a/rt/lib/RT/Interface/Web.pm b/rt/lib/RT/Interface/Web.pm new file mode 100644 index 000000000..6b5272848 --- /dev/null +++ b/rt/lib/RT/Interface/Web.pm @@ -0,0 +1,1287 @@ +## $Header: /home/cvs/cvsroot/freeside/rt/lib/RT/Interface/Web.pm,v 1.1 2002-08-12 06:17:08 ivan Exp $ + +## Portions Copyright 2000 Tobias Brox +## Copyright 1996-2002 Jesse Vincent + +## This is a library of static subs to be used by the Mason web +## interface to RT + +package RT::Interface::Web; + +# {{{ sub NewParser + +=head2 NewParser + + Returns a new Mason::Parser object. Takes a param hash of things + that get passed to HTML::Mason::Parser. Currently hard coded to only + take the parameter 'allow_globals'. + +=cut + +sub NewParser { + my %args = ( + allow_globals => undef, + @_ + ); + + my $parser = new HTML::Mason::Parser( + default_escape_flags => 'h', + allow_globals => $args{'allow_globals'} + ); + return ($parser); +} + +# }}} + +# {{{ sub NewInterp + +=head2 NewInterp + + Takes a paremeter hash. Needs a param called 'parser' which is a reference + to an HTML::Mason::Parser. + returns a new Mason::Interp object + +=cut + +sub NewInterp { + my %params = ( + comp_root => [ + [ local => $RT::MasonLocalComponentRoot ], + [ standard => $RT::MasonComponentRoot ] + ], + data_dir => "$RT::MasonDataDir", + @_ + ); + + #We allow recursive autohandlers to allow for RT auth. + + use HTML::Mason::Interp; + my $interp = new HTML::Mason::Interp(%params); + +} + +# }}} + +# {{{ sub NewApacheHandler + +=head2 NewApacheHandler + + Takes a Mason::Interp object + Returns a new Mason::ApacheHandler object + +=cut + +sub NewApacheHandler { + my $interp = shift; + my $ah = new HTML::Mason::ApacheHandler( interp => $interp ); + return ($ah); +} + +# }}} + + +# {{{ sub NewMason11ApacheHandler + +=head2 NewMason11ApacheHandler + + Returns a new Mason::ApacheHandler object + +=cut + +sub NewMason11ApacheHandler { + my %args = ( default_escape_flags => 'h', + allow_globals => [%session], + comp_root => [ + [ local => $RT::MasonLocalComponentRoot ], + [ standard => $RT::MasonComponentRoot ] + ], + data_dir => "$RT::MasonDataDir", + args_method => 'CGI' + ); + my $ah = new HTML::Mason::ApacheHandler(%args); + return ($ah); +} + +# }}} + + + + + +# }}} + +package HTML::Mason::Commands; + +# {{{ sub Abort +# Error - calls Error and aborts +sub Abort { + + if ( $session{'ErrorDocument'} && $session{'ErrorDocumentType'} ) { + SetContentType( $session{'ErrorDocumentType'} ); + $m->comp( $session{'ErrorDocument'}, Why => shift ); + $m->abort; + } + else { + SetContentType('text/html'); + $m->comp( "/Elements/Error", Why => shift ); + $m->abort; + } +} + +# }}} + +# {{{ sub CreateTicket + +=head2 CreateTicket ARGS + +Create a new ticket, using Mason's %ARGS. returns @results. +=cut + +sub CreateTicket { + my %ARGS = (@_); + + my (@Actions); + + my $Ticket = new RT::Ticket( $session{'CurrentUser'} ); + + my $Queue = new RT::Queue( $session{'CurrentUser'} ); + unless ( $Queue->Load( $ARGS{'Queue'} ) ) { + Abort('Queue not found'); + } + + unless ( $Queue->CurrentUserHasRight('CreateTicket') ) { + Abort('You have no permission to create tickets in that queue.'); + } + + my $due = new RT::Date( $session{'CurrentUser'} ); + $due->Set( Format => 'unknown', Value => $ARGS{'Due'} ); + my $starts = new RT::Date( $session{'CurrentUser'} ); + $starts->Set( Format => 'unknown', Value => $ARGS{'Starts'} ); + + my @Requestors = split ( /,/, $ARGS{'Requestors'} ); + my @Cc = split ( /,/, $ARGS{'Cc'} ); + my @AdminCc = split ( /,/, $ARGS{'AdminCc'} ); + + my $MIMEObj = MakeMIMEEntity( + Subject => $ARGS{'Subject'}, + From => $ARGS{'From'}, + Cc => $ARGS{'Cc'}, + Body => $ARGS{'Content'}, + AttachmentFieldName => 'Attach' + ); + + my %create_args = ( + Queue => $ARGS{Queue}, + Owner => $ARGS{Owner}, + InitialPriority => $ARGS{InitialPriority}, + FinalPriority => $ARGS{FinalPriority}, + TimeLeft => $ARGS{TimeLeft}, + TimeWorked => $ARGS{TimeWorked}, + Requestor => \@Requestors, + Cc => \@Cc, + AdminCc => \@AdminCc, + Subject => $ARGS{Subject}, + Status => $ARGS{Status}, + Due => $due->ISO, + Starts => $starts->ISO, + MIMEObj => $MIMEObj + ); + + # we need to get any KeywordSelect- fields into %create_args.. + grep { $_ =~ /^KeywordSelect-/ &&{ $create_args{$_} = $ARGS{$_} } } %ARGS; + + my ( $id, $Trans, $ErrMsg ) = $Ticket->Create(%create_args); + unless ( $id && $Trans ) { + Abort($ErrMsg); + } + my @linktypes = qw( DependsOn MemberOf RefersTo ); + + foreach my $linktype (@linktypes) { + foreach my $luri ( split ( / /, $ARGS{"new-$linktype"} ) ) { + $luri =~ s/\s*$//; # Strip trailing whitespace + my ( $val, $msg ) = $Ticket->AddLink( + Target => $luri, + Type => $linktype + ); + push ( @Actions, $msg ) unless ($val); + } + + foreach my $luri ( split ( / /, $ARGS{"$linktype-new"} ) ) { + my ( $val, $msg ) = $Ticket->AddLink( + Base => $luri, + Type => $linktype + ); + + push ( @Actions, $msg ) unless ($val); + } + } + + push ( @Actions, $ErrMsg ); + unless ( $Ticket->CurrentUserHasRight('ShowTicket') ) { + Abort( "No permission to view newly created ticket #" + . $Ticket->id . "." ); + } + return ( $Ticket, @Actions ); + +} + +# }}} + +# {{{ sub LoadTicket - loads a ticket + +=head2 LoadTicket id + +Takes a ticket id as its only variable. if it's handed an array, it takes +the first value. + +Returns an RT::Ticket object as the current user. + +=cut + +sub LoadTicket { + my $id = shift; + + if ( ref($id) eq "ARRAY" ) { + $id = $id->[0]; + } + + unless ($id) { + Abort("No ticket specified"); + } + + my $Ticket = RT::Ticket->new( $session{'CurrentUser'} ); + $Ticket->Load($id); + unless ( $Ticket->id ) { + Abort("Could not load ticket $id"); + } + return $Ticket; +} + +# }}} + +# {{{ sub ProcessUpdateMessage + +sub ProcessUpdateMessage { + + #TODO document what else this takes. + my %args = ( + ARGSRef => undef, + Actions => undef, + TicketObj => undef, + @_ + ); + + #Make the update content have no 'weird' newlines in it + if ( $args{ARGSRef}->{'UpdateContent'} ) { + + if ( + $args{ARGSRef}->{'UpdateSubject'} eq $args{'TicketObj'}->Subject() ) + { + $args{ARGSRef}->{'UpdateSubject'} = undef; + } + + my $Message = MakeMIMEEntity( + Subject => $args{ARGSRef}->{'UpdateSubject'}, + Body => $args{ARGSRef}->{'UpdateContent'}, + AttachmentFieldName => 'UpdateAttachment' + ); + + ## Check whether this was a refresh or not. + + # Match Correspondence or Comments. + my $trans_flag = -2; + my $trans_type = undef; + my $orig_trans = $args{ARGSRef}->{'UpdateType'}; + if ( $orig_trans =~ /^(private|public)$/ ) { + $trans_type = "Comment"; + }elsif ( $orig_trans eq 'response' ) { + $trans_type = "Correspond"; + } + + # Do we have a transaction that we need to update on? session + if( defined( $trans_type ) ){ + $trans_flag = 0; + + # Prepare a checksum. + # See perldoc -f unpack for example of this. + my $this_checksum = unpack("%32C*", $Message->body_as_string ) % 65535; + + # The above *could* generate duplicate checksums. Crosscheck with + # the length. + my $this_length = length( $Message->body_as_string ); + + # Don't forget the ticket id. + my $this_id = $args{TicketObj}->id; + + # Check whether the previous transaction in the + # ticket is the same as the current transaction. + if( defined( $session{'prev_trans_type'} ) && defined( $session{'prev_trans_chksum'} ) && defined( $session{'prev_trans_length'} ) && defined( $session{'prev_trans_tickid'} ) ){ + if( $session{'prev_trans_type'} eq $orig_trans && $session{'prev_trans_chksum'} == $this_checksum && $session{'prev_trans_length'} == $this_length && $session{'prev_trans_tickid'} == $this_id ){ + # Its the same as the previous transaction for this user. + $trans_flag = -1; + } + } + + # Store them for next time. + $session{'prev_trans_type'} = $orig_trans; + $session{'prev_trans_chksum'} = $this_checksum; + $session{'prev_trans_length'} = $this_length; + $session{'prev_trans_tickid'} = $this_id; + + if( $trans_flag == -1 ){ + push ( @{ $args{'Actions'} }, +"This appears to be a duplicate of your previous update (please do not refresh this page)" ); + } + + + if ( $trans_type eq 'Comment' && $trans_flag >= 0 ) { + my ( $Transaction, $Description ) = $args{TicketObj}->Comment( + CcMessageTo => $args{ARGSRef}->{'UpdateCc'}, + BccMessageTo => $args{ARGSRef}->{'UpdateBcc'}, + MIMEObj => $Message, + TimeTaken => $args{ARGSRef}->{'UpdateTimeWorked'} + ); + push ( @{ $args{Actions} }, $Description ); + } + elsif ( $trans_type eq 'Correspond' && $trans_flag >= 0 ) { + my ( $Transaction, $Description ) = $args{TicketObj}->Correspond( + CcMessageTo => $args{ARGSRef}->{'UpdateCc'}, + BccMessageTo => $args{ARGSRef}->{'UpdateBcc'}, + MIMEObj => $Message, + TimeTaken => $args{ARGSRef}->{'UpdateTimeWorked'} + ); + push ( @{ $args{Actions} }, $Description ); + } + } + else { + push ( @{ $args{'Actions'} }, + "Update type was neither correspondence nor comment. Update not recorded" + ); + } + } +} + +# }}} + +# {{{ sub MakeMIMEEntity + +=head2 MakeMIMEEntity PARAMHASH + +Takes a paramhash Subject, Body and AttachmentFieldName. + + Returns a MIME::Entity. + +=cut + +sub MakeMIMEEntity { + + #TODO document what else this takes. + my %args = ( + Subject => undef, + From => undef, + Cc => undef, + Body => undef, + AttachmentFieldName => undef, + @_ + ); + + #Make the update content have no 'weird' newlines in it + + $args{'Body'} =~ s/\r\n/\n/gs; + my $Message = MIME::Entity->build( + Subject => $args{'Subject'} || "", + From => $args{'From'}, + Cc => $args{'Cc'}, + Data => [ $args{'Body'} ] + ); + + my $cgi_object = CGIObject(); + if ( $cgi_object->param( $args{'AttachmentFieldName'} ) ) { + + my $cgi_filehandle = + $cgi_object->upload( $args{'AttachmentFieldName'} ); + + use File::Temp qw(tempfile tempdir); + + #foreach my $filehandle (@filenames) { + + # my ( $fh, $temp_file ) = tempfile(); + + #$binmode $fh; #thank you, windows + + # We're having trouble with tempfiles not getting created. Let's try it with + # a scalar instead + + my ( $buffer, @file ); + + while ( my $bytesread = read( $cgi_filehandle, $buffer, 4096 ) ) { + push ( @file, $buffer ); + } + + $RT::Logger->debug($file); + my $filename = "$cgi_filehandle"; + $filename =~ s#^(.*)/##; + $filename =~ s#^(.*)\\##; + my $uploadinfo = $cgi_object->uploadInfo($cgi_filehandle); + $Message->attach( + Data => \@file, + + #Path => $temp_file, + Filename => $filename, + Type => $uploadinfo->{'Content-Type'} + ); + + #close($fh); + #unlink($temp_file); + + # } + } + $Message->make_singlepart(); + return ($Message); + +} + +# }}} + +# {{{ sub ProcessSearchQuery + +=head2 ProcessSearchQuery + + Takes a form such as the one filled out in webrt/Search/Elements/PickRestriction and turns it into something that RT::Tickets can understand. + +TODO Doc exactly what comes in the paramhash + + +=cut + +sub ProcessSearchQuery { + my %args = @_; + + ## TODO: The only parameter here is %ARGS. Maybe it would be + ## cleaner to load this parameter as $ARGS, and use $ARGS->{...} + ## instead of $args{ARGS}->{...} ? :) + + #Searches are sticky. + if ( defined $session{'tickets'} ) { + + # Reset the old search + $session{'tickets'}->GotoFirstItem; + } + else { + + # Init a new search + $session{'tickets'} = RT::Tickets->new( $session{'CurrentUser'} ); + } + + #Import a bookmarked search if we have one + if ( defined $args{ARGS}->{'Bookmark'} ) { + $session{'tickets'}->ThawLimits( $args{ARGS}->{'Bookmark'} ); + } + + # {{{ Goto next/prev page + if ( $args{ARGS}->{'GotoPage'} eq 'Next' ) { + $session{'tickets'}->NextPage; + } + elsif ( $args{ARGS}->{'GotoPage'} eq 'Prev' ) { + $session{'tickets'}->PrevPage; + } + + # }}} + + # {{{ Deal with limiting the search + + if ( $args{ARGS}->{'RefreshSearchInterval'} ) { + $session{'tickets_refresh_interval'} = + $args{ARGS}->{'RefreshSearchInterval'}; + } + + if ( $args{ARGS}->{'TicketsSortBy'} ) { + $session{'tickets_sort_by'} = $args{ARGS}->{'TicketsSortBy'}; + $session{'tickets_sort_order'} = $args{ARGS}->{'TicketsSortOrder'}; + $session{'tickets'}->OrderBy( + FIELD => $args{ARGS}->{'TicketsSortBy'}, + ORDER => $args{ARGS}->{'TicketsSortOrder'} + ); + } + + # }}} + + # {{{ Set the query limit + if ( defined $args{ARGS}->{'RowsPerPage'} ) { + $RT::Logger->debug( + "limiting to " . $args{ARGS}->{'RowsPerPage'} . " rows" ); + + $session{'tickets_rows_per_page'} = $args{ARGS}->{'RowsPerPage'}; + $session{'tickets'}->RowsPerPage( $args{ARGS}->{'RowsPerPage'} ); + } + + # }}} + # {{{ Limit priority + if ( $args{ARGS}->{'ValueOfPriority'} ne '' ) { + $session{'tickets'}->LimitPriority( + VALUE => $args{ARGS}->{'ValueOfPriority'}, + OPERATOR => $args{ARGS}->{'PriorityOp'} + ); + } + + # }}} + # {{{ Limit owner + if ( $args{ARGS}->{'ValueOfOwner'} ne '' ) { + $session{'tickets'}->LimitOwner( + VALUE => $args{ARGS}->{'ValueOfOwner'}, + OPERATOR => $args{ARGS}->{'OwnerOp'} + ); + } + + # }}} + # {{{ Limit requestor email + + if ( $args{ARGS}->{'ValueOfRequestor'} ne '' ) { + my $alias = $session{'tickets'}->LimitRequestor( + VALUE => $args{ARGS}->{'ValueOfRequestor'}, + OPERATOR => $args{ARGS}->{'RequestorOp'}, + ); + + } + + # }}} + # {{{ Limit Queue + if ( $args{ARGS}->{'ValueOfQueue'} ne '' ) { + $session{'tickets'}->LimitQueue( + VALUE => $args{ARGS}->{'ValueOfQueue'}, + OPERATOR => $args{ARGS}->{'QueueOp'} + ); + } + + # }}} + # {{{ Limit Status + if ( $args{ARGS}->{'ValueOfStatus'} ne '' ) { + if ( ref( $args{ARGS}->{'ValueOfStatus'} ) ) { + foreach my $value ( @{ $args{ARGS}->{'ValueOfStatus'} } ) { + $session{'tickets'}->LimitStatus( + VALUE => $value, + OPERATOR => $args{ARGS}->{'StatusOp'}, + ); + } + } + else { + $session{'tickets'}->LimitStatus( + VALUE => $args{ARGS}->{'ValueOfStatus'}, + OPERATOR => $args{ARGS}->{'StatusOp'}, + ); + } + + } + + # }}} + # {{{ Limit Subject + if ( $args{ARGS}->{'ValueOfSubject'} ne '' ) { + $session{'tickets'}->LimitSubject( + VALUE => $args{ARGS}->{'ValueOfSubject'}, + OPERATOR => $args{ARGS}->{'SubjectOp'}, + ); + } + + # }}} + # {{{ Limit Dates + if ( $args{ARGS}->{'ValueOfDate'} ne '' ) { + + my $date = ParseDateToISO( $args{ARGS}->{'ValueOfDate'} ); + $args{ARGS}->{'DateType'} =~ s/_Date$//; + + $session{'tickets'}->LimitDate( + FIELD => $args{ARGS}->{'DateType'}, + VALUE => $date, + OPERATOR => $args{ARGS}->{'DateOp'}, + ); + } + + # }}} + # {{{ Limit Content + if ( $args{ARGS}->{'ValueOfContent'} ne '' ) { + $session{'tickets'}->LimitContent( + VALUE => $args{ARGS}->{'ValueOfContent'}, + OPERATOR => $args{ARGS}->{'ContentOp'}, + ); + } + + # }}} + # {{{ Limit KeywordSelects + + foreach my $KeywordSelectId ( + map { /^KeywordSelect(\d+)$/; $1 } + grep { /^KeywordSelect(\d+)$/; } keys %{ $args{ARGS} } + ) + { + my $form = $args{ARGS}->{"KeywordSelect$KeywordSelectId"}; + my $oper = $args{ARGS}->{"KeywordSelectOp$KeywordSelectId"}; + foreach my $KeywordId ( ref($form) ? @{$form} : ($form) ) { + next unless ($KeywordId); + my $quote = 1; + if ( $KeywordId =~ /^null$/i ) { + + #Don't quote the string 'null' + $quote = 0; + + # Convert the operator to something apropriate for nulls + $oper = 'IS' if ( $oper eq '=' ); + $oper = 'IS NOT' if ( $oper eq '!=' ); + } + $session{'tickets'}->LimitKeyword( + KEYWORDSELECT => $KeywordSelectId, + OPERATOR => $oper, + QUOTEVALUE => $quote, + KEYWORD => $KeywordId + ); + } + } + + # }}} + +} + +# }}} + +# {{{ sub ParseDateToISO + +=head2 ParseDateToISO + +Takes a date in an arbitrary format. +Returns an ISO date and time in GMT + +=cut + +sub ParseDateToISO { + my $date = shift; + + my $date_obj = new RT::Date($CurrentUser); + $date_obj->Set( + Format => 'unknown', + Value => $date + ); + return ( $date_obj->ISO ); +} + +# }}} + +# {{{ sub Config +# TODO: This might eventually read the cookies, user configuration +# information from the DB, queue configuration information from the +# DB, etc. + +sub Config { + my $args = shift; + my $key = shift; + return $args->{$key} || $RT::WebOptions{$key}; +} + +# }}} + +# {{{ sub ProcessACLChanges + +sub ProcessACLChanges { + my $ACLref = shift; + my $ARGSref = shift; + + my @CheckACL = @$ACLref; + my %ARGS = %$ARGSref; + + my ( $ACL, @results ); + + # {{{ Add rights + foreach $ACL (@CheckACL) { + my ($Principal); + + next unless ($ACL); + + # Parse out what we're really talking about. + if ( $ACL =~ /^(.*?)-(\d+)-(.*?)-(\d+)/ ) { + my $PrincipalType = $1; + my $PrincipalId = $2; + my $Scope = $3; + my $AppliesTo = $4; + + # {{{ Create an object called Principal + # so we can do rights operations + + if ( $PrincipalType eq 'User' ) { + $Principal = new RT::User( $session{'CurrentUser'} ); + } + elsif ( $PrincipalType eq 'Group' ) { + $Principal = new RT::Group( $session{'CurrentUser'} ); + } + else { + Abort("$PrincipalType unknown principal type"); + } + + $Principal->Load($PrincipalId) + || Abort("$PrincipalType $PrincipalId couldn't be loaded"); + + # }}} + + # {{{ load up an RT::ACL object with the same current vals of this ACL + + my $CurrentACL = new RT::ACL( $session{'CurrentUser'} ); + if ( $Scope eq 'Queue' ) { + $CurrentACL->LimitToQueue($AppliesTo); + } + elsif ( $Scope eq 'System' ) { + $CurrentACL->LimitToSystem(); + } + + $CurrentACL->LimitPrincipalToType($PrincipalType); + $CurrentACL->LimitPrincipalToId($PrincipalId); + + # }}} + + # {{{ Get the values of the select we're working with + # into an array. it will contain all the new rights that have + # been granted + #Hack to turn the ACL returned into an array + my @rights = + ref( $ARGS{"GrantACE-$ACL"} ) eq 'ARRAY' + ? @{ $ARGS{"GrantACE-$ACL"} } + : ( $ARGS{"GrantACE-$ACL"} ); + + # }}} + + # {{{ Add any rights we need. + + foreach my $right (@rights) { + next unless ($right); + + #if the right that's been selected wasn't there before, add it. + unless ( + $CurrentACL->HasEntry( + RightScope => "$Scope", + RightName => "$right", + RightAppliesTo => "$AppliesTo", + PrincipalType => $PrincipalType, + PrincipalId => $Principal->Id + ) + ) + { + + #Add new entry to list of rights. + if ( $Scope eq 'Queue' ) { + my $Queue = new RT::Queue( $session{'CurrentUser'} ); + $Queue->Load($AppliesTo); + unless ( $Queue->id ) { + Abort("Couldn't find a queue called $AppliesTo"); + } + + my ( $val, $msg ) = $Principal->GrantQueueRight( + RightAppliesTo => $Queue->id, + RightName => "$right" + ); + + if ($val) { + push ( @results, + "Granted right $right to " + . $Principal->Name + . " for queue " + . $Queue->Name ); + } + else { + push ( @results, $msg ); + } + } + elsif ( $Scope eq 'System' ) { + my ( $val, $msg ) = $Principal->GrantSystemRight( + RightAppliesTo => $AppliesTo, + RightName => "$right" + ); + if ($val) { + push ( @results, "Granted system right '$right' to " + . $Principal->Name ); + } + else { + push ( @results, $msg ); + } + } + } + } + + # }}} + } + } + + # }}} Add rights + + # {{{ remove any rights that have been deleted + + my @RevokeACE = + ref( $ARGS{"RevokeACE"} ) eq 'ARRAY' + ? @{ $ARGS{"RevokeACE"} } + : ( $ARGS{"RevokeACE"} ); + + foreach my $aceid (@RevokeACE) { + + my $right = new RT::ACE( $session{'CurrentUser'} ); + $right->Load($aceid); + next unless ( $right->id ); + + my $phrase = "Revoked " + . $right->PrincipalType . " " + . $right->PrincipalObj->Name + . "'s right to " + . $right->RightName; + + if ( $right->RightScope eq 'System' ) { + $phrase .= ' across all queues.'; + } + else { + $phrase .= ' for the queue ' . $right->AppliesToObj->Name . '.'; + } + my ( $val, $msg ) = $right->Delete(); + if ($val) { + push ( @results, $phrase ); + } + else { + push ( @results, $msg ); + } + } + + # }}} + + return (@results); +} + +# }}} + +# {{{ sub UpdateRecordObj + +=head2 UpdateRecordObj ( ARGSRef => \%ARGS, Object => RT::Record, AttributesRef => \@attribs) + +@attribs is a list of ticket fields to check and update if they differ from the B's current values. ARGSRef is a ref to HTML::Mason's %ARGS. + +Returns an array of success/failure messages + +=cut + +sub UpdateRecordObject { + my %args = ( + ARGSRef => undef, + AttributesRef => undef, + Object => undef, + @_ + ); + + my (@results); + + my $object = $args{'Object'}; + my $attributes = $args{'AttributesRef'}; + my $ARGSRef = $args{'ARGSRef'}; + + foreach $attribute (@$attributes) { + if ( ( defined $ARGSRef->{"$attribute"} ) + and ( $ARGSRef->{"$attribute"} ne $object->$attribute() ) ) + { + $ARGSRef->{"$attribute"} =~ s/\r\n/\n/gs; + + my $method = "Set$attribute"; + my ( $code, $msg ) = $object->$method( $ARGSRef->{"$attribute"} ); + push @results, "$attribute: $msg"; + } + } + return (@results); +} + +# }}} + +# {{{ sub ProcessTicketBasics + +=head2 ProcessTicketBasics ( TicketObj => $Ticket, ARGSRef => \%ARGS ); + +Returns an array of results messages. + +=cut + +sub ProcessTicketBasics { + + my %args = ( + TicketObj => undef, + ARGSRef => undef, + @_ + ); + + my $TicketObj = $args{'TicketObj'}; + my $ARGSRef = $args{'ARGSRef'}; + + # {{{ Set basic fields + my @attribs = qw( + Subject + FinalPriority + Priority + TimeWorked + TimeLeft + Status + Queue + ); + + if ( $ARGSRef->{'Queue'} and ( $ARGSRef->{'Queue'} !~ /^(\d+)$/ ) ) { + my $tempqueue = RT::Queue->new($RT::SystemUser); + $tempqueue->Load( $ARGSRef->{'Queue'} ); + if ( $tempqueue->id ) { + $ARGSRef->{'Queue'} = $tempqueue->Id(); + } + } + + my @results = UpdateRecordObject( + AttributesRef => \@attribs, + Object => $TicketObj, + ARGSRef => $ARGSRef + ); + + # We special case owner changing, so we can use ForceOwnerChange + if ( $ARGSRef->{'Owner'} && ( $TicketObj->Owner ne $ARGSRef->{'Owner'} ) ) { + my ($ChownType); + if ( $ARGSRef->{'ForceOwnerChange'} ) { + $ChownType = "Force"; + } + else { + $ChownType = "Give"; + } + + my ( $val, $msg ) = + $TicketObj->SetOwner( $ARGSRef->{'Owner'}, $ChownType ); + push ( @results, "$msg" ); + } + + # }}} + + return (@results); +} + +# }}} + +# {{{ sub ProcessTicketWatchers + +=head2 ProcessTicketWatchers ( TicketObj => $Ticket, ARGSRef => \%ARGS ); + +Returns an array of results messages. + +=cut + +sub ProcessTicketWatchers { + my %args = ( + TicketObj => undef, + ARGSRef => undef, + @_ + ); + my (@results); + + my $Ticket = $args{'TicketObj'}; + my $ARGSRef = $args{'ARGSRef'}; + + # {{{ Munge watchers + + foreach my $key ( keys %$ARGSRef ) { + + # Delete deletable watchers + if ( ( $key =~ /^DelWatcher(\d*)$/ ) and ( $ARGSRef->{$key} ) ) { + my ( $code, $msg ) = $Ticket->DeleteWatcher($1); + push @results, $msg; + } + + # Delete watchers in the simple style demanded by the bulk manipulator + elsif ( $key =~ /^Delete(Requestor|Cc|AdminCc)$/ ) { + my ( $code, $msg ) = $Ticket->DeleteWatcher( $ARGSRef->{$key}, $1 ); + push @results, $msg; + } + + # Add new wathchers by email address + elsif ( ( $ARGSRef->{$key} =~ /^(AdminCc|Cc|Requestor)$/ ) + and ( $key =~ /^WatcherTypeEmail(\d*)$/ ) ) + { + + #They're in this order because otherwise $1 gets clobbered :/ + my ( $code, $msg ) = $Ticket->AddWatcher( + Type => $ARGSRef->{$key}, + Email => $ARGSRef->{ "WatcherAddressEmail" . $1 } + ); + push @results, $msg; + } + + #Add requestors in the simple style demanded by the bulk manipulator + elsif ( $key =~ /^Add(Requestor|Cc|AdminCc)$/ ) { + my ( $code, $msg ) = $Ticket->AddWatcher( + Type => $1, + Email => $ARGSRef->{$key} + ); + push @results, $msg; + } + + # Add new watchers by owner + elsif ( ( $ARGSRef->{$key} =~ /^(AdminCc|Cc|Requestor)$/ ) + and ( $key =~ /^WatcherTypeUser(\d*)$/ ) ) + { + + #They're in this order because otherwise $1 gets clobbered :/ + my ( $code, $msg ) = + $Ticket->AddWatcher( Type => $ARGSRef->{$key}, Owner => $1 ); + push @results, $msg; + } + } + + # }}} + + return (@results); +} + +# }}} + +# {{{ sub ProcessTicketDates + +=head2 ProcessTicketDates ( TicketObj => $Ticket, ARGSRef => \%ARGS ); + +Returns an array of results messages. + +=cut + +sub ProcessTicketDates { + my %args = ( + TicketObj => undef, + ARGSRef => undef, + @_ + ); + + my $Ticket = $args{'TicketObj'}; + my $ARGSRef = $args{'ARGSRef'}; + + my (@results); + + # {{{ Set date fields + my @date_fields = qw( + Told + Resolved + Starts + Started + Due + ); + + #Run through each field in this list. update the value if apropriate + foreach $field (@date_fields) { + my ( $code, $msg ); + + my $DateObj = RT::Date->new( $session{'CurrentUser'} ); + + #If it's something other than just whitespace + if ( $ARGSRef->{ $field . '_Date' } ne '' ) { + $DateObj->Set( + Format => 'unknown', + Value => $ARGSRef->{ $field . '_Date' } + ); + my $obj = $field . "Obj"; + if ( ( defined $DateObj->Unix ) + and ( $DateObj->Unix ne $Ticket->$obj()->Unix() ) ) + { + my $method = "Set$field"; + my ( $code, $msg ) = $Ticket->$method( $DateObj->ISO ); + push @results, "$msg"; + } + } + } + + # }}} + return (@results); +} + +# }}} + +# {{{ sub ProcessTicketLinks + +=head2 ProcessTicketLinks ( TicketObj => $Ticket, ARGSRef => \%ARGS ); + +Returns an array of results messages. + +=cut + +sub ProcessTicketLinks { + my %args = ( + TicketObj => undef, + ARGSRef => undef, + @_ + ); + + my $Ticket = $args{'TicketObj'}; + my $ARGSRef = $args{'ARGSRef'}; + + my (@results); + + # Delete links that are gone gone gone. + foreach my $arg ( keys %$ARGSRef ) { + if ( $arg =~ /DeleteLink-(.*?)-(DependsOn|MemberOf|RefersTo)-(.*)$/ ) { + my $base = $1; + my $type = $2; + my $target = $3; + + push @results, + "Trying to delete: Base: $base Target: $target Type $type"; + my ( $val, $msg ) = $Ticket->DeleteLink( + Base => $base, + Type => $type, + Target => $target + ); + + push @results, $msg; + + } + + } + + my @linktypes = qw( DependsOn MemberOf RefersTo ); + + foreach my $linktype (@linktypes) { + + for my $luri ( split ( / /, $ARGSRef->{ $Ticket->Id . "-$linktype" } ) ) + { + $luri =~ s/\s*$//; # Strip trailing whitespace + my ( $val, $msg ) = $Ticket->AddLink( + Target => $luri, + Type => $linktype + ); + push @results, $msg; + } + + for my $luri ( split ( / /, $ARGSRef->{ "$linktype-" . $Ticket->Id } ) ) + { + my ( $val, $msg ) = $Ticket->AddLink( + Base => $luri, + Type => $linktype + ); + + push @results, $msg; + } + } + + #Merge if we need to + if ( $ARGSRef->{ $Ticket->Id . "-MergeInto" } ) { + my ( $val, $msg ) = + $Ticket->MergeInto( $ARGSRef->{ $Ticket->Id . "-MergeInto" } ); + push @results, $msg; + } + + return (@results); +} + +# }}} + +# {{{ sub ProcessTicketObjectKeywords + +=head2 ProcessTicketObjectKeywords ( TicketObj => $Ticket, ARGSRef => \%ARGS ); + +Returns an array of results messages. + +=cut + +sub ProcessTicketObjectKeywords { + my %args = ( + TicketObj => undef, + ARGSRef => undef, + @_ + ); + + my $TicketObj = $args{'TicketObj'}; + my $ARGSRef = $args{'ARGSRef'}; + + my (@results); + + # {{{ set ObjectKeywords. + + my $KeywordSelects = $TicketObj->QueueObj->KeywordSelects; + + # iterate through all the keyword selects for this queue + while ( my $KeywordSelect = $KeywordSelects->Next ) { + + # {{{ do some setup + + # if we have KeywordSelectMagic for this keywordselect: + next + unless + defined $ARGSRef->{ 'KeywordSelectMagic' . $KeywordSelect->id }; + + # Lets get a hash of the possible values to work with + my $value = $ARGSRef->{ 'KeywordSelect' . $KeywordSelect->id } || []; + + #lets get all those values in a hash. regardless of # of entries + #we'll use this for adding and deleting keywords from this object. + my %values = map { $_ => 1 } ref($value) ? @{$value} : ($value); + + # Load up the ObjectKeywords for this KeywordSelect for this ticket + my $ObjectKeys = $TicketObj->KeywordsObj( $KeywordSelect->id ); + + # }}} + # {{{ add new keywords + + foreach my $key ( keys %values ) { + + #unless the ticket has that keyword for that keyword select, + unless ( $ObjectKeys->HasEntry($key) ) { + + #Add the keyword + my ( $result, $msg ) = $TicketObj->AddKeyword( + Keyword => $key, + KeywordSelect => $KeywordSelect->id + ); + push ( @results, $msg ); + } + } + + # }}} + # {{{ Delete unused keywords + + #redo this search, so we don't ask it to delete things that are already gone + # such as when a single keyword select gets its value changed. + $ObjectKeys = $TicketObj->KeywordsObj( $KeywordSelect->id ); + + while ( my $TicketKey = $ObjectKeys->Next ) { + + # if the hash defined above doesn\'t contain the keyword mentioned, + unless ( $values{ $TicketKey->Keyword } ) { + + #I'd really love to just call $keyword->Delete, but then + # we wouldn't get a transaction recorded + my ( $result, $msg ) = $TicketObj->DeleteKeyword( + Keyword => $TicketKey->Keyword, + KeywordSelect => $KeywordSelect->id + ); + push ( @results, $msg ); + } + } + + # }}} + } + + #Iterate through the keyword selects for BulkManipulator style access + while ( my $KeywordSelect = $KeywordSelects->Next ) { + if ( $ARGSRef->{ "AddToKeywordSelect" . $KeywordSelect->Id } ) { + + #Add the keyword + my ( $result, $msg ) = $TicketObj->AddKeyword( + Keyword => + $ARGSRef->{ "AddToKeywordSelect" . $KeywordSelect->Id }, + KeywordSelect => $KeywordSelect->id + ); + push ( @results, $msg ); + } + if ( $ARGSRef->{ "DeleteFromKeywordSelect" . $KeywordSelect->Id } ) { + + #Delete the keyword + my ( $result, $msg ) = $TicketObj->DeleteKeyword( + Keyword => + $ARGSRef->{ "DeleteFromKeywordSelect" . $KeywordSelect->Id }, + KeywordSelect => $KeywordSelect->id + ); + push ( @results, $msg ); + } + } + + # }}} + + return (@results); +} + +# }}} + +1; -- cgit v1.2.1 From 945721f48f74d5cfffef7c7cf3a3d6bc2521f5dd Mon Sep 17 00:00:00 2001 From: ivan Date: Tue, 15 Jul 2003 13:16:32 +0000 Subject: import of rt 3.0.4 --- rt/lib/RT/Interface/CLI.pm | 112 ++- rt/lib/RT/Interface/Email.pm | 683 +++++++------ rt/lib/RT/Interface/Email/Auth/MailFrom.pm | 131 +++ rt/lib/RT/Interface/Email/Filter/SpamAssassin.pm | 63 ++ rt/lib/RT/Interface/Web.pm | 1124 ++++++++++++---------- 5 files changed, 1243 insertions(+), 870 deletions(-) create mode 100644 rt/lib/RT/Interface/Email/Auth/MailFrom.pm create mode 100644 rt/lib/RT/Interface/Email/Filter/SpamAssassin.pm (limited to 'rt/lib/RT/Interface') diff --git a/rt/lib/RT/Interface/CLI.pm b/rt/lib/RT/Interface/CLI.pm index a3bf92d5f..a3c840af5 100644 --- a/rt/lib/RT/Interface/CLI.pm +++ b/rt/lib/RT/Interface/CLI.pm @@ -1,9 +1,31 @@ -# $Header: /home/cvs/cvsroot/freeside/rt/lib/RT/Interface/CLI.pm,v 1.1 2002-08-12 06:17:08 ivan Exp $ -# RT is (c) 1996-2001 Jesse Vincent +# BEGIN LICENSE BLOCK +# +# Copyright (c) 1996-2003 Jesse Vincent +# +# (Except where explictly superceded by other copyright notices) +# +# This work is made available to you under the terms of Version 2 of +# the GNU General Public License. A copy of that license should have +# been provided with this software, but in any event can be snarfed +# from www.gnu.org. +# +# This work is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# Unless otherwise specified, all modifications, corrections or +# extensions to this work which alter its source code become the +# property of Best Practical Solutions, LLC when submitted for +# inclusion in the work. +# +# +# END LICENSE BLOCK +use strict; +use RT; package RT::Interface::CLI; -use strict; BEGIN { @@ -11,14 +33,14 @@ BEGIN { use vars qw ($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS); # set the version for version checking - $VERSION = do { my @r = (q$Revision: 1.1 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r }; # must be all one line, for MakeMaker + $VERSION = do { my @r = (q$Revision: 1.1.1.1 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r }; # must be all one line, for MakeMaker @ISA = qw(Exporter); # your exported package globals go here, # as well as any optionally exported functions - @EXPORT_OK = qw(&CleanEnv &LoadConfig &DBConnect - &GetCurrentUser &GetMessageContent &debug); + @EXPORT_OK = qw(&CleanEnv + &GetCurrentUser &GetMessageContent &debug &loc); } =head1 NAME @@ -27,25 +49,28 @@ BEGIN { =head1 SYNOPSIS - use lib "!!RT_LIB_PATH!!"; - use lib "!!RT_ETC_PATH!!"; + use lib "/path/to/rt/libraries/"; - use RT::Interface::CLI qw(CleanEnv LoadConfig DBConnect - GetCurrentUser GetMessageContent); + use RT::Interface::CLI qw(CleanEnv + GetCurrentUser GetMessageContent loc); #Clean out all the nasties from the environment CleanEnv(); - #Load etc/config.pm and drop privs - LoadConfig(); + #let's talk to RT' + use RT; - #Connect to the database and get RT::SystemUser and RT::Nobody loaded - DBConnect(); + #Load RT's config file + RT::LoadConfig(); + # Connect to the database. set up loggign + RT::Init(); #Get the current user all loaded my $CurrentUser = GetCurrentUser(); + print loc('Hello!'); # Synonym of $CuurentUser->loc('Hello!'); + =head1 DESCRIPTION @@ -53,7 +78,6 @@ BEGIN { =begin testing -ok(require RT::TestHarness); ok(require RT::Interface::CLI); =end testing @@ -77,35 +101,10 @@ sub CleanEnv { -=head2 LoadConfig - -Loads RT's config file and then drops setgid privileges. - -=cut - -sub LoadConfig { - - #This drags in RT's config.pm - use config; - -} - - - -=head2 DBConnect - - Calls RT::Init, which creates a database connection and then creates $RT::Nobody - and $RT::SystemUser - -=cut - - -sub DBConnect { - use RT; - RT::Init(); -} +{ + my $CurrentUser; # shared betwen GetCurrentUser and loc # {{{ sub GetCurrentUser @@ -115,15 +114,14 @@ sub DBConnect { loaded with that user. if the current user isn't found, returns a copy of RT::Nobody. =cut + sub GetCurrentUser { - my ($Gecos, $CurrentUser); - require RT::CurrentUser; #Instantiate a user object - $Gecos=(getpwuid($<))[0]; + my $Gecos= ($^O eq 'MSWin32') ? Win32::LoginName() : (getpwuid($<))[0]; #If the current user is 0, then RT will assume that the User object #is that of the currentuser. @@ -134,10 +132,29 @@ sub GetCurrentUser { unless ($CurrentUser->Id) { $RT::Logger->debug("No user with a unix login of '$Gecos' was found. "); } + return($CurrentUser); } # }}} + +# {{{ sub loc + +=head2 loc + + Synonym of $CurrentUser->loc(). + +=cut + +sub loc { + die "No current user yet" unless $CurrentUser ||= RT::CurrentUser->new; + return $CurrentUser->loc(@_); +} +# }}} + +} + + # {{{ sub GetMessageContent =head2 GetMessageContent @@ -221,4 +238,9 @@ sub debug { # }}} +eval "require RT::Interface::CLI_Vendor"; +die $@ if ($@ && $@ !~ qr{^Can't locate RT/Interface/CLI_Vendor.pm}); +eval "require RT::Interface::CLI_Local"; +die $@ if ($@ && $@ !~ qr{^Can't locate RT/Interface/CLI_Local.pm}); + 1; diff --git a/rt/lib/RT/Interface/Email.pm b/rt/lib/RT/Interface/Email.pm index e95436091..bc1a55da2 100755 --- a/rt/lib/RT/Interface/Email.pm +++ b/rt/lib/RT/Interface/Email.pm @@ -1,41 +1,58 @@ -# $Header: /home/cvs/cvsroot/freeside/rt/lib/RT/Interface/Email.pm,v 1.1 2002-08-12 06:17:08 ivan Exp $ -# RT is (c) 1996-2001 Jesse Vincent - +# BEGIN LICENSE BLOCK +# +# Copyright (c) 1996-2003 Jesse Vincent +# +# (Except where explictly superceded by other copyright notices) +# +# This work is made available to you under the terms of Version 2 of +# the GNU General Public License. A copy of that license should have +# been provided with this software, but in any event can be snarfed +# from www.gnu.org. +# +# This work is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# Unless otherwise specified, all modifications, corrections or +# extensions to this work which alter its source code become the +# property of Best Practical Solutions, LLC when submitted for +# inclusion in the work. +# +# +# END LICENSE BLOCK package RT::Interface::Email; use strict; use Mail::Address; use MIME::Entity; +use RT::EmailParser; + BEGIN { use Exporter (); use vars qw ($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS); # set the version for version checking - $VERSION = do { my @r = (q$Revision: 1.1 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r }; # must be all one line, for MakeMaker + $VERSION = do { my @r = (q$Revision: 1.1.1.1 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r }; # must be all one line, for MakeMaker @ISA = qw(Exporter); # your exported package globals go here, # as well as any optionally exported functions - @EXPORT_OK = qw(&CleanEnv - &LoadConfig - &DBConnect - &GetCurrentUser + @EXPORT_OK = qw( + &CreateUser &GetMessageContent &CheckForLoops &CheckForSuspiciousSender &CheckForAutoGenerated - &ParseMIMEEntityFromSTDIN - &ParseTicketId &MailError &ParseCcAddressesFromHead &ParseSenderAddressFromHead - &ParseErrorsToAddressFromHead - &ParseAddressFromHeader - + &ParseErrorsToAddressFromHead + &ParseAddressFromHeader + &Gateway); - &debug); } =head1 NAME @@ -47,28 +64,13 @@ BEGIN { use lib "!!RT_LIB_PATH!!"; use lib "!!RT_ETC_PATH!!"; - use RT::Interface::Email qw(CleanEnv LoadConfig DBConnect - ); - - #Clean out all the nasties from the environment - CleanEnv(); - - #Load etc/config.pm and drop privs - LoadConfig(); - - #Connect to the database and get RT::SystemUser and RT::Nobody loaded - DBConnect(); - - - #Get the current user all loaded - my $CurrentUser = GetCurrentUser(); + use RT::Interface::Email qw(Gateway CreateUser); =head1 DESCRIPTION =begin testing -ok(require RT::TestHarness); ok(require RT::Interface::Email); =end testing @@ -79,71 +81,6 @@ ok(require RT::Interface::Email); =cut -=head2 CleanEnv - -Removes some of the nastiest nasties from the user\'s environment. - -=cut - -sub CleanEnv { - $ENV{'PATH'} = '/bin:/usr/bin'; # or whatever you need - $ENV{'CDPATH'} = '' if defined $ENV{'CDPATH'}; - $ENV{'SHELL'} = '/bin/sh' if defined $ENV{'SHELL'}; - $ENV{'ENV'} = '' if defined $ENV{'ENV'}; - $ENV{'IFS'} = '' if defined $ENV{'IFS'}; -} - - - -=head2 LoadConfig - -Loads RT's config file and then drops setgid privileges. - -=cut - -sub LoadConfig { - - #This drags in RT's config.pm - use config; - -} - - - -=head2 DBConnect - - Calls RT::Init, which creates a database connection and then creates $RT::Nobody - and $RT::SystemUser - -=cut - - -sub DBConnect { - use RT; - RT::Init(); -} - - - -# {{{ sub debug - -sub debug { - my $val = shift; - my ($debug); - if ($val) { - $RT::Logger->debug($val."\n"); - if ($debug) { - print STDERR "$val\n"; - } - } - if ($debug) { - return(1); - } -} - -# }}} - - # {{{ sub CheckForLoops sub CheckForLoops { @@ -207,82 +144,6 @@ sub CheckForAutoGenerated { # }}} -# {{{ sub ParseMIMEEntityFromSTDIN - -sub ParseMIMEEntityFromSTDIN { - - # Create a new parser object: - - my $parser = new MIME::Parser; - - # {{{ Config $parser to store large attacments in temp dir - - ## TODO: Does it make sense storing to disk at all? After all, we - ## need to put each msg as an in-core scalar before saving it to - ## the database, don't we? - - ## At the same time, we should make sure that we nuke attachments - ## Over max size and return them - - ## TODO: Remove the temp dir when we don't need it any more. - - my $AttachmentDir = File::Temp::tempdir (TMPDIR => 1, CLEANUP => 1); - - # Set up output directory for files: - $parser->output_dir("$AttachmentDir"); - - #If someone includes a message, don't extract it - $parser->extract_nested_messages(0); - - - # Set up the prefix for files with auto-generated names: - $parser->output_prefix("part"); - - # If content length is <= 20000 bytes, store each msg as in-core scalar; - # Else, write to a disk file (the default action): - - $parser->output_to_core(20000); - - # }}} (temporary directory) - - #Ok. now that we're set up, let's get the stdin. - my $entity; - unless ($entity = $parser->read(\*STDIN)) { - die "couldn't parse MIME stream"; - } - #Now we've got a parsed mime object. - - # Get the head, a MIME::Head: - my $head = $entity->head; - - - # Unfold headers that are have embedded newlines - $head->unfold; - - # TODO - information about the charset is lost here! - $head->decode; - - return ($entity, $head); - -} -# }}} - -# {{{ sub ParseTicketId - -sub ParseTicketId { - my $Subject = shift; - my ($Id); - - if ($Subject =~ s/\[$RT::rtname \#(\d+)\]//i) { - $Id = $1; - $RT::Logger->debug("Found a ticket ID. It's $Id"); - return($Id); - } - else { - return(undef); - } -} -# }}} # {{{ sub MailError sub MailError { @@ -313,8 +174,8 @@ sub MailError { if ($mimeobj) { $mimeobj->sync_headers(); $entity->add_part($mimeobj); - } - + } + if ($RT::MailCommand eq 'sendmailpipe') { open (MAIL, "|$RT::SendmailPath $RT::SendmailArguments") || return(0); print MAIL $entity->as_string; @@ -327,144 +188,66 @@ sub MailError { # }}} -# {{{ sub GetCurrentUser - -sub GetCurrentUser { - my $head = shift; - my $entity = shift; - my $ErrorsTo = shift; +# {{{ Create User - my %UserInfo = (); +sub CreateUser { + my ($Username, $Address, $Name, $ErrorsTo, $entity) = @_; + my $NewUser = RT::User->new($RT::SystemUser); - #Suck the address of the sender out of the header - my ($Address, $Name) = ParseSenderAddressFromHead($head); - - #This will apply local address canonicalization rules - $Address = RT::CanonicalizeAddress($Address); - - #If desired, synchronize with an external database - - my $UserFoundInExternalDatabase = 0; - - # Username is the 'Name' attribute of the user that RT uses for things - # like authentication - my $Username = undef; - if ($RT::LookupSenderInExternalDatabase) { - ($UserFoundInExternalDatabase, %UserInfo) = - RT::LookupExternalUserInfo($Address, $Name); - - $Address = $UserInfo{'EmailAddress'}; - $Username = $UserInfo{'Name'}; - } - - my $CurrentUser = RT::CurrentUser->new(); + # This data is tainted by some Very Broken mailers. + # (Sometimes they send raw ISO 8859-1 data here. fear that. + require Encode; + $Username = Encode::encode(utf8 => $Username, Encode::FB_PERLQQ()) if defined $Username; + $Name = Encode::encode(utf8 => $Name, Encode::FB_PERLQQ()) if defined $Name; - # First try looking up by a username, if we got one from the external - # db lookup. Next, try looking up by email address. Failing that, - # try looking up by users who have this user's email address as their - # username. - - if ($Username) { - $CurrentUser->LoadByName($Username); - } + my ($Val, $Message) = + $NewUser->Create(Name => ($Username || $Address), + EmailAddress => $Address, + RealName => $Name, + Password => undef, + Privileged => 0, + Comments => 'Autocreated on ticket submission' + ); - unless ($CurrentUser->Id) { - $CurrentUser->LoadByEmail($Address); - } - - #If we can't get it by email address, try by name. - unless ($CurrentUser->Id) { - $CurrentUser->LoadByName($Address); + unless ($Val) { + + # Deal with the race condition of two account creations at once + # + if ($Username) { + $NewUser->LoadByName($Username); + } + + unless ($NewUser->Id) { + $NewUser->LoadByEmail($Address); + } + + unless ($NewUser->Id) { + MailError( To => $ErrorsTo, + Subject => "User could not be created", + Explanation => "User creation failed in mailgateway: $Message", + MIMEObj => $entity, + LogLevel => 'crit' + ); + } } - - - unless ($CurrentUser->Id) { - #If we couldn't load a user, determine whether to create a user - - # {{{ If we require an incoming address to be found in the external - # user database, reject the incoming message appropriately - if ( $RT::LookupSenderInExternalDatabase && - $RT::SenderMustExistInExternalDatabase && - !$UserFoundInExternalDatabase) { - - my $Message = "Sender's email address was not found in the user database."; - - # {{{ This code useful only if you've defined an AutoRejectRequest template - - require RT::Template; - my $template = new RT::Template($RT::Nobody); - $template->Load('AutoRejectRequest'); - $Message = $template->Content || $Message; - - # }}} - - MailError( To => $ErrorsTo, - Subject => "Ticket Creation failed: user could not be created", - Explanation => $Message, - MIMEObj => $entity, - LogLevel => 'notice' - ); - - return($CurrentUser); - - } - # }}} - - else { - my $NewUser = RT::User->new($RT::SystemUser); - - my ($Val, $Message) = - $NewUser->Create(Name => ($Username || $Address), - EmailAddress => $Address, - RealName => "$Name", - Password => undef, - Privileged => 0, - Comments => 'Autocreated on ticket submission' - ); - - unless ($Val) { - - # Deal with the race condition of two account creations at once - # - if ($Username) { - $NewUser->LoadByName($Username); - } - - unless ($NewUser->Id) { - $NewUser->LoadByEmail($Address); - } - - unless ($NewUser->Id) { - MailError( To => $ErrorsTo, - Subject => "User could not be created", - Explanation => "User creation failed in mailgateway: $Message", - MIMEObj => $entity, - LogLevel => 'crit' - ); - } - } - } - - #Load the new user object - $CurrentUser->LoadByEmail($Address); - - unless ($CurrentUser->id) { - $RT::Logger->warning("Couldn't load user '$Address'.". "giving up"); - MailError( To => $ErrorsTo, - Subject => "User could not be loaded", - Explanation => "User '$Address' could not be loaded in the mail gateway", - MIMEObj => $entity, - LogLevel => 'crit' - ); - - } + + #Load the new user object + my $CurrentUser = RT::CurrentUser->new(); + $CurrentUser->LoadByEmail($Address); + + unless ($CurrentUser->id) { + $RT::Logger->warning("Couldn't load user '$Address'.". "giving up"); + MailError( To => $ErrorsTo, + Subject => "User could not be loaded", + Explanation => "User '$Address' could not be loaded in the mail gateway", + MIMEObj => $entity, + LogLevel => 'crit' + ); } - - return ($CurrentUser); - -} -# }}} + return $CurrentUser; +} +# }}} # {{{ ParseCcAddressesFromHead =head2 ParseCcAddressesFromHead HASHREF @@ -489,11 +272,11 @@ sub ParseCcAddressesFromHead { foreach my $AddrObj (@ToObjs, @CcObjs) { my $Address = $AddrObj->address; - $Address = RT::CanonicalizeAddress($Address); + $Address = $args{'CurrentUser'}->UserObj->CanonicalizeEmailAddress($Address); next if ($args{'CurrentUser'}->EmailAddress =~ /^$Address$/i); next if ($args{'QueueObj'}->CorrespondAddress =~ /^$Address$/i); next if ($args{'QueueObj'}->CommentAddress =~ /^$Address$/i); - next if (RT::IsRTAddress($Address)); + next if (RT::EmailParser::IsRTAddress(undef, $Address)); push (@Addresses, $Address); } @@ -568,8 +351,7 @@ sub ParseAddressFromHeader{ } my $Name = ($AddrObj->phrase || $AddrObj->comment || $AddrObj->address); - - + #Lets take the from and load a user object. my $Address = $AddrObj->address; @@ -578,4 +360,289 @@ sub ParseAddressFromHeader{ # }}} + +=head2 Gateway + +This performs all the "guts" of the mail rt-mailgate program, and is +designed to be called from the web interface with a message, user +object, and so on. + +=cut + +sub Gateway { + my %args = ( message => undef, + queue => 1, + action => 'correspond', + ticket => undef, + @_ ); + + # Validate the action + unless ( $args{'action'} =~ /^(comment|correspond|action)$/ ) { + + # Can't safely loc this. What object do we loc around? + return ( 0, "Invalid 'action' parameter", undef ); + } + + my $parser = RT::EmailParser->new(); + $parser->ParseMIMEEntityFromScalar( $args{'message'} ); + + my $Message = $parser->Entity(); + my $head = $Message->head; + + my ( $CurrentUser, $AuthStat, $status, $error ); + + my $ErrorsTo = ParseErrorsToAddressFromHead($head); + + my $MessageId = $head->get('Message-Id') + || ""; + + #Pull apart the subject line + my $Subject = $head->get('Subject') || ''; + chomp $Subject; + + + $args{'ticket'} ||= $parser->ParseTicketId($Subject); + + my $SystemTicket; + if ($args{'ticket'} ) { + $SystemTicket = RT::Ticket->new($RT::SystemUser); + $SystemTicket->Load($args{'ticket'}); + } + + #Set up a queue object + my $SystemQueueObj = RT::Queue->new($RT::SystemUser); + $SystemQueueObj->Load( $args{'queue'} ); + + + # We can safely have no queue of we have a known-good ticket + unless ( $args{'ticket'} || $SystemQueueObj->id ) { + MailError( + To => $RT::OwnerEmail, + Subject => "RT Bounce: $Subject", + Explanation => "RT couldn't find the queue: " . $args{'queue'}, + MIMEObj => $Message ); + return ( 0, "RT couldn't find the queue: " . $args{'queue'}, undef ); + } + + # Authentication Level + # -1 - Get out. this user has been explicitly declined + # 0 - User may not do anything (Not used at the moment) + # 1 - Normal user + # 2 - User is allowed to specify status updates etc. a la enhanced-mailgate + + push @RT::MailPlugins, "Auth::MailFrom" unless @RT::MailPlugins; + # Since this needs loading, no matter what + + for (@RT::MailPlugins) { + my $Code; + my $NewAuthStat; + if ( ref($_) eq "CODE" ) { + $Code = $_; + } + else { + $_ = "RT::Interface::Email::$_" unless /^RT::Interface::Email::/; + eval "require $_;"; + if ($@) { + die ("Couldn't load module $_: $@"); + next; + } + no strict 'refs'; + if ( !defined( $Code = *{ $_ . "::GetCurrentUser" }{CODE} ) ) { + die ("No GetCurrentUser code found in $_ module"); + next; + } + } + + ( $CurrentUser, $NewAuthStat ) = $Code->( Message => $Message, + CurrentUser => $CurrentUser, + AuthLevel => $AuthStat, + Action => $args{'action'}, + Ticket => $SystemTicket, + Queue => $SystemQueueObj ); + + # You get the highest level of authentication you were assigned. + last if $AuthStat == -1; + $AuthStat = $NewAuthStat if $NewAuthStat > $AuthStat; + } + + # {{{ If authentication fails and no new user was created, get out. + if ( !$CurrentUser or !$CurrentUser->Id or $AuthStat == -1 ) { + + # If the plugins refused to create one, they lose. + MailError( + Subject => "Could not load a valid user", + Explanation => < $Message, + LogLevel => 'error' ) + unless $AuthStat == -1; + return ( 0, "Could not load a valid user", undef ); + } + + # }}} + + # {{{ Lets check for mail loops of various sorts. + my $IsAutoGenerated = CheckForAutoGenerated($head); + + my $IsSuspiciousSender = CheckForSuspiciousSender($head); + + my $IsALoop = CheckForLoops($head); + + my $SquelchReplies = 0; + + #If the message is autogenerated, we need to know, so we can not + # send mail to the sender + if ( $IsSuspiciousSender || $IsAutoGenerated || $IsALoop ) { + $SquelchReplies = 1; + $ErrorsTo = $RT::OwnerEmail; + } + + # }}} + + # {{{ Drop it if it's disallowed + if ( $AuthStat == 0 ) { + MailError( + To => $ErrorsTo, + Subject => "Permission Denied", + Explanation => "You do not have permission to communicate with RT", + MIMEObj => $Message ); + } + + # }}} + # {{{ Warn someone if it's a loop + + # Warn someone if it's a loop, before we drop it on the ground + if ($IsALoop) { + $RT::Logger->crit("RT Recieved mail ($MessageId) from itself."); + + #Should we mail it to RTOwner? + if ($RT::LoopsToRTOwner) { + MailError( To => $RT::OwnerEmail, + Subject => "RT Bounce: $Subject", + Explanation => "RT thinks this message may be a bounce", + MIMEObj => $Message ); + + #Do we actually want to store it? + return ( 0, "Message Bounced", undef ) unless ($RT::StoreLoops); + } + } + + # }}} + + # {{{ Squelch replies if necessary + # Don't let the user stuff the RT-Squelch-Replies-To header. + if ( $head->get('RT-Squelch-Replies-To') ) { + $head->add( 'RT-Relocated-Squelch-Replies-To', + $head->get('RT-Squelch-Replies-To') ); + $head->delete('RT-Squelch-Replies-To'); + } + + if ($SquelchReplies) { + ## TODO: This is a hack. It should be some other way to + ## indicate that the transaction should be "silent". + + my ( $Sender, $junk ) = ParseSenderAddressFromHead($head); + $head->add( 'RT-Squelch-Replies-To', $Sender ); + } + + # }}} + + my $Ticket = RT::Ticket->new($CurrentUser); + + # {{{ If we don't have a ticket Id, we're creating a new ticket + if ( !$args{'ticket'} ) { + + # {{{ Create a new ticket + + my @Cc; + my @Requestors = ( $CurrentUser->id ); + + if ($RT::ParseNewMessageForTicketCcs) { + @Cc = ParseCcAddressesFromHead( Head => $head, + CurrentUser => $CurrentUser, + QueueObj => $SystemQueueObj ); + } + + my ( $id, $Transaction, $ErrStr ) = $Ticket->Create( + Queue => $SystemQueueObj->Id, + Subject => $Subject, + Requestor => \@Requestors, + Cc => \@Cc, + MIMEObj => $Message ); + if ( $id == 0 ) { + MailError( To => $ErrorsTo, + Subject => "Ticket creation failed", + Explanation => $ErrStr, + MIMEObj => $Message ); + $RT::Logger->error("Create failed: $id / $Transaction / $ErrStr "); + return ( 0, "Ticket creation failed", $Ticket ); + } + + # }}} + } + + # }}} + + # If the action is comment, add a comment. + elsif ( $args{'action'} =~ /^(comment|correspond)$/i ) { + $Ticket->Load($args{'ticket'}); + unless ( $Ticket->Id ) { + my $message = "Could not find a ticket with id ".$args{'ticket'}; + MailError( To => $ErrorsTo, + Subject => "Message not recorded", + Explanation => $message, + MIMEObj => $Message ); + + return ( 0, $message); + } + + my ( $status, $msg ); + if ( $args{'action'} =~ /^correspond$/ ) { + ( $status, $msg ) = $Ticket->Correspond( MIMEObj => $Message ); + } + else { + ( $status, $msg ) = $Ticket->Comment( MIMEObj => $Message ); + } + unless ($status) { + + #Warn the sender that we couldn't actually submit the comment. + MailError( To => $ErrorsTo, + Subject => "Message not recorded", + Explanation => $msg, + MIMEObj => $Message ); + return ( 0, "Message not recorded", $Ticket ); + } + } + + else { + + #Return mail to the sender with an error + MailError( To => $ErrorsTo, + Subject => "RT Configuration error", + Explanation => "'" + . $args{'action'} + . "' not a recognized action." + . " Your RT administrator has misconfigured " + . "the mail aliases which invoke RT", + MIMEObj => $Message ); + $RT::Logger->crit( $args{'action'} . " type unknown for $MessageId" ); + return ( 0, "Configuration error: " . $args{'action'} . " not a recognized action", $Ticket ); + + } + + +return ( 1, "Success", $Ticket ); +} + +eval "require RT::Interface::Email_Vendor"; +die $@ if ($@ && $@ !~ qr{^Can't locate RT/Interface/Email_Vendor.pm}); +eval "require RT::Interface::Email_Local"; +die $@ if ($@ && $@ !~ qr{^Can't locate RT/Interface/Email_Local.pm}); + 1; diff --git a/rt/lib/RT/Interface/Email/Auth/MailFrom.pm b/rt/lib/RT/Interface/Email/Auth/MailFrom.pm new file mode 100644 index 000000000..eb778ff30 --- /dev/null +++ b/rt/lib/RT/Interface/Email/Auth/MailFrom.pm @@ -0,0 +1,131 @@ +# BEGIN LICENSE BLOCK +# +# Copyright (c) 1996-2003 Jesse Vincent +# +# (Except where explictly superceded by other copyright notices) +# +# This work is made available to you under the terms of Version 2 of +# the GNU General Public License. A copy of that license should have +# been provided with this software, but in any event can be snarfed +# from www.gnu.org. +# +# This work is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# Unless otherwise specified, all modifications, corrections or +# extensions to this work which alter its source code become the +# property of Best Practical Solutions, LLC when submitted for +# inclusion in the work. +# +# +# END LICENSE BLOCK +package RT::Interface::Email::Auth::MailFrom; +use RT::Interface::Email qw(ParseSenderAddressFromHead CreateUser); + +# This is what the ordinary, non-enhanced gateway does at the moment. + +sub GetCurrentUser { + my %args = ( Message => undef, + CurrentUser => undef, + AuthLevel => undef, + Ticket => undef, + Queue => undef, + Action => undef, + @_ ); + + # We don't need to do any external lookups + my ( $Address, $Name ) = ParseSenderAddressFromHead( $args{'Message'}->head ); + my $CurrentUser = RT::CurrentUser->new(); + $CurrentUser->LoadByEmail($Address); + + unless ( $CurrentUser->Id ) { + $CurrentUser->LoadByName($Address); + } + + if ( $CurrentUser->Id ) { + return ( $CurrentUser, 1 ); + } + + + + # If the user can't be loaded, we may need to create one. Figure out the acl situation. + my $unpriv = RT::Group->new($RT::SystemUser); + $unpriv->LoadSystemInternalGroup('Unprivileged'); + unless ( $unpriv->Id ) { + $RT::Logger->crit( "Auth::MailFrom couldn't find the 'Unprivileged' internal group" ); + return ( $args{'CurrentUser'}, -1 ); + } + + my $everyone = RT::Group->new($RT::SystemUser); + $everyone->LoadSystemInternalGroup('Everyone'); + unless ( $everyone->Id ) { + $RT::Logger->crit( "Auth::MailFrom couldn't find the 'Everyone' internal group"); + return ( $args{'CurrentUser'}, -1 ); + } + + # but before we do that, we need to make sure that the created user would have the right + # to do what we're doing. + if ( $args{'Ticket'} && $args{'Ticket'}->Id ) { + # We have a ticket. that means we're commenting or corresponding + if ( $args{'Action'} =~ /^comment$/i ) { + + # check to see whether "Everybody" or "Unprivileged users" can comment on tickets + unless ( $everyone->PrincipalObj->HasRight( + Object => $args{'Queue'}, + Right => 'CommentOnTicket' + ) + || $unpriv->PrincipalObj->HasRight( + Object => $args{'Queue'}, + Right => 'CommentOnTicket' + ) + ) { + return ( $args{'CurrentUser'}, 0 ); + } + } + elsif ( $args{'Action'} =~ /^correspond$/i ) { + + # check to see whether "Everybody" or "Unprivileged users" can correspond on tickets + unless ( $everyone->PrincipalObj->HasRight(Object => $args{'Queue'}, + Right => 'ReplyToTicket' + ) + || $unpriv->PrincipalObj->HasRight( + Object => $args{'Queue'}, + Right => 'ReplyToTicket' + ) + ) { + return ( $args{'CurrentUser'}, 0 ); + } + + } + else { + return ( $args{'CurrentUser'}, 0 ); + } + } + + # We're creating a ticket + elsif ( $args{'Queue'} && $args{'Queue'}->Id ) { + + # check to see whether "Everybody" or "Unprivileged users" can create tickets in this queue + unless ( $everyone->PrincipalObj->HasRight( Object => $args{'Queue'}, + Right => 'CreateTicket' ) + || $unpriv->PrincipalObj->HasRight( Object => $args{'Queue'}, + Right => 'CreateTicket' ) + ) { + return ( $args{'CurrentUser'}, 0 ); + } + + } + + $CurrentUser = CreateUser( undef, $Address, $Name, $args{'Message'} ); + + return ( $CurrentUser, 1 ); +} + +eval "require RT::Interface::Email::Auth::MailFrom_Vendor"; +die $@ if ($@ && $@ !~ qr{^Can't locate RT/Interface/Email/Auth/MailFrom_Vendor.pm}); +eval "require RT::Interface::Email::Auth::MailFrom_Local"; +die $@ if ($@ && $@ !~ qr{^Can't locate RT/Interface/Email/Auth/MailFrom_Local.pm}); + +1; diff --git a/rt/lib/RT/Interface/Email/Filter/SpamAssassin.pm b/rt/lib/RT/Interface/Email/Filter/SpamAssassin.pm new file mode 100644 index 000000000..f00e2d82b --- /dev/null +++ b/rt/lib/RT/Interface/Email/Filter/SpamAssassin.pm @@ -0,0 +1,63 @@ +# BEGIN LICENSE BLOCK +# +# Copyright (c) 1996-2003 Jesse Vincent +# +# (Except where explictly superceded by other copyright notices) +# +# This work is made available to you under the terms of Version 2 of +# the GNU General Public License. A copy of that license should have +# been provided with this software, but in any event can be snarfed +# from www.gnu.org. +# +# This work is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# Unless otherwise specified, all modifications, corrections or +# extensions to this work which alter its source code become the +# property of Best Practical Solutions, LLC when submitted for +# inclusion in the work. +# +# +# END LICENSE BLOCK +package RT::Interface::Email::Filter::SpamAssassin; + +use Mail::SpamAssassin; +my $spamtest = Mail::SpamAssassin->new(); + +sub GetCurrentUser { + my $item = shift; + my $status = $spamtest->check ($item); + return (undef, 0) unless $status->is_spam(); + eval { $status->rewrite_mail() }; + if ($status->get_hits > $status->get_required_hits()*1.5) { + # Spammy indeed + return (undef, -1); + } + return (undef, 0); +} + +=head1 NAME + +RT::Interface::Email::Filter::SpamAssassin - Spam filter for RT + +=head1 SYNOPSIS + + @RT::MailPlugins = ("Filter::SpamAssassin", ...); + +=head1 DESCRIPTION + +This plugin checks to see if an incoming mail is spam (using +C) and if so, rewrites its headers. If the mail is very +definitely spam - 1.5x more hits than required - then it is dropped on +the floor; otherwise, it is passed on as normal. + +=cut + +eval "require RT::Interface::Email::Filter::SpamAssassin_Vendor"; +die $@ if ($@ && $@ !~ qr{^Can't locate RT/Interface/Email/Filter/SpamAssassin_Vendor.pm}); +eval "require RT::Interface::Email::Filter::SpamAssassin_Local"; +die $@ if ($@ && $@ !~ qr{^Can't locate RT/Interface/Email/Filter/SpamAssassin_Local.pm}); + +1; diff --git a/rt/lib/RT/Interface/Web.pm b/rt/lib/RT/Interface/Web.pm index 6b5272848..5097f54a4 100644 --- a/rt/lib/RT/Interface/Web.pm +++ b/rt/lib/RT/Interface/Web.pm @@ -1,129 +1,214 @@ -## $Header: /home/cvs/cvsroot/freeside/rt/lib/RT/Interface/Web.pm,v 1.1 2002-08-12 06:17:08 ivan Exp $ - +# BEGIN LICENSE BLOCK +# +# Copyright (c) 1996-2003 Jesse Vincent +# +# (Except where explictly superceded by other copyright notices) +# +# This work is made available to you under the terms of Version 2 of +# the GNU General Public License. A copy of that license should have +# been provided with this software, but in any event can be snarfed +# from www.gnu.org. +# +# This work is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# Unless otherwise specified, all modifications, corrections or +# extensions to this work which alter its source code become the +# property of Best Practical Solutions, LLC when submitted for +# inclusion in the work. +# +# +# END LICENSE BLOCK ## Portions Copyright 2000 Tobias Brox -## Copyright 1996-2002 Jesse Vincent ## This is a library of static subs to be used by the Mason web ## interface to RT + +=head1 NAME + +RT::Interface::Web + +=begin testing + +use_ok(RT::Interface::Web); + +=end testing + +=cut + + package RT::Interface::Web; +use strict; -# {{{ sub NewParser -=head2 NewParser - Returns a new Mason::Parser object. Takes a param hash of things - that get passed to HTML::Mason::Parser. Currently hard coded to only - take the parameter 'allow_globals'. + + +# {{{ sub NewApacheHandler + +=head2 NewApacheHandler + + Takes extra options to pass to HTML::Mason::ApacheHandler->new + Returns a new Mason::ApacheHandler object =cut -sub NewParser { - my %args = ( - allow_globals => undef, +sub NewApacheHandler { + require HTML::Mason::ApacheHandler; + my $ah = new HTML::Mason::ApacheHandler( + + comp_root => [ + [ local => $RT::MasonLocalComponentRoot ], + [ standard => $RT::MasonComponentRoot ] + ], + args_method => "CGI", + default_escape_flags => 'h', + allow_globals => [qw(%session)], + data_dir => "$RT::MasonDataDir", @_ ); - my $parser = new HTML::Mason::Parser( - default_escape_flags => 'h', - allow_globals => $args{'allow_globals'} - ); - return ($parser); + $ah->interp->set_escape( h => \&RT::Interface::Web::EscapeUTF8 ); + + return ($ah); } # }}} -# {{{ sub NewInterp +# {{{ sub NewCGIHandler -=head2 NewInterp +=head2 NewCGIHandler - Takes a paremeter hash. Needs a param called 'parser' which is a reference - to an HTML::Mason::Parser. - returns a new Mason::Interp object + Returns a new Mason::CGIHandler object =cut -sub NewInterp { - my %params = ( +sub NewCGIHandler { + my %args = ( + @_ + ); + + my $handler = HTML::Mason::CGIHandler->new( comp_root => [ [ local => $RT::MasonLocalComponentRoot ], [ standard => $RT::MasonComponentRoot ] ], data_dir => "$RT::MasonDataDir", - @_ + default_escape_flags => 'h', + allow_globals => [qw(%session)] ); + - #We allow recursive autohandlers to allow for RT auth. + $handler->interp->set_escape( h => \&RT::Interface::Web::EscapeUTF8 ); - use HTML::Mason::Interp; - my $interp = new HTML::Mason::Interp(%params); -} + return ($handler); +} # }}} -# {{{ sub NewApacheHandler -=head2 NewApacheHandler +# {{{ EscapeUTF8 - Takes a Mason::Interp object - Returns a new Mason::ApacheHandler object +=head2 EscapeUTF8 SCALARREF + +does a css-busting but minimalist escaping of whatever html you're passing in. =cut -sub NewApacheHandler { - my $interp = shift; - my $ah = new HTML::Mason::ApacheHandler( interp => $interp ); - return ($ah); +sub EscapeUTF8 { + my $ref = shift; + my $val = $$ref; + use bytes; + $val =~ s/&/&/g; + $val =~ s//>/g; + $val =~ s/\(/(/g; + $val =~ s/\)/)/g; + $val =~ s/"/"/g; + $val =~ s/'/'/g; + $$ref = $val; + Encode::_utf8_on($$ref); + } # }}} -# {{{ sub NewMason11ApacheHandler +package HTML::Mason::Commands; +use strict; +use vars qw/$r $m %session/; -=head2 NewMason11ApacheHandler - Returns a new Mason::ApacheHandler object +# {{{ loc + +=head2 loc ARRAY + +loc is a nice clean global routine which calls $session{'CurrentUser'}->loc() +with whatever it's called with. If there is no $session{'CurrentUser'}, +it creates a temporary user, so we have something to get a localisation handle +through =cut -sub NewMason11ApacheHandler { - my %args = ( default_escape_flags => 'h', - allow_globals => [%session], - comp_root => [ - [ local => $RT::MasonLocalComponentRoot ], - [ standard => $RT::MasonComponentRoot ] - ], - data_dir => "$RT::MasonDataDir", - args_method => 'CGI' - ); - my $ah = new HTML::Mason::ApacheHandler(%args); - return ($ah); +sub loc { + + if ($session{'CurrentUser'} && + UNIVERSAL::can($session{'CurrentUser'}, 'loc')){ + return($session{'CurrentUser'}->loc(@_)); + } + else { + my $u = RT::CurrentUser->new($RT::SystemUser); + return ($u->loc(@_)); + } } # }}} +# {{{ loc_fuzzy + +=head2 loc_fuzzy STRING +loc_fuzzy is for handling localizations of messages that may already +contain interpolated variables, typically returned from libraries +outside RT's control. It takes the message string and extracts the +variable array automatically by matching against the candidate entries +inside the lexicon file. + +=cut +sub loc_fuzzy { + my $msg = shift; + + if ($session{'CurrentUser'} && + UNIVERSAL::can($session{'CurrentUser'}, 'loc')){ + return($session{'CurrentUser'}->loc_fuzzy($msg)); + } + else { + my $u = RT::CurrentUser->new($RT::SystemUser); + return ($u->loc_fuzzy($msg)); + } +} # }}} -package HTML::Mason::Commands; # {{{ sub Abort # Error - calls Error and aborts sub Abort { - if ( $session{'ErrorDocument'} && $session{'ErrorDocumentType'} ) { - SetContentType( $session{'ErrorDocumentType'} ); - $m->comp( $session{'ErrorDocument'}, Why => shift ); + if ($session{'ErrorDocument'} && + $session{'ErrorDocumentType'}) { + $r->content_type($session{'ErrorDocumentType'}); + $m->comp($session{'ErrorDocument'} , Why => shift); $m->abort; - } - else { - SetContentType('text/html'); - $m->comp( "/Elements/Error", Why => shift ); + } + else { + $m->comp("/Elements/Error" , Why => shift); $m->abort; } } @@ -135,6 +220,7 @@ sub Abort { =head2 CreateTicket ARGS Create a new ticket, using Mason's %ARGS. returns @results. + =cut sub CreateTicket { @@ -158,38 +244,45 @@ sub CreateTicket { my $starts = new RT::Date( $session{'CurrentUser'} ); $starts->Set( Format => 'unknown', Value => $ARGS{'Starts'} ); - my @Requestors = split ( /,/, $ARGS{'Requestors'} ); - my @Cc = split ( /,/, $ARGS{'Cc'} ); - my @AdminCc = split ( /,/, $ARGS{'AdminCc'} ); + my @Requestors = split ( /\s*,\s*/, $ARGS{'Requestors'} ); + my @Cc = split ( /\s*,\s*/, $ARGS{'Cc'} ); + my @AdminCc = split ( /\s*,\s*/, $ARGS{'AdminCc'} ); my $MIMEObj = MakeMIMEEntity( Subject => $ARGS{'Subject'}, From => $ARGS{'From'}, Cc => $ARGS{'Cc'}, Body => $ARGS{'Content'}, - AttachmentFieldName => 'Attach' ); + if ($ARGS{'Attachments'}) { + $MIMEObj->make_multipart; + $MIMEObj->add_part($_) foreach values %{$ARGS{'Attachments'}}; + } + my %create_args = ( - Queue => $ARGS{Queue}, - Owner => $ARGS{Owner}, - InitialPriority => $ARGS{InitialPriority}, - FinalPriority => $ARGS{FinalPriority}, - TimeLeft => $ARGS{TimeLeft}, - TimeWorked => $ARGS{TimeWorked}, + Queue => $ARGS{'Queue'}, + Owner => $ARGS{'Owner'}, + InitialPriority => $ARGS{'InitialPriority'}, + FinalPriority => $ARGS{'FinalPriority'}, + TimeLeft => $ARGS{'TimeLeft'}, + TimeEstimated => $ARGS{'TimeEstimated'}, + TimeWorked => $ARGS{'TimeWorked'}, Requestor => \@Requestors, Cc => \@Cc, AdminCc => \@AdminCc, - Subject => $ARGS{Subject}, - Status => $ARGS{Status}, + Subject => $ARGS{'Subject'}, + Status => $ARGS{'Status'}, Due => $due->ISO, Starts => $starts->ISO, MIMEObj => $MIMEObj ); - - # we need to get any KeywordSelect- fields into %create_args.. - grep { $_ =~ /^KeywordSelect-/ &&{ $create_args{$_} = $ARGS{$_} } } %ARGS; - + foreach my $arg (%ARGS) { + if ($arg =~ /^CustomField-(\d+)(.*?)$/) { + next if ($arg =~ /-Magic$/); + $create_args{"CustomField-".$1} = $ARGS{"$arg"}; + } + } my ( $id, $Trans, $ErrMsg ) = $Ticket->Create(%create_args); unless ( $id && $Trans ) { Abort($ErrMsg); @@ -216,7 +309,7 @@ sub CreateTicket { } } - push ( @Actions, $ErrMsg ); + push ( @Actions, split("\n", $ErrMsg) ); unless ( $Ticket->CurrentUserHasRight('ShowTicket') ) { Abort( "No permission to view newly created ticket #" . $Ticket->id . "." ); @@ -283,80 +376,38 @@ sub ProcessUpdateMessage { my $Message = MakeMIMEEntity( Subject => $args{ARGSRef}->{'UpdateSubject'}, Body => $args{ARGSRef}->{'UpdateContent'}, - AttachmentFieldName => 'UpdateAttachment' ); - ## Check whether this was a refresh or not. - - # Match Correspondence or Comments. - my $trans_flag = -2; - my $trans_type = undef; - my $orig_trans = $args{ARGSRef}->{'UpdateType'}; - if ( $orig_trans =~ /^(private|public)$/ ) { - $trans_type = "Comment"; - }elsif ( $orig_trans eq 'response' ) { - $trans_type = "Correspond"; - } - - # Do we have a transaction that we need to update on? session - if( defined( $trans_type ) ){ - $trans_flag = 0; - - # Prepare a checksum. - # See perldoc -f unpack for example of this. - my $this_checksum = unpack("%32C*", $Message->body_as_string ) % 65535; - - # The above *could* generate duplicate checksums. Crosscheck with - # the length. - my $this_length = length( $Message->body_as_string ); - - # Don't forget the ticket id. - my $this_id = $args{TicketObj}->id; - - # Check whether the previous transaction in the - # ticket is the same as the current transaction. - if( defined( $session{'prev_trans_type'} ) && defined( $session{'prev_trans_chksum'} ) && defined( $session{'prev_trans_length'} ) && defined( $session{'prev_trans_tickid'} ) ){ - if( $session{'prev_trans_type'} eq $orig_trans && $session{'prev_trans_chksum'} == $this_checksum && $session{'prev_trans_length'} == $this_length && $session{'prev_trans_tickid'} == $this_id ){ - # Its the same as the previous transaction for this user. - $trans_flag = -1; - } - } - - # Store them for next time. - $session{'prev_trans_type'} = $orig_trans; - $session{'prev_trans_chksum'} = $this_checksum; - $session{'prev_trans_length'} = $this_length; - $session{'prev_trans_tickid'} = $this_id; - - if( $trans_flag == -1 ){ - push ( @{ $args{'Actions'} }, -"This appears to be a duplicate of your previous update (please do not refresh this page)" ); - } - - - if ( $trans_type eq 'Comment' && $trans_flag >= 0 ) { - my ( $Transaction, $Description ) = $args{TicketObj}->Comment( - CcMessageTo => $args{ARGSRef}->{'UpdateCc'}, - BccMessageTo => $args{ARGSRef}->{'UpdateBcc'}, - MIMEObj => $Message, - TimeTaken => $args{ARGSRef}->{'UpdateTimeWorked'} - ); - push ( @{ $args{Actions} }, $Description ); - } - elsif ( $trans_type eq 'Correspond' && $trans_flag >= 0 ) { - my ( $Transaction, $Description ) = $args{TicketObj}->Correspond( - CcMessageTo => $args{ARGSRef}->{'UpdateCc'}, - BccMessageTo => $args{ARGSRef}->{'UpdateBcc'}, - MIMEObj => $Message, - TimeTaken => $args{ARGSRef}->{'UpdateTimeWorked'} - ); - push ( @{ $args{Actions} }, $Description ); - } - } + if ($args{ARGSRef}->{'UpdateAttachments'}) { + $Message->make_multipart; + $Message->add_part($_) foreach values %{$args{ARGSRef}->{'UpdateAttachments'}}; + } + + ## TODO: Implement public comments + if ( $args{ARGSRef}->{'UpdateType'} =~ /^(private|public)$/ ) { + my ( $Transaction, $Description ) = $args{TicketObj}->Comment( + CcMessageTo => $args{ARGSRef}->{'UpdateCc'}, + BccMessageTo => $args{ARGSRef}->{'UpdateBcc'}, + MIMEObj => $Message, + TimeTaken => $args{ARGSRef}->{'UpdateTimeWorked'} + ); + push ( @{ $args{Actions} }, $Description ); + } + elsif ( $args{ARGSRef}->{'UpdateType'} eq 'response' ) { + my ( $Transaction, $Description ) = $args{TicketObj}->Correspond( + CcMessageTo => $args{ARGSRef}->{'UpdateCc'}, + BccMessageTo => $args{ARGSRef}->{'UpdateBcc'}, + MIMEObj => $Message, + TimeTaken => $args{ARGSRef}->{'UpdateTimeWorked'} + ); + push ( @{ $args{Actions} }, $Description ); + } else { push ( @{ $args{'Actions'} }, - "Update type was neither correspondence nor comment. Update not recorded" - ); + loc("Update type was neither correspondence nor comment."). + " ". + loc("Update not recorded.") + ); } } } @@ -382,61 +433,66 @@ sub MakeMIMEEntity { Cc => undef, Body => undef, AttachmentFieldName => undef, - @_ + map Encode::encode_utf8($_), @_, ); #Make the update content have no 'weird' newlines in it $args{'Body'} =~ s/\r\n/\n/gs; - my $Message = MIME::Entity->build( - Subject => $args{'Subject'} || "", - From => $args{'From'}, - Cc => $args{'Cc'}, - Data => [ $args{'Body'} ] - ); + my $Message; + { + # MIME::Head is not happy in utf-8 domain. This only happens + # when processing an incoming email (so far observed). + no utf8; + use bytes; + $Message = MIME::Entity->build( + Subject => $args{'Subject'} || "", + From => $args{'From'}, + Cc => $args{'Cc'}, + Data => [ $args{'Body'} ] + ); + } - my $cgi_object = CGIObject(); - if ( $cgi_object->param( $args{'AttachmentFieldName'} ) ) { + my $cgi_object = $m->cgi_object; - my $cgi_filehandle = - $cgi_object->upload( $args{'AttachmentFieldName'} ); + if (my $filehandle = $cgi_object->upload( $args{'AttachmentFieldName'} ) ) { - use File::Temp qw(tempfile tempdir); - #foreach my $filehandle (@filenames) { - # my ( $fh, $temp_file ) = tempfile(); + use File::Temp qw(tempfile tempdir); - #$binmode $fh; #thank you, windows + #foreach my $filehandle (@filenames) { - # We're having trouble with tempfiles not getting created. Let's try it with - # a scalar instead + my ( $fh, $temp_file ) = tempfile(); - my ( $buffer, @file ); + binmode $fh; #thank you, windows + my ($buffer); + while ( my $bytesread = read( $filehandle, $buffer, 4096 ) ) { + print $fh $buffer; + } - while ( my $bytesread = read( $cgi_filehandle, $buffer, 4096 ) ) { - push ( @file, $buffer ); - } + my $uploadinfo = $cgi_object->uploadInfo($filehandle); - $RT::Logger->debug($file); - my $filename = "$cgi_filehandle"; - $filename =~ s#^(.*)/##; - $filename =~ s#^(.*)\\##; - my $uploadinfo = $cgi_object->uploadInfo($cgi_filehandle); - $Message->attach( - Data => \@file, - - #Path => $temp_file, - Filename => $filename, - Type => $uploadinfo->{'Content-Type'} - ); + # Prefer the cached name first over CGI.pm stringification. + my $filename = $RT::Mason::CGI::Filename; + $filename = "$filehandle" unless defined($filename); + + $filename =~ s#^.*[\\/]##; + + $Message->attach( + Path => $temp_file, + Filename => $filename, + Type => $uploadinfo->{'Content-Type'}, + ); + close($fh); - #close($fh); - #unlink($temp_file); + # } - # } } + $Message->make_singlepart(); + RT::I18N::SetMIMEEntityToUTF8($Message); # convert text parts into utf-8 + return ($Message); } @@ -485,6 +541,9 @@ sub ProcessSearchQuery { elsif ( $args{ARGS}->{'GotoPage'} eq 'Prev' ) { $session{'tickets'}->PrevPage; } + elsif ( $args{ARGS}->{'GotoPage'} > 0 ) { + $session{'tickets'}->GotoPage( $args{ARGS}->{GotoPage} - 1 ); + } # }}} @@ -576,8 +635,12 @@ sub ProcessSearchQuery { # }}} # {{{ Limit Subject if ( $args{ARGS}->{'ValueOfSubject'} ne '' ) { + my $val = $args{ARGS}->{'ValueOfSubject'}; + if ($args{ARGS}->{'SubjectOp'} =~ /like/) { + $val = "%".$val."%"; + } $session{'tickets'}->LimitSubject( - VALUE => $args{ARGS}->{'ValueOfSubject'}, + VALUE => $val, OPERATOR => $args{ARGS}->{'SubjectOp'}, ); } @@ -585,40 +648,59 @@ sub ProcessSearchQuery { # }}} # {{{ Limit Dates if ( $args{ARGS}->{'ValueOfDate'} ne '' ) { - my $date = ParseDateToISO( $args{ARGS}->{'ValueOfDate'} ); $args{ARGS}->{'DateType'} =~ s/_Date$//; - $session{'tickets'}->LimitDate( - FIELD => $args{ARGS}->{'DateType'}, - VALUE => $date, - OPERATOR => $args{ARGS}->{'DateOp'}, - ); + if ( $args{ARGS}->{'DateType'} eq 'Updated' ) { + $session{'tickets'}->LimitTransactionDate( + VALUE => $date, + OPERATOR => $args{ARGS}->{'DateOp'}, + ); + } + else { + $session{'tickets'}->LimitDate( FIELD => $args{ARGS}->{'DateType'}, + VALUE => $date, + OPERATOR => $args{ARGS}->{'DateOp'}, + ); + } } # }}} # {{{ Limit Content - if ( $args{ARGS}->{'ValueOfContent'} ne '' ) { - $session{'tickets'}->LimitContent( - VALUE => $args{ARGS}->{'ValueOfContent'}, - OPERATOR => $args{ARGS}->{'ContentOp'}, + if ( $args{ARGS}->{'ValueOfAttachmentField'} ne '' ) { + my $val = $args{ARGS}->{'ValueOfAttachmentField'}; + if ($args{ARGS}->{'AttachmentFieldOp'} =~ /like/) { + $val = "%".$val."%"; + } + $session{'tickets'}->Limit( + FIELD => $args{ARGS}->{'AttachmentField'}, + VALUE => $val, + OPERATOR => $args{ARGS}->{'AttachmentFieldOp'}, ); } # }}} - # {{{ Limit KeywordSelects - foreach my $KeywordSelectId ( - map { /^KeywordSelect(\d+)$/; $1 } - grep { /^KeywordSelect(\d+)$/; } keys %{ $args{ARGS} } - ) - { - my $form = $args{ARGS}->{"KeywordSelect$KeywordSelectId"}; - my $oper = $args{ARGS}->{"KeywordSelectOp$KeywordSelectId"}; - foreach my $KeywordId ( ref($form) ? @{$form} : ($form) ) { - next unless ($KeywordId); + # {{{ Limit CustomFields + + foreach my $arg ( keys %{ $args{ARGS} } ) { + my $id; + if ( $arg =~ /^CustomField(\d+)$/ ) { + $id = $1; + } + else { + next; + } + next unless ( $args{ARGS}->{$arg} ); + + my $form = $args{ARGS}->{$arg}; + my $oper = $args{ARGS}->{ "CustomFieldOp" . $id }; + foreach my $value ( ref($form) ? @{$form} : ($form) ) { my $quote = 1; - if ( $KeywordId =~ /^null$/i ) { + if ($oper =~ /like/i) { + $value = "%".$value."%"; + } + if ( $value =~ /^null$/i ) { #Don't quote the string 'null' $quote = 0; @@ -627,17 +709,16 @@ sub ProcessSearchQuery { $oper = 'IS' if ( $oper eq '=' ); $oper = 'IS NOT' if ( $oper eq '!=' ); } - $session{'tickets'}->LimitKeyword( - KEYWORDSELECT => $KeywordSelectId, - OPERATOR => $oper, - QUOTEVALUE => $quote, - KEYWORD => $KeywordId - ); + $session{'tickets'}->LimitCustomField( CUSTOMFIELD => $id, + OPERATOR => $oper, + QUOTEVALUE => $quote, + VALUE => $value ); } } # }}} + } # }}} @@ -654,7 +735,7 @@ Returns an ISO date and time in GMT sub ParseDateToISO { my $date = shift; - my $date_obj = new RT::Date($CurrentUser); + my $date_obj = RT::Date->new($session{'CurrentUser'}); $date_obj->Set( Format => 'unknown', Value => $date @@ -680,172 +761,82 @@ sub Config { # {{{ sub ProcessACLChanges sub ProcessACLChanges { - my $ACLref = shift; my $ARGSref = shift; - my @CheckACL = @$ACLref; my %ARGS = %$ARGSref; my ( $ACL, @results ); - # {{{ Add rights - foreach $ACL (@CheckACL) { - my ($Principal); - next unless ($ACL); + foreach my $arg (keys %ARGS) { + if ($arg =~ /GrantRight-(\d+)-(.*?)-(\d+)$/) { + my $principal_id = $1; + my $object_type = $2; + my $object_id = $3; + my $rights = $ARGS{$arg}; - # Parse out what we're really talking about. - if ( $ACL =~ /^(.*?)-(\d+)-(.*?)-(\d+)/ ) { - my $PrincipalType = $1; - my $PrincipalId = $2; - my $Scope = $3; - my $AppliesTo = $4; + my $principal = RT::Principal->new($session{'CurrentUser'}); + $principal->Load($principal_id); - # {{{ Create an object called Principal - # so we can do rights operations + my $obj; - if ( $PrincipalType eq 'User' ) { - $Principal = new RT::User( $session{'CurrentUser'} ); - } - elsif ( $PrincipalType eq 'Group' ) { - $Principal = new RT::Group( $session{'CurrentUser'} ); - } - else { - Abort("$PrincipalType unknown principal type"); - } + if ($object_type eq 'RT::Queue') { + $obj = RT::Queue->new($session{'CurrentUser'}); + $obj->Load($object_id); + } elsif ($object_type eq 'RT::Group') { + $obj = RT::Group->new($session{'CurrentUser'}); + $obj->Load($object_id); - $Principal->Load($PrincipalId) - || Abort("$PrincipalType $PrincipalId couldn't be loaded"); - - # }}} - - # {{{ load up an RT::ACL object with the same current vals of this ACL - - my $CurrentACL = new RT::ACL( $session{'CurrentUser'} ); - if ( $Scope eq 'Queue' ) { - $CurrentACL->LimitToQueue($AppliesTo); + } elsif ($object_type eq 'RT::System') { + $obj = $RT::System; + } else { + push (@results, loc("System Error"). + loc("Rights could not be granted for [_1]", $object_type)); + next; } - elsif ( $Scope eq 'System' ) { - $CurrentACL->LimitToSystem(); - } - - $CurrentACL->LimitPrincipalToType($PrincipalType); - $CurrentACL->LimitPrincipalToId($PrincipalId); - - # }}} - - # {{{ Get the values of the select we're working with - # into an array. it will contain all the new rights that have - # been granted - #Hack to turn the ACL returned into an array - my @rights = - ref( $ARGS{"GrantACE-$ACL"} ) eq 'ARRAY' - ? @{ $ARGS{"GrantACE-$ACL"} } - : ( $ARGS{"GrantACE-$ACL"} ); - - # }}} - - # {{{ Add any rights we need. + my @rights = ref($ARGS{$arg}) eq 'ARRAY' ? @{$ARGS{$arg}} : ($ARGS{$arg}); foreach my $right (@rights) { next unless ($right); - - #if the right that's been selected wasn't there before, add it. - unless ( - $CurrentACL->HasEntry( - RightScope => "$Scope", - RightName => "$right", - RightAppliesTo => "$AppliesTo", - PrincipalType => $PrincipalType, - PrincipalId => $Principal->Id - ) - ) - { - - #Add new entry to list of rights. - if ( $Scope eq 'Queue' ) { - my $Queue = new RT::Queue( $session{'CurrentUser'} ); - $Queue->Load($AppliesTo); - unless ( $Queue->id ) { - Abort("Couldn't find a queue called $AppliesTo"); - } - - my ( $val, $msg ) = $Principal->GrantQueueRight( - RightAppliesTo => $Queue->id, - RightName => "$right" - ); - - if ($val) { - push ( @results, - "Granted right $right to " - . $Principal->Name - . " for queue " - . $Queue->Name ); - } - else { - push ( @results, $msg ); - } - } - elsif ( $Scope eq 'System' ) { - my ( $val, $msg ) = $Principal->GrantSystemRight( - RightAppliesTo => $AppliesTo, - RightName => "$right" - ); - if ($val) { - push ( @results, "Granted system right '$right' to " - . $Principal->Name ); - } - else { - push ( @results, $msg ); - } - } - } + my ($val, $msg) = $principal->GrantRight(Object => $obj, Right => $right); + push (@results, $msg); } - - # }}} } - } - - # }}} Add rights - - # {{{ remove any rights that have been deleted - - my @RevokeACE = - ref( $ARGS{"RevokeACE"} ) eq 'ARRAY' - ? @{ $ARGS{"RevokeACE"} } - : ( $ARGS{"RevokeACE"} ); - - foreach my $aceid (@RevokeACE) { - - my $right = new RT::ACE( $session{'CurrentUser'} ); - $right->Load($aceid); - next unless ( $right->id ); + elsif ($arg =~ /RevokeRight-(\d+)-(.*?)-(\d+)-(.*?)$/) { + my $principal_id = $1; + my $object_type = $2; + my $object_id = $3; + my $right = $4; + + my $principal = RT::Principal->new($session{'CurrentUser'}); + $principal->Load($principal_id); + next unless ($right); + my $obj; + + if ($object_type eq 'RT::Queue') { + $obj = RT::Queue->new($session{'CurrentUser'}); + $obj->Load($object_id); + } elsif ($object_type eq 'RT::Group') { + $obj = RT::Group->new($session{'CurrentUser'}); + $obj->Load($object_id); + + } elsif ($object_type eq 'RT::System') { + $obj = $RT::System; + } else { + push (@results, loc("System Error"). + loc("Rights could not be revoked for [_1]", $object_type)); + next; + } + my ($val, $msg) = $principal->RevokeRight(Object => $obj, Right => $right); + push (@results, $msg); + } - my $phrase = "Revoked " - . $right->PrincipalType . " " - . $right->PrincipalObj->Name - . "'s right to " - . $right->RightName; - if ( $right->RightScope eq 'System' ) { - $phrase .= ' across all queues.'; - } - else { - $phrase .= ' for the queue ' . $right->AppliesToObj->Name . '.'; - } - my ( $val, $msg ) = $right->Delete(); - if ($val) { - push ( @results, $phrase ); - } - else { - push ( @results, $msg ); - } } - # }}} - return (@results); -} + + } # }}} @@ -864,6 +855,7 @@ sub UpdateRecordObject { ARGSRef => undef, AttributesRef => undef, Object => undef, + AttributePrefix => undef, @_ ); @@ -872,17 +864,94 @@ sub UpdateRecordObject { my $object = $args{'Object'}; my $attributes = $args{'AttributesRef'}; my $ARGSRef = $args{'ARGSRef'}; + foreach my $attribute (@$attributes) { + my $value; + if ( defined $ARGSRef->{$attribute} ) { + $value = $ARGSRef->{$attribute}; + } + elsif ( + defined( $args{'AttributePrefix'} ) + && defined( + $ARGSRef->{ $args{'AttributePrefix'} . "-" . $attribute } + ) + ) { + $value = $ARGSRef->{ $args{'AttributePrefix'} . "-" . $attribute }; + + } else { + next; + } - foreach $attribute (@$attributes) { - if ( ( defined $ARGSRef->{"$attribute"} ) - and ( $ARGSRef->{"$attribute"} ne $object->$attribute() ) ) - { - $ARGSRef->{"$attribute"} =~ s/\r\n/\n/gs; + $value =~ s/\r\n/\n/gs; + + if ($value ne $object->$attribute()){ + + my $method = "Set$attribute"; + my ( $code, $msg ) = $object->$method($value); + + push @results, loc($attribute) . ': ' . loc_fuzzy($msg); +=for loc + "[_1] could not be set to [_2].", # loc + "That is already the current value", # loc + "No value sent to _Set!\n", # loc + "Illegal value for [_1]", # loc + "The new value has been set.", # loc + "No column specified", # loc + "Immutable field", # loc + "Nonexistant field?", # loc + "Invalid data", # loc + "Couldn't find row", # loc + "Missing a primary key?: [_1]", # loc + "Found Object", # loc +=cut + }; + } + return (@results); +} - my $method = "Set$attribute"; - my ( $code, $msg ) = $object->$method( $ARGSRef->{"$attribute"} ); - push @results, "$attribute: $msg"; - } +# }}} + +# {{{ Sub ProcessCustomFieldUpdates + +sub ProcessCustomFieldUpdates { + my %args = ( + CustomFieldObj => undef, + ARGSRef => undef, + @_ + ); + + my $Object = $args{'CustomFieldObj'}; + my $ARGSRef = $args{'ARGSRef'}; + + my @attribs = qw( Name Type Description Queue SortOrder); + my @results = UpdateRecordObject( + AttributesRef => \@attribs, + Object => $Object, + ARGSRef => $ARGSRef + ); + + if ( $ARGSRef->{ "CustomField-" . $Object->Id . "-AddValue-Name" } ) { + + my ( $addval, $addmsg ) = $Object->AddValue( + Name => + $ARGSRef->{ "CustomField-" . $Object->Id . "-AddValue-Name" }, + Description => $ARGSRef->{ "CustomField-" + . $Object->Id + . "-AddValue-Description" }, + SortOrder => $ARGSRef->{ "CustomField-" + . $Object->Id + . "-AddValue-SortOrder" }, + ); + push ( @results, $addmsg ); + } + my @delete_values = ( + ref $ARGSRef->{ 'CustomField-' . $Object->Id . '-DeleteValue' } eq + 'ARRAY' ) + ? @{ $ARGSRef->{ 'CustomField-' . $Object->Id . '-DeleteValue' } } + : ( $ARGSRef->{ 'CustomField-' . $Object->Id . '-DeleteValue' } ); + foreach my $id (@delete_values) { + next unless defined $id; + my ( $err, $msg ) = $Object->DeleteValue($id); + push ( @results, $msg ); } return (@results); } @@ -913,6 +982,7 @@ sub ProcessTicketBasics { Subject FinalPriority Priority + TimeEstimated TimeWorked TimeLeft Status @@ -934,7 +1004,7 @@ sub ProcessTicketBasics { ); # We special case owner changing, so we can use ForceOwnerChange - if ( $ARGSRef->{'Owner'} && ( $TicketObj->Owner ne $ARGSRef->{'Owner'} ) ) { + if ( $ARGSRef->{'Owner'} && ( $TicketObj->Owner != $ARGSRef->{'Owner'} ) ) { my ($ChownType); if ( $ARGSRef->{'ForceOwnerChange'} ) { $ChownType = "Force"; @@ -945,7 +1015,7 @@ sub ProcessTicketBasics { my ( $val, $msg ) = $TicketObj->SetOwner( $ARGSRef->{'Owner'}, $ChownType ); - push ( @results, "$msg" ); + push ( @results, $msg ); } # }}} @@ -955,6 +1025,142 @@ sub ProcessTicketBasics { # }}} +# {{{ Sub ProcessTicketCustomFieldUpdates + +sub ProcessTicketCustomFieldUpdates { + my %args = ( + ARGSRef => undef, + @_ + ); + + my @results; + + my $ARGSRef = $args{'ARGSRef'}; + + # Build up a list of tickets that we want to work with + my %tickets_to_mod; + my %custom_fields_to_mod; + foreach my $arg ( keys %{$ARGSRef} ) { + if ( $arg =~ /^Ticket-(\d+)-CustomField-(\d+)-/ ) { + + # For each of those tickets, find out what custom fields we want to work with. + $custom_fields_to_mod{$1}{$2} = 1; + } + } + + # For each of those tickets + foreach my $tick ( keys %custom_fields_to_mod ) { + my $Ticket = RT::Ticket->new( $session{'CurrentUser'} ); + $Ticket->Load($tick); + + # For each custom field + foreach my $cf ( keys %{ $custom_fields_to_mod{$tick} } ) { + + my $CustomFieldObj = RT::CustomField->new($session{'CurrentUser'}); + $CustomFieldObj->LoadById($cf); + + foreach my $arg ( keys %{$ARGSRef} ) { + # since http won't pass in a form element with a null value, we need + # to fake it + if ($arg =~ /^(.*?)-Values-Magic$/ ) { + # We don't care about the magic, if there's really a values element; + next if (exists $ARGSRef->{$1.'-Values'}) ; + + $arg = $1."-Values"; + $ARGSRef->{$1."-Values"} = undef; + + } + next unless ( $arg =~ /^Ticket-$tick-CustomField-$cf-/ ); + my @values = + ( ref( $ARGSRef->{$arg} ) eq 'ARRAY' ) + ? @{ $ARGSRef->{$arg} } + : ( $ARGSRef->{$arg} ); + if ( ( $arg =~ /-AddValue$/ ) || ( $arg =~ /-Value$/ ) ) { + foreach my $value (@values) { + next unless ($value); + my ( $val, $msg ) = $Ticket->AddCustomFieldValue( + Field => $cf, + Value => $value + ); + push ( @results, $msg ); + } + } + elsif ( $arg =~ /-DeleteValues$/ ) { + foreach my $value (@values) { + next unless ($value); + my ( $val, $msg ) = $Ticket->DeleteCustomFieldValue( + Field => $cf, + Value => $value + ); + push ( @results, $msg ); + } + } + elsif ( $arg =~ /-Values$/ and $CustomFieldObj->Type !~ /Entry/) { + my $cf_values = $Ticket->CustomFieldValues($cf); + + my %values_hash; + foreach my $value (@values) { + next unless ($value); + + # build up a hash of values that the new set has + $values_hash{$value} = 1; + + unless ( $cf_values->HasEntry($value) ) { + my ( $val, $msg ) = $Ticket->AddCustomFieldValue( + Field => $cf, + Value => $value + ); + push ( @results, $msg ); + } + + } + while ( my $cf_value = $cf_values->Next ) { + unless ( $values_hash{ $cf_value->Content } == 1 ) { + my ( $val, $msg ) = $Ticket->DeleteCustomFieldValue( + Field => $cf, + Value => $cf_value->Content + ); + push ( @results, $msg); + + } + + } + } + elsif ( $arg =~ /-Values$/ ) { + my $cf_values = $Ticket->CustomFieldValues($cf); + + # keep everything up to the point of difference, delete the rest + my $delete_flag; + foreach my $old_cf (@{$cf_values->ItemsArrayRef}) { + if (!$delete_flag and @values and $old_cf->Content eq $values[0]) { + shift @values; + next; + } + + $delete_flag ||= 1; + $old_cf->Delete; + } + + # now add/replace extra things, if any + foreach my $value (@values) { + my ( $val, $msg ) = $Ticket->AddCustomFieldValue( + Field => $cf, + Value => $value + ); + push ( @results, $msg ); + } + } + else { + push ( @results, "User asked for an unknown update type for custom field " . $cf->Name . " for ticket " . $Ticket->id ); + } + } + } + return (@results); + } +} + +# }}} + # {{{ sub ProcessTicketWatchers =head2 ProcessTicketWatchers ( TicketObj => $Ticket, ARGSRef => \%ARGS ); @@ -978,18 +1184,22 @@ sub ProcessTicketWatchers { foreach my $key ( keys %$ARGSRef ) { - # Delete deletable watchers - if ( ( $key =~ /^DelWatcher(\d*)$/ ) and ( $ARGSRef->{$key} ) ) { - my ( $code, $msg ) = $Ticket->DeleteWatcher($1); + # {{{ Delete deletable watchers + if ( ( $key =~ /^Ticket-DelWatcher-Type-(.*)-Principal-(\d+)$/ ) ) { + my ( $code, $msg ) = + $Ticket->DeleteWatcher(PrincipalId => $2, + Type => $1); push @results, $msg; } # Delete watchers in the simple style demanded by the bulk manipulator elsif ( $key =~ /^Delete(Requestor|Cc|AdminCc)$/ ) { - my ( $code, $msg ) = $Ticket->DeleteWatcher( $ARGSRef->{$key}, $1 ); + my ( $code, $msg ) = $Ticket->DeleteWatcher( Type => $ARGSRef->{$key}, PrincipalId => $1 ); push @results, $msg; } + # }}} + # Add new wathchers by email address elsif ( ( $ARGSRef->{$key} =~ /^(AdminCc|Cc|Requestor)$/ ) and ( $key =~ /^WatcherTypeEmail(\d*)$/ ) ) @@ -1014,12 +1224,11 @@ sub ProcessTicketWatchers { # Add new watchers by owner elsif ( ( $ARGSRef->{$key} =~ /^(AdminCc|Cc|Requestor)$/ ) - and ( $key =~ /^WatcherTypeUser(\d*)$/ ) ) - { + and ( $key =~ /^Ticket-AddWatcher-Principal-(\d*)$/ ) ) { #They're in this order because otherwise $1 gets clobbered :/ my ( $code, $msg ) = - $Ticket->AddWatcher( Type => $ARGSRef->{$key}, Owner => $1 ); + $Ticket->AddWatcher( Type => $ARGSRef->{$key}, PrincipalId => $1 ); push @results, $msg; } } @@ -1061,7 +1270,7 @@ sub ProcessTicketDates { ); #Run through each field in this list. update the value if apropriate - foreach $field (@date_fields) { + foreach my $field (@date_fields) { my ( $code, $msg ); my $DateObj = RT::Date->new( $session{'CurrentUser'} ); @@ -1098,11 +1307,9 @@ Returns an array of results messages. =cut sub ProcessTicketLinks { - my %args = ( - TicketObj => undef, - ARGSRef => undef, - @_ - ); + my %args = ( TicketObj => undef, + ARGSRef => undef, + @_ ); my $Ticket = $args{'TicketObj'}; my $ARGSRef = $args{'ARGSRef'}; @@ -1118,11 +1325,9 @@ sub ProcessTicketLinks { push @results, "Trying to delete: Base: $base Target: $target Type $type"; - my ( $val, $msg ) = $Ticket->DeleteLink( - Base => $base, - Type => $type, - Target => $target - ); + my ( $val, $msg ) = $Ticket->DeleteLink( Base => $base, + Type => $type, + Target => $target ); push @results, $msg; @@ -1133,26 +1338,23 @@ sub ProcessTicketLinks { my @linktypes = qw( DependsOn MemberOf RefersTo ); foreach my $linktype (@linktypes) { - - for my $luri ( split ( / /, $ARGSRef->{ $Ticket->Id . "-$linktype" } ) ) - { - $luri =~ s/\s*$//; # Strip trailing whitespace - my ( $val, $msg ) = $Ticket->AddLink( - Target => $luri, - Type => $linktype - ); - push @results, $msg; + if ( $ARGSRef->{ $Ticket->Id . "-$linktype" } ) { + for my $luri ( split ( / /, $ARGSRef->{ $Ticket->Id . "-$linktype" } ) ) { + $luri =~ s/\s*$//; # Strip trailing whitespace + my ( $val, $msg ) = $Ticket->AddLink( Target => $luri, + Type => $linktype ); + push @results, $msg; + } } + if ( $ARGSRef->{ "$linktype-" . $Ticket->Id } ) { - for my $luri ( split ( / /, $ARGSRef->{ "$linktype-" . $Ticket->Id } ) ) - { - my ( $val, $msg ) = $Ticket->AddLink( - Base => $luri, - Type => $linktype - ); + for my $luri ( split ( / /, $ARGSRef->{ "$linktype-" . $Ticket->Id } ) ) { + my ( $val, $msg ) = $Ticket->AddLink( Base => $luri, + Type => $linktype ); - push @results, $msg; - } + push @results, $msg; + } + } } #Merge if we need to @@ -1167,121 +1369,9 @@ sub ProcessTicketLinks { # }}} -# {{{ sub ProcessTicketObjectKeywords - -=head2 ProcessTicketObjectKeywords ( TicketObj => $Ticket, ARGSRef => \%ARGS ); - -Returns an array of results messages. - -=cut - -sub ProcessTicketObjectKeywords { - my %args = ( - TicketObj => undef, - ARGSRef => undef, - @_ - ); - - my $TicketObj = $args{'TicketObj'}; - my $ARGSRef = $args{'ARGSRef'}; - - my (@results); - - # {{{ set ObjectKeywords. - - my $KeywordSelects = $TicketObj->QueueObj->KeywordSelects; - - # iterate through all the keyword selects for this queue - while ( my $KeywordSelect = $KeywordSelects->Next ) { - - # {{{ do some setup - - # if we have KeywordSelectMagic for this keywordselect: - next - unless - defined $ARGSRef->{ 'KeywordSelectMagic' . $KeywordSelect->id }; - - # Lets get a hash of the possible values to work with - my $value = $ARGSRef->{ 'KeywordSelect' . $KeywordSelect->id } || []; - - #lets get all those values in a hash. regardless of # of entries - #we'll use this for adding and deleting keywords from this object. - my %values = map { $_ => 1 } ref($value) ? @{$value} : ($value); - - # Load up the ObjectKeywords for this KeywordSelect for this ticket - my $ObjectKeys = $TicketObj->KeywordsObj( $KeywordSelect->id ); - - # }}} - # {{{ add new keywords - - foreach my $key ( keys %values ) { - - #unless the ticket has that keyword for that keyword select, - unless ( $ObjectKeys->HasEntry($key) ) { - - #Add the keyword - my ( $result, $msg ) = $TicketObj->AddKeyword( - Keyword => $key, - KeywordSelect => $KeywordSelect->id - ); - push ( @results, $msg ); - } - } - - # }}} - # {{{ Delete unused keywords - - #redo this search, so we don't ask it to delete things that are already gone - # such as when a single keyword select gets its value changed. - $ObjectKeys = $TicketObj->KeywordsObj( $KeywordSelect->id ); - - while ( my $TicketKey = $ObjectKeys->Next ) { - - # if the hash defined above doesn\'t contain the keyword mentioned, - unless ( $values{ $TicketKey->Keyword } ) { - - #I'd really love to just call $keyword->Delete, but then - # we wouldn't get a transaction recorded - my ( $result, $msg ) = $TicketObj->DeleteKeyword( - Keyword => $TicketKey->Keyword, - KeywordSelect => $KeywordSelect->id - ); - push ( @results, $msg ); - } - } - - # }}} - } - - #Iterate through the keyword selects for BulkManipulator style access - while ( my $KeywordSelect = $KeywordSelects->Next ) { - if ( $ARGSRef->{ "AddToKeywordSelect" . $KeywordSelect->Id } ) { - - #Add the keyword - my ( $result, $msg ) = $TicketObj->AddKeyword( - Keyword => - $ARGSRef->{ "AddToKeywordSelect" . $KeywordSelect->Id }, - KeywordSelect => $KeywordSelect->id - ); - push ( @results, $msg ); - } - if ( $ARGSRef->{ "DeleteFromKeywordSelect" . $KeywordSelect->Id } ) { - - #Delete the keyword - my ( $result, $msg ) = $TicketObj->DeleteKeyword( - Keyword => - $ARGSRef->{ "DeleteFromKeywordSelect" . $KeywordSelect->Id }, - KeywordSelect => $KeywordSelect->id - ); - push ( @results, $msg ); - } - } - - # }}} - - return (@results); -} - -# }}} +eval "require RT::Interface::Web_Vendor"; +die $@ if ($@ && $@ !~ qr{^Can't locate RT/Interface/Web_Vendor.pm}); +eval "require RT::Interface::Web_Local"; +die $@ if ($@ && $@ !~ qr{^Can't locate RT/Interface/Web_Local.pm}); 1; -- cgit v1.2.1 From 289340780927b5bac2c7604d7317c3063c6dd8cc Mon Sep 17 00:00:00 2001 From: ivan Date: Thu, 11 Mar 2004 02:05:38 +0000 Subject: import of rt 3.0.9 --- rt/lib/RT/Interface/Email.pm | 294 +++++++++++++++++++++++++++++-------------- rt/lib/RT/Interface/REST.pm | 252 +++++++++++++++++++++++++++++++++++++ rt/lib/RT/Interface/Web.pm | 150 ++++++++++++++++------ 3 files changed, 568 insertions(+), 128 deletions(-) create mode 100644 rt/lib/RT/Interface/REST.pm (limited to 'rt/lib/RT/Interface') diff --git a/rt/lib/RT/Interface/Email.pm b/rt/lib/RT/Interface/Email.pm index bc1a55da2..241f5f35c 100755 --- a/rt/lib/RT/Interface/Email.pm +++ b/rt/lib/RT/Interface/Email.pm @@ -27,14 +27,14 @@ use strict; use Mail::Address; use MIME::Entity; use RT::EmailParser; - +use File::Temp; BEGIN { use Exporter (); use vars qw ($VERSION @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS); # set the version for version checking - $VERSION = do { my @r = (q$Revision: 1.1.1.1 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r }; # must be all one line, for MakeMaker + $VERSION = do { my @r = (q$Revision: 1.1.1.2 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r }; # must be all one line, for MakeMaker @ISA = qw(Exporter); @@ -153,6 +153,7 @@ sub MailError { Subject => 'There has been an error', Explanation => 'Unexplained error', MIMEObj => undef, + Attach => undef, LogLevel => 'crit', @_); @@ -175,7 +176,13 @@ sub MailError { $mimeobj->sync_headers(); $entity->add_part($mimeobj); } - + + if ($args{'Attach'}) { + $entity->attach(Data => $args{'Attach'}, Type => 'message/rfc822'); + + } + + if ($RT::MailCommand eq 'sendmailpipe') { open (MAIL, "|$RT::SendmailPath $RT::SendmailArguments") || return(0); print MAIL $entity->as_string; @@ -194,12 +201,6 @@ sub CreateUser { my ($Username, $Address, $Name, $ErrorsTo, $entity) = @_; my $NewUser = RT::User->new($RT::SystemUser); - # This data is tainted by some Very Broken mailers. - # (Sometimes they send raw ISO 8859-1 data here. fear that. - require Encode; - $Username = Encode::encode(utf8 => $Username, Encode::FB_PERLQQ()) if defined $Username; - $Name = Encode::encode(utf8 => $Name, Encode::FB_PERLQQ()) if defined $Name; - my ($Val, $Message) = $NewUser->Create(Name => ($Username || $Address), EmailAddress => $Address, @@ -361,36 +362,108 @@ sub ParseAddressFromHeader{ -=head2 Gateway +=head2 Gateway ARGSREF + + +Takes parameters: + + action + queue + message + This performs all the "guts" of the mail rt-mailgate program, and is designed to be called from the web interface with a message, user object, and so on. +Returns: + + An array of: + + (status code, message, optional ticket object) + + status code is a numeric value. + + for temporary failures, status code should be -75 + + for permanent failures which are handled by RT, status code should be 0 + + for succces, the status code should be 1 + + + =cut sub Gateway { - my %args = ( message => undef, - queue => 1, - action => 'correspond', - ticket => undef, - @_ ); + my $argsref = shift; + + my %args = %$argsref; + + # Set some reasonable defaults + $args{'action'} = 'correspond' unless ( $args{'action'} ); + $args{'queue'} = '1' unless ( $args{'queue'} ); # Validate the action unless ( $args{'action'} =~ /^(comment|correspond|action)$/ ) { # Can't safely loc this. What object do we loc around? - return ( 0, "Invalid 'action' parameter", undef ); + $RT::Logger->crit("Mail gateway called with an invalid action paramenter '".$args{'action'}."' for queue '".$args{'queue'}."'"); + + return ( -75, "Invalid 'action' parameter", undef ); } my $parser = RT::EmailParser->new(); - $parser->ParseMIMEEntityFromScalar( $args{'message'} ); + my ( $fh, $temp_file ); + for ( 1 .. 10 ) { + + # on NFS and NTFS, it is possible that tempfile() conflicts + # with other processes, causing a race condition. we try to + # accommodate this by pausing and retrying. + last if ( $fh, $temp_file ) = eval { File::Temp::tempfile(undef, UNLINK => 0) }; + sleep 1; + } + if ($fh) { + binmode $fh; #thank you, windows + $fh->autoflush(1); + print $fh $args{'message'}; + close($fh); + + if ( -f $temp_file ) { + $parser->ParseMIMEEntityFromFile($temp_file); + File::Temp::unlink0( $fh, $temp_file ); + if ($parser->Entity) { + delete $args{'message'}; + } + } + + } + + #If for some reason we weren't able to parse the message using a temp file + # try it with a scalar + if ($args{'message'}) { + $parser->ParseMIMEEntityFromScalar($args{'message'}); + + } + + if (!$parser->Entity()) { + MailError( + To => $RT::OwnerEmail, + Subject => "RT Bounce: Unparseable message", + Explanation => "RT couldn't process the message below", + Attach => $args{'message'} + ); + + return(0,"Failed to parse this message. Something is likely badly wrong with the message"); + } my $Message = $parser->Entity(); - my $head = $Message->head; + my $head = $Message->head; my ( $CurrentUser, $AuthStat, $status, $error ); + # Initalize AuthStat so comparisons work correctly + $AuthStat = -9999999; + my $ErrorsTo = ParseErrorsToAddressFromHead($head); my $MessageId = $head->get('Message-Id') @@ -400,37 +473,31 @@ sub Gateway { my $Subject = $head->get('Subject') || ''; chomp $Subject; - $args{'ticket'} ||= $parser->ParseTicketId($Subject); my $SystemTicket; - if ($args{'ticket'} ) { + if ( $args{'ticket'} ) { $SystemTicket = RT::Ticket->new($RT::SystemUser); - $SystemTicket->Load($args{'ticket'}); + $SystemTicket->Load( $args{'ticket'} ); } #Set up a queue object my $SystemQueueObj = RT::Queue->new($RT::SystemUser); $SystemQueueObj->Load( $args{'queue'} ); - # We can safely have no queue of we have a known-good ticket unless ( $args{'ticket'} || $SystemQueueObj->id ) { - MailError( - To => $RT::OwnerEmail, - Subject => "RT Bounce: $Subject", - Explanation => "RT couldn't find the queue: " . $args{'queue'}, - MIMEObj => $Message ); - return ( 0, "RT couldn't find the queue: " . $args{'queue'}, undef ); + return ( -75, "RT couldn't find the queue: " . $args{'queue'}, undef ); } # Authentication Level - # -1 - Get out. this user has been explicitly declined + # -1 - Get out. this user has been explicitly declined # 0 - User may not do anything (Not used at the moment) # 1 - Normal user # 2 - User is allowed to specify status updates etc. a la enhanced-mailgate - push @RT::MailPlugins, "Auth::MailFrom" unless @RT::MailPlugins; + push @RT::MailPlugins, "Auth::MailFrom" unless @RT::MailPlugins; + # Since this needs loading, no matter what for (@RT::MailPlugins) { @@ -453,35 +520,59 @@ sub Gateway { } } - ( $CurrentUser, $NewAuthStat ) = $Code->( Message => $Message, - CurrentUser => $CurrentUser, - AuthLevel => $AuthStat, - Action => $args{'action'}, - Ticket => $SystemTicket, - Queue => $SystemQueueObj ); + ( $CurrentUser, $NewAuthStat ) = $Code->( + Message => $Message, + CurrentUser => $CurrentUser, + AuthLevel => $AuthStat, + Action => $args{'action'}, + Ticket => $SystemTicket, + Queue => $SystemQueueObj + ); + + # If a module returns a "-1" then we discard the ticket, so. + $AuthStat = -1 if $NewAuthStat == -1; # You get the highest level of authentication you were assigned. - last if $AuthStat == -1; $AuthStat = $NewAuthStat if $NewAuthStat > $AuthStat; + last if $AuthStat == -1; } # {{{ If authentication fails and no new user was created, get out. if ( !$CurrentUser or !$CurrentUser->Id or $AuthStat == -1 ) { # If the plugins refused to create one, they lose. - MailError( - Subject => "Could not load a valid user", - Explanation => < $RT::OwnerEmail, + Subject => "Could not load a valid user", + Explanation => < $Message, - LogLevel => 'error' ) - unless $AuthStat == -1; + MIMEObj => $Message, + LogLevel => 'error' + ); + + # Also notify the requestor that his request has been dropped. + MailError( + To => $ErrorsTo, + Subject => "Could not load a valid user", + Explanation => < $Message, + LogLevel => 'error' + ); + } return ( 0, "Could not load a valid user", undef ); } @@ -508,10 +599,11 @@ EOT # {{{ Drop it if it's disallowed if ( $AuthStat == 0 ) { MailError( - To => $ErrorsTo, - Subject => "Permission Denied", - Explanation => "You do not have permission to communicate with RT", - MIMEObj => $Message ); + To => $ErrorsTo, + Subject => "Permission Denied", + Explanation => "You do not have permission to communicate with RT", + MIMEObj => $Message + ); } # }}} @@ -523,10 +615,12 @@ EOT #Should we mail it to RTOwner? if ($RT::LoopsToRTOwner) { - MailError( To => $RT::OwnerEmail, - Subject => "RT Bounce: $Subject", - Explanation => "RT thinks this message may be a bounce", - MIMEObj => $Message ); + MailError( + To => $RT::OwnerEmail, + Subject => "RT Bounce: $Subject", + Explanation => "RT thinks this message may be a bounce", + MIMEObj => $Message + ); #Do we actually want to store it? return ( 0, "Message Bounced", undef ) unless ($RT::StoreLoops); @@ -538,8 +632,10 @@ EOT # {{{ Squelch replies if necessary # Don't let the user stuff the RT-Squelch-Replies-To header. if ( $head->get('RT-Squelch-Replies-To') ) { - $head->add( 'RT-Relocated-Squelch-Replies-To', - $head->get('RT-Squelch-Replies-To') ); + $head->add( + 'RT-Relocated-Squelch-Replies-To', + $head->get('RT-Squelch-Replies-To') + ); $head->delete('RT-Squelch-Replies-To'); } @@ -564,22 +660,27 @@ EOT my @Requestors = ( $CurrentUser->id ); if ($RT::ParseNewMessageForTicketCcs) { - @Cc = ParseCcAddressesFromHead( Head => $head, - CurrentUser => $CurrentUser, - QueueObj => $SystemQueueObj ); + @Cc = ParseCcAddressesFromHead( + Head => $head, + CurrentUser => $CurrentUser, + QueueObj => $SystemQueueObj + ); } my ( $id, $Transaction, $ErrStr ) = $Ticket->Create( - Queue => $SystemQueueObj->Id, - Subject => $Subject, - Requestor => \@Requestors, - Cc => \@Cc, - MIMEObj => $Message ); + Queue => $SystemQueueObj->Id, + Subject => $Subject, + Requestor => \@Requestors, + Cc => \@Cc, + MIMEObj => $Message + ); if ( $id == 0 ) { - MailError( To => $ErrorsTo, - Subject => "Ticket creation failed", - Explanation => $ErrStr, - MIMEObj => $Message ); + MailError( + To => $ErrorsTo, + Subject => "Ticket creation failed", + Explanation => $ErrStr, + MIMEObj => $Message + ); $RT::Logger->error("Create failed: $id / $Transaction / $ErrStr "); return ( 0, "Ticket creation failed", $Ticket ); } @@ -591,15 +692,17 @@ EOT # If the action is comment, add a comment. elsif ( $args{'action'} =~ /^(comment|correspond)$/i ) { - $Ticket->Load($args{'ticket'}); + $Ticket->Load( $args{'ticket'} ); unless ( $Ticket->Id ) { - my $message = "Could not find a ticket with id ".$args{'ticket'}; - MailError( To => $ErrorsTo, - Subject => "Message not recorded", - Explanation => $message, - MIMEObj => $Message ); - - return ( 0, $message); + my $message = "Could not find a ticket with id " . $args{'ticket'}; + MailError( + To => $ErrorsTo, + Subject => "Message not recorded", + Explanation => $message, + MIMEObj => $Message + ); + + return ( 0, $message ); } my ( $status, $msg ); @@ -612,10 +715,12 @@ EOT unless ($status) { #Warn the sender that we couldn't actually submit the comment. - MailError( To => $ErrorsTo, - Subject => "Message not recorded", - Explanation => $msg, - MIMEObj => $Message ); + MailError( + To => $ErrorsTo, + Subject => "Message not recorded", + Explanation => $msg, + MIMEObj => $Message + ); return ( 0, "Message not recorded", $Ticket ); } } @@ -623,21 +728,28 @@ EOT else { #Return mail to the sender with an error - MailError( To => $ErrorsTo, - Subject => "RT Configuration error", - Explanation => "'" - . $args{'action'} - . "' not a recognized action." - . " Your RT administrator has misconfigured " - . "the mail aliases which invoke RT", - MIMEObj => $Message ); + MailError( + To => $ErrorsTo, + Subject => "RT Configuration error", + Explanation => "'" + . $args{'action'} + . "' not a recognized action." + . " Your RT administrator has misconfigured " + . "the mail aliases which invoke RT", + MIMEObj => $Message + ); $RT::Logger->crit( $args{'action'} . " type unknown for $MessageId" ); - return ( 0, "Configuration error: " . $args{'action'} . " not a recognized action", $Ticket ); + return ( + -75, + "Configuration error: " + . $args{'action'} + . " not a recognized action", + $Ticket + ); } - -return ( 1, "Success", $Ticket ); + return ( 1, "Success", $Ticket ); } eval "require RT::Interface::Email_Vendor"; diff --git a/rt/lib/RT/Interface/REST.pm b/rt/lib/RT/Interface/REST.pm new file mode 100644 index 000000000..1ec4f21f9 --- /dev/null +++ b/rt/lib/RT/Interface/REST.pm @@ -0,0 +1,252 @@ +# BEGIN LICENSE BLOCK +# +# Copyright (c) 1996-2003 Jesse Vincent +# +# (Except where explictly superceded by other copyright notices) +# +# This work is made available to you under the terms of Version 2 of +# the GNU General Public License. A copy of that license should have +# been provided with this software, but in any event can be snarfed +# from www.gnu.org. +# +# This work is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# Unless otherwise specified, all modifications, corrections or +# extensions to this work which alter its source code become the +# property of Best Practical Solutions, LLC when submitted for +# inclusion in the work. +# +# +# END LICENSE BLOCK +# lib/RT/Interface/REST.pm +# + +package RT::Interface::REST; +use strict; +use RT; + +BEGIN { + use Exporter (); + use vars qw($VERSION @ISA @EXPORT); + + $VERSION = do { my @r = (q$Revision: 1.1 $ =~ /\d+/g); sprintf "%d."."%02d"x$#r, @r }; + + @ISA = qw(Exporter); + @EXPORT = qw(expand_list form_parse form_compose vpush vsplit); +} + +my $field = '[a-zA-Z][a-zA-Z0-9_-]*'; + +sub expand_list { + my ($list) = @_; + my ($elt, @elts, %elts); + + foreach $elt (split /,/, $list) { + if ($elt =~ /^(\d+)-(\d+)$/) { push @elts, ($1..$2) } + else { push @elts, $elt } + } + + @elts{@elts}=(); + return sort {$a<=>$b} keys %elts; +} + +# Returns a reference to an array of parsed forms. +sub form_parse { + my $state = 0; + my @forms = (); + my @lines = split /\n/, $_[0]; + my ($c, $o, $k, $e) = ("", [], {}, ""); + + LINE: + while (@lines) { + my $line = shift @lines; + + next LINE if $line eq ''; + + if ($line eq '--') { + # We reached the end of one form. We'll ignore it if it was + # empty, and store it otherwise, errors and all. + if ($e || $c || @$o) { + push @forms, [ $c, $o, $k, $e ]; + $c = ""; $o = []; $k = {}; $e = ""; + } + $state = 0; + } + elsif ($state != -1) { + if ($state == 0 && $line =~ /^#/) { + # Read an optional block of comments (only) at the start + # of the form. + $state = 1; + $c = $line; + while (@lines && $lines[0] =~ /^#/) { + $c .= "\n".shift @lines; + } + $c .= "\n"; + } + elsif ($state <= 1 && $line =~ /^($field):(?:\s+(.*))?$/) { + # Read a field: value specification. + my $f = $1; + my @v = ($2 || ()); + + # Read continuation lines, if any. + while (@lines && ($lines[0] eq '' || $lines[0] =~ /^\s+/)) { + push @v, shift @lines; + } + pop @v while (@v && $v[-1] eq ''); + + # Strip longest common leading indent from text. + my ($ws, $ls) = (""); + foreach $ls (map {/^(\s+)/} @v[1..$#v]) { + $ws = $ls if (!$ws || length($ls) < length($ws)); + } + s/^$ws// foreach @v; + + push(@$o, $f) unless exists $k->{$f}; + vpush($k, $f, join("\n", @v)); + + $state = 1; + } + elsif ($line !~ /^#/) { + # We've found a syntax error, so we'll reconstruct the + # form parsed thus far, and add an error marker. (>>) + $state = -1; + $e = form_compose([[ "", $o, $k, "" ]]); + $e.= $line =~ /^>>/ ? "$line\n" : ">> $line\n"; + } + } + else { + # We saw a syntax error earlier, so we'll accumulate the + # contents of this form until the end. + $e .= "$line\n"; + } + } + push(@forms, [ $c, $o, $k, $e ]) if ($e || $c || @$o); + + my $l; + foreach $l (keys %$k) { + $k->{$l} = vsplit($k->{$l}) if (ref $k->{$l} eq 'ARRAY'); + } + + return \@forms; +} + +# Returns text representing a set of forms. +sub form_compose { + my ($forms) = @_; + my (@text, $form); + + foreach $form (@$forms) { + my ($c, $o, $k, $e) = @$form; + my $text = ""; + + if ($c) { + $c =~ s/\n*$/\n/; + $text = "$c\n"; + } + if ($e) { + $text .= $e; + } + elsif ($o) { + my (@lines, $key); + + foreach $key (@$o) { + my ($line, $sp, $v); + my @values = (ref $k->{$key} eq 'ARRAY') ? + @{ $k->{$key} } : + $k->{$key}; + + $sp = " "x(length("$key: ")); + $sp = " "x4 if length($sp) > 16; + + foreach $v (@values) { + if ($v =~ /\n/) { + $v =~ s/^/$sp/gm; + $v =~ s/^$sp//; + + if ($line) { + push @lines, "$line\n\n"; + $line = ""; + } + elsif (@lines && $lines[-1] !~ /\n\n$/) { + $lines[-1] .= "\n"; + } + push @lines, "$key: $v\n\n"; + } + elsif ($line && + length($line)+length($v)-rindex($line, "\n") >= 70) + { + $line .= ",\n$sp$v"; + } + else { + $line = $line ? "$line, $v" : "$key: $v"; + } + } + + $line = "$key:" unless @values; + if ($line) { + if ($line =~ /\n/) { + if (@lines && $lines[-1] !~ /\n\n$/) { + $lines[-1] .= "\n"; + } + $line .= "\n"; + } + push @lines, "$line\n"; + } + } + + $text .= join "", @lines; + } + else { + chomp $text; + } + push @text, $text; + } + + return join "\n--\n\n", @text; +} + +# Add a value to a (possibly multi-valued) hash key. +sub vpush { + my ($hash, $key, $val) = @_; + my @val = ref $val eq 'ARRAY' ? @$val : $val; + + if (exists $hash->{$key}) { + unless (ref $hash->{$key} eq 'ARRAY') { + my @v = $hash->{$key} ne '' ? $hash->{$key} : (); + $hash->{$key} = \@v; + } + push @{ $hash->{$key} }, @val; + } + else { + $hash->{$key} = $val; + } +} + +# "Normalise" a hash key that's known to be multi-valued. +sub vsplit { + my ($val) = @_; + my ($line, $word, @words); + + foreach $line (map {split /\n/} (ref $val eq 'ARRAY') ? @$val : $val) + { + # XXX: This should become a real parser, à la Text::ParseWords. + $line =~ s/^\s+//; + $line =~ s/\s+$//; + push @words, split /\s*,\s*/, $line; + } + + return \@words; +} + +1; + +=head1 NAME + + RT::Interface::REST - helper functions for the REST interface. + +=head1 SYNOPSIS + + Only the REST should use this module. diff --git a/rt/lib/RT/Interface/Web.pm b/rt/lib/RT/Interface/Web.pm index 5097f54a4..8d66239be 100644 --- a/rt/lib/RT/Interface/Web.pm +++ b/rt/lib/RT/Interface/Web.pm @@ -68,6 +68,7 @@ sub NewApacheHandler { default_escape_flags => 'h', allow_globals => [qw(%session)], data_dir => "$RT::MasonDataDir", + autoflush => 1, @_ ); @@ -98,7 +99,8 @@ sub NewCGIHandler { ], data_dir => "$RT::MasonDataDir", default_escape_flags => 'h', - allow_globals => [qw(%session)] + allow_globals => [qw(%session)], + autoflush => 1, ); @@ -137,6 +139,60 @@ sub EscapeUTF8 { # }}} +# {{{ WebCanonicalizeInfo + +=head2 WebCanonicalizeInfo(); + +Different web servers set different environmental varibles. This +function must return something suitable for REMOTE_USER. By default, +just downcase $ENV{'REMOTE_USER'} + +=cut + +sub WebCanonicalizeInfo { + my $user; + + if ( defined $ENV{'REMOTE_USER'} ) { + $user = lc ( $ENV{'REMOTE_USER'} ) if( length($ENV{'REMOTE_USER'}) ); + } + + return $user; +} + +# }}} + +# {{{ WebExternalAutoInfo + +=head2 WebExternalAutoInfo($user); + +Returns a hash of user attributes, used when WebExternalAuto is set. + +=cut + +sub WebExternalAutoInfo { + my $user = shift; + + my %user_info; + + $user_info{'Privileged'} = 1; + + if ($^O !~ /^(?:riscos|MacOS|MSWin32|dos|os2)$/) { + # Populate fields with information from Unix /etc/passwd + + my ($comments, $realname) = (getpwnam($user))[5, 6]; + $user_info{'Comments'} = $comments if defined $comments; + $user_info{'RealName'} = $realname if defined $realname; + } + elsif ($^O eq 'MSWin32' and eval 'use Net::AdminMisc; 1') { + # Populate fields with information from NT domain controller + } + + # and return the wad of stuff + return {%user_info}; +} + +# }}} + package HTML::Mason::Commands; use strict; @@ -160,10 +216,13 @@ sub loc { UNIVERSAL::can($session{'CurrentUser'}, 'loc')){ return($session{'CurrentUser'}->loc(@_)); } - else { - my $u = RT::CurrentUser->new($RT::SystemUser); + elsif ( my $u = eval { RT::CurrentUser->new($RT::SystemUser->Id) } ) { return ($u->loc(@_)); } + else { + # pathetic case -- SystemUser is gone. + return $_[0]; + } } # }}} @@ -189,7 +248,7 @@ sub loc_fuzzy { return($session{'CurrentUser'}->loc_fuzzy($msg)); } else { - my $u = RT::CurrentUser->new($RT::SystemUser); + my $u = RT::CurrentUser->new($RT::SystemUser->Id); return ($u->loc_fuzzy($msg)); } } @@ -365,7 +424,8 @@ sub ProcessUpdateMessage { ); #Make the update content have no 'weird' newlines in it - if ( $args{ARGSRef}->{'UpdateContent'} ) { + if ( $args{ARGSRef}->{'UpdateContent'} || + $args{ARGSRef}->{'UpdateAttachments'}) { if ( $args{ARGSRef}->{'UpdateSubject'} eq $args{'TicketObj'}->Subject() ) @@ -433,7 +493,8 @@ sub MakeMIMEEntity { Cc => undef, Body => undef, AttachmentFieldName => undef, - map Encode::encode_utf8($_), @_, +# map Encode::encode_utf8($_), @_, + @_, ); #Make the update content have no 'weird' newlines in it @@ -449,6 +510,7 @@ sub MakeMIMEEntity { Subject => $args{'Subject'} || "", From => $args{'From'}, Cc => $args{'Cc'}, + Charset => 'utf8', Data => [ $args{'Body'} ] ); } @@ -463,7 +525,14 @@ sub MakeMIMEEntity { #foreach my $filehandle (@filenames) { - my ( $fh, $temp_file ) = tempfile(); + my ( $fh, $temp_file ); + for ( 1 .. 10 ) { + # on NFS and NTFS, it is possible that tempfile() conflicts + # with other processes, causing a race condition. we try to + # accommodate this by pausing and retrying. + last if ($fh, $temp_file) = eval { tempfile() }; + sleep 1; + } binmode $fh; #thank you, windows my ($buffer); @@ -481,7 +550,7 @@ sub MakeMIMEEntity { $Message->attach( Path => $temp_file, - Filename => $filename, + Filename => Encode::decode_utf8($filename), Type => $uploadinfo->{'Content-Type'}, ); close($fh); @@ -594,13 +663,13 @@ sub ProcessSearchQuery { # }}} # {{{ Limit requestor email + if ( $args{ARGS}->{'ValueOfWatcherRole'} ne '' ) { + $session{'tickets'}->LimitWatcher( + TYPE => $args{ARGS}->{'WatcherRole'}, + VALUE => $args{ARGS}->{'ValueOfWatcherRole'}, + OPERATOR => $args{ARGS}->{'WatcherRoleOp'}, - if ( $args{ARGS}->{'ValueOfRequestor'} ne '' ) { - my $alias = $session{'tickets'}->LimitRequestor( - VALUE => $args{ARGS}->{'ValueOfRequestor'}, - OPERATOR => $args{ARGS}->{'RequestorOp'}, ); - } # }}} @@ -780,17 +849,13 @@ sub ProcessACLChanges { my $obj; - if ($object_type eq 'RT::Queue') { - $obj = RT::Queue->new($session{'CurrentUser'}); - $obj->Load($object_id); - } elsif ($object_type eq 'RT::Group') { - $obj = RT::Group->new($session{'CurrentUser'}); - $obj->Load($object_id); - - } elsif ($object_type eq 'RT::System') { + if ($object_type eq 'RT::System') { $obj = $RT::System; + } elsif ($RT::ACE::OBJECT_TYPES{$object_type}) { + $obj = $object_type->new($session{'CurrentUser'}); + $obj->Load($object_id); } else { - push (@results, loc("System Error"). + push (@results, loc("System Error"). ': '. loc("Rights could not be granted for [_1]", $object_type)); next; } @@ -813,17 +878,14 @@ sub ProcessACLChanges { next unless ($right); my $obj; - if ($object_type eq 'RT::Queue') { - $obj = RT::Queue->new($session{'CurrentUser'}); - $obj->Load($object_id); - } elsif ($object_type eq 'RT::Group') { - $obj = RT::Group->new($session{'CurrentUser'}); - $obj->Load($object_id); - - } elsif ($object_type eq 'RT::System') { + if ($object_type eq 'RT::System') { $obj = $RT::System; + } elsif ($RT::ACE::OBJECT_TYPES{$object_type}) { + $obj = $object_type->new($session{'CurrentUser'}); + $obj->Load($object_id); } else { - push (@results, loc("System Error"). + die; + push (@results, loc("System Error"). ': '. loc("Rights could not be revoked for [_1]", $object_type)); next; } @@ -953,6 +1015,17 @@ sub ProcessCustomFieldUpdates { my ( $err, $msg ) = $Object->DeleteValue($id); push ( @results, $msg ); } + + my $vals = $Object->Values(); + while (my $cfv = $vals->Next()) { + if (my $so = $ARGSRef->{ 'CustomField-' . $Object->Id . '-SortOrder' . $cfv->Id }) { + if ($cfv->SortOrder != $so) { + my ( $err, $msg ) = $cfv->SetSortOrder($so); + push ( @results, $msg ); + } + } + } + return (@results); } @@ -1050,8 +1123,11 @@ sub ProcessTicketCustomFieldUpdates { # For each of those tickets foreach my $tick ( keys %custom_fields_to_mod ) { - my $Ticket = RT::Ticket->new( $session{'CurrentUser'} ); - $Ticket->Load($tick); + my $Ticket = $args{'TicketObj'}; + if (!$Ticket or $Ticket->id != $tick) { + $Ticket = RT::Ticket->new( $session{'CurrentUser'} ); + $Ticket->Load($tick); + } # For each custom field foreach my $cf ( keys %{ $custom_fields_to_mod{$tick} } ) { @@ -1074,10 +1150,10 @@ sub ProcessTicketCustomFieldUpdates { my @values = ( ref( $ARGSRef->{$arg} ) eq 'ARRAY' ) ? @{ $ARGSRef->{$arg} } - : ( $ARGSRef->{$arg} ); + : split /\n/, $ARGSRef->{$arg} ; if ( ( $arg =~ /-AddValue$/ ) || ( $arg =~ /-Value$/ ) ) { foreach my $value (@values) { - next unless ($value); + next unless length($value); my ( $val, $msg ) = $Ticket->AddCustomFieldValue( Field => $cf, Value => $value @@ -1087,7 +1163,7 @@ sub ProcessTicketCustomFieldUpdates { } elsif ( $arg =~ /-DeleteValues$/ ) { foreach my $value (@values) { - next unless ($value); + next unless length($value); my ( $val, $msg ) = $Ticket->DeleteCustomFieldValue( Field => $cf, Value => $value @@ -1100,7 +1176,7 @@ sub ProcessTicketCustomFieldUpdates { my %values_hash; foreach my $value (@values) { - next unless ($value); + next unless length($value); # build up a hash of values that the new set has $values_hash{$value} = 1; -- cgit v1.2.1