X-Git-Url: http://git.freeside.biz/gitweb/?a=blobdiff_plain;ds=sidebyside;f=rt%2Flib%2FRT%2FScrips.pm;h=cf580251fe9f38ea0627c0155b4ddb495d00aaae;hb=187086c479a09629b7d180eec513fb7657f4e291;hp=de9d1eae90e4db0c485bda52b977443001842f90;hpb=e9e0cf0989259b94d9758eceff448666a2e5a5cc;p=freeside.git diff --git a/rt/lib/RT/Scrips.pm b/rt/lib/RT/Scrips.pm index de9d1eae9..cf580251f 100755 --- a/rt/lib/RT/Scrips.pm +++ b/rt/lib/RT/Scrips.pm @@ -2,7 +2,7 @@ # # COPYRIGHT: # -# This software is Copyright (c) 1996-2014 Best Practical Solutions, LLC +# This software is Copyright (c) 1996-2018 Best Practical Solutions, LLC # # # (Except where explicitly superseded by other copyright notices) @@ -69,12 +69,20 @@ package RT::Scrips; use strict; use warnings; -use RT::Scrip; - use base 'RT::SearchBuilder'; +use RT::Scrip; +use RT::ObjectScrips; + sub Table { 'Scrips'} +sub _Init { + my $self = shift; + + $self->{'with_disabled_column'} = 1; + + return ( $self->SUPER::_Init(@_) ); +} =head2 LimitToQueue @@ -85,14 +93,17 @@ another call to this method =cut sub LimitToQueue { - my $self = shift; - my $queue = shift; - - $self->Limit (ENTRYAGGREGATOR => 'OR', - FIELD => 'Queue', - VALUE => "$queue") - if defined $queue; - + my $self = shift; + my $queue = shift; + return unless defined $queue; + + my $alias = RT::ObjectScrips->new( $self->CurrentUser ) + ->JoinTargetToThis( $self ); + $self->Limit( + ALIAS => $alias, + FIELD => 'ObjectId', + VALUE => int $queue, + ); } @@ -106,43 +117,140 @@ another call to this method or LimitToQueue sub LimitToGlobal { - my $self = shift; - - $self->Limit (ENTRYAGGREGATOR => 'OR', - FIELD => 'Queue', - VALUE => 0); - + my $self = shift; + return $self->LimitToQueue(0); } -# {{{ sub Next +sub LimitToAdded { + my $self = shift; + return RT::ObjectScrips->new( $self->CurrentUser ) + ->LimitTargetToAdded( $self => @_ ); +} -=head2 Next +sub LimitToNotAdded { + my $self = shift; + return RT::ObjectScrips->new( $self->CurrentUser ) + ->LimitTargetToNotAdded( $self => @_ ); +} + +sub LimitByStage { + my $self = shift; + my %args = @_%2? (Stage => @_) : @_; + return unless defined $args{'Stage'}; + + my $alias = RT::ObjectScrips->new( $self->CurrentUser ) + ->JoinTargetToThis( $self, %args ); + $self->Limit( + ALIAS => $alias, + FIELD => 'Stage', + VALUE => $args{'Stage'}, + ); +} + +=head2 LimitByTemplate -Returns the next scrip that this user can see. +Takes a L object and limits scrips to those that +use the template. =cut - -sub Next { + +sub LimitByTemplate { my $self = shift; - - - my $Scrip = $self->SUPER::Next(); - if ((defined($Scrip)) and (ref($Scrip))) { - - if ($Scrip->CurrentUserHasRight('ShowScrips')) { - return($Scrip); - } - - #If the user doesn't have the right to show this scrip - else { - return($self->Next()); - } + my $template = shift; + + $self->Limit( FIELD => 'Template', VALUE => $template->Name ); + + if ( $template->Queue ) { + # if template is local then we are interested in global and + # queue specific scrips + $self->LimitToQueue( $template->Queue ); + $self->LimitToGlobal; + } + else { # template is global + + # if every queue has a custom version then there + # is no scrip that uses the template + { + my $queues = RT::Queues->new( RT->SystemUser ); + my $alias = $queues->Join( + TYPE => 'LEFT', + ALIAS1 => 'main', + FIELD1 => 'id', + TABLE2 => 'Templates', + FIELD2 => 'Queue', + ); + $queues->Limit( + LEFTJOIN => $alias, + ALIAS => $alias, + FIELD => 'Name', + VALUE => $template->Name, + ); + $queues->Limit( + ALIAS => $alias, + FIELD => 'id', + OPERATOR => 'IS', + VALUE => 'NULL', + ); + return $self->Limit( FIELD => 'id', VALUE => 0 ) + unless $queues->Count; + } + + # otherwise it's either a global scrip or application to + # a queue with custom version of the template. + my $os_alias = RT::ObjectScrips->new( $self->CurrentUser ) + ->JoinTargetToThis( $self ); + my $tmpl_alias = $self->Join( + TYPE => 'LEFT', + ALIAS1 => $os_alias, + FIELD1 => 'ObjectId', + TABLE2 => 'Templates', + FIELD2 => 'Queue', + ); + $self->Limit( + LEFTJOIN => $tmpl_alias, ALIAS => $tmpl_alias, FIELD => 'Name', VALUE => $template->Name, + ); + $self->Limit( + LEFTJOIN => $tmpl_alias, ALIAS => $tmpl_alias, FIELD => 'Queue', OPERATOR => '!=', VALUE => 0, + ); + + $self->_OpenParen('UsedBy'); + $self->Limit( SUBCLAUSE => 'UsedBy', ALIAS => $os_alias, FIELD => 'ObjectId', VALUE => 0 ); + $self->Limit( + SUBCLAUSE => 'UsedBy', + ALIAS => $tmpl_alias, + FIELD => 'id', + OPERATOR => 'IS', + VALUE => 'NULL', + ); + $self->_CloseParen('UsedBy'); } - #if there never was any scrip - else { - return(undef); - } - +} + +sub ApplySortOrder { + my $self = shift; + my $order = shift || 'ASC'; + $self->OrderByCols( { + ALIAS => RT::ObjectScrips->new( $self->CurrentUser ) + ->JoinTargetToThis( $self => @_ ) + , + FIELD => 'SortOrder', + ORDER => $order, + } ); +} + +=head2 AddRecord + +Overrides the collection to ensure that only scrips the user can see are +returned. + +=cut + +sub AddRecord { + my $self = shift; + my ($record) = @_; + + return unless $record->CurrentUserHasRight('ShowScrips'); + return $self->SUPER::AddRecord( $record ); } =head2 Apply @@ -315,10 +423,8 @@ sub _SetupSourceObjects { =head2 _FindScrips -Find only the apropriate scrips for whatever we're doing now. Order them -by their description. (Most common use case is to prepend a number to the -description, forcing the scrips to display and run in ascending alphanumerical -order.) +Find only the appropriate scrips for whatever we're doing now. Order +them by the SortOrder field from the ObjectScrips table. =cut @@ -330,32 +436,27 @@ sub _FindScrips { @_ ); - $self->LimitToQueue( $self->{'TicketObj'}->QueueObj->Id ) - ; #Limit it to $Ticket->QueueObj->Id - $self->LimitToGlobal(); - # or to "global" - - $self->Limit( FIELD => "Stage", VALUE => $args{'Stage'} ); + $self->LimitToQueue( $self->{'TicketObj'}->QueueObj->Id ); + $self->LimitToGlobal; + $self->LimitByStage( $args{'Stage'} ); - my $ConditionsAlias = $self->NewAlias('ScripConditions'); - - $self->Join( + my $ConditionsAlias = $self->Join( ALIAS1 => 'main', FIELD1 => 'ScripCondition', - ALIAS2 => $ConditionsAlias, - FIELD2 => 'id' + TABLE2 => 'ScripConditions', + FIELD2 => 'id', ); #We only want things where the scrip applies to this sort of transaction # TransactionBatch stage can define list of transaction foreach( split /\s*,\s*/, ($args{'Type'} || '') ) { - $self->Limit( - ALIAS => $ConditionsAlias, - FIELD => 'ApplicableTransTypes', - OPERATOR => 'LIKE', - VALUE => $_, - ENTRYAGGREGATOR => 'OR', - ) + $self->Limit( + ALIAS => $ConditionsAlias, + FIELD => 'ApplicableTransTypes', + OPERATOR => 'LIKE', + VALUE => $_, + ENTRYAGGREGATOR => 'OR', + ) } # Or where the scrip applies to any transaction @@ -367,8 +468,7 @@ sub _FindScrips { ENTRYAGGREGATOR => 'OR', ); - # Promise some kind of ordering - $self->OrderBy( FIELD => 'Description' ); + $self->ApplySortOrder; # we call Count below, but later we always do search # so just do search and get count from results @@ -382,19 +482,6 @@ sub _FindScrips { ); } - - - -=head2 NewItem - -Returns an empty new RT::Scrip item - -=cut - -sub NewItem { - my $self = shift; - return(RT::Scrip->new($self->CurrentUser)); -} RT::Base->_ImportOverlays(); 1;