[otrs-cvs] otrs/Kernel/System/ProcessManagement/TransitionAction TicketArticleCreate.pm, NONE, 1.1 ResponsibleSet.pm, 1.1, NONE TicketStateSet.pm, NONE, 1.1 QueueMove.pm, 1.3, NONE TicketServiceSet.pm, NONE, 1.1 TicketQueueSet.pm, NONE, 1.1 TicketLockSet.pm, NONE, 1.1 SLASet.pm, 1.1, NONE OwnerSet.pm, 1.3, NONE TicketUnlock.pm, 1.3, NONE CustomerSet.pm, 1.3, NONE TicketResponsibleSet.pm, NONE, 1.1 TicketOwnerSet.pm, NONE, 1.1 ArticleCreate.pm, 1.3, NONE ServiceSet.pm, 1.1, NONE StateSet.pm, 1.6, NONE TicketCustomerSet.pm, NONE, 1.1 TicketSLASet.pm, NONE, 1.1
"CVS commits notifications of OTRS.org" <[email protected]>
| Newsgroups | gmane.comp.otrs.cvs |
|---|---|
| Message-ID | <[email protected]> |
Comments:
Update of /home/cvs/otrs/Kernel/System/ProcessManagement/TransitionAction
In directory lancelot:/tmp/cvs-serv13698/Kernel/System/ProcessManagement/TransitionAction
Added Files:
TicketArticleCreate.pm TicketStateSet.pm TicketServiceSet.pm
TicketQueueSet.pm TicketLockSet.pm TicketResponsibleSet.pm
TicketOwnerSet.pm TicketCustomerSet.pm TicketSLASet.pm
Removed Files:
ResponsibleSet.pm QueueMove.pm SLASet.pm OwnerSet.pm
TicketUnlock.pm CustomerSet.pm ArticleCreate.pm ServiceSet.pm
StateSet.pm
Log Message:
Fixed bug#9032 - TransitionAction module name notation.
Author: cr
--- NEW FILE: TicketArticleCreate.pm ---
# --
# Kernel/System/ProcessManagement/TransitionAction/TicketArticleCreate.pm - A Module to create an article
# Copyright (C) 2001-2013 OTRS AG, http://otrs.org/
# --
# $Id: TicketArticleCreate.pm,v 1.1 2013/01/11 06:09:05 cr Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --
package Kernel::System::ProcessManagement::TransitionAction::TicketArticleCreate;
use strict;
use warnings;
use Kernel::System::VariableCheck qw(:all);
use utf8;
use vars qw($VERSION);
$VERSION = qw($Revision: 1.1 $) [1];
=head1 NAME
Kernel::System::ProcessManagement::TransitionAction::TicketArticleCreate - A module to create an article
=head1 SYNOPSIS
All TicketArticleCreate functions.
=head1 PUBLIC INTERFACE
=over 4
=cut
=item new()
create an object
use Kernel::Config;
use Kernel::System::Encode;
use Kernel::System::Log;
use Kernel::System::Time;
use Kernel::System::Main;
use Kernel::System::DB;
use Kernel::System::Ticket;
use Kernel::System::ProcessManagement::TransitionAction::TicketArticleCreate;
my $ConfigObject = Kernel::Config->new();
my $EncodeObject = Kernel::System::Encode->new(
ConfigObject => $ConfigObject,
);
my $LogObject = Kernel::System::Log->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
);
my $TimeObject = Kernel::System::Time->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
);
my $MainObject = Kernel::System::Main->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
);
my $DBObject = Kernel::System::DB->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
MainObject => $MainObject,
);
my $TicketObject = Kernel::System::Ticket->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
EncodeObject => $EncodeObject,
);
my $TicketArticleCreateActionObject = Kernel::System::ProcessManagement::TransitionAction::TicketArticleCreate->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
EncodeObject => $EncodeObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
TicketObject => $TicketObject,
);
=cut
sub new {
my ( $Type, %Param ) = @_;
# allocate new hash for object
my $Self = {};
bless( $Self, $Type );
# get needed objects
for my $Needed (
qw(ConfigObject LogObject EncodeObject DBObject MainObject TimeObject TicketObject)
)
{
die "Got no $Needed!" if !$Param{$Needed};
$Self->{$Needed} = $Param{$Needed};
}
return $Self;
}
=item Run()
Run Data
my $TicketArticleCreateResult = $TicketArticleCreateActionObject->Run(
UserID => 123,
Ticket => \%Ticket, # required
Config => {
# required:
ArticleType => 'note-internal', # email-external|email-internal|phone|fax|...
SenderType => 'agent', # agent|system|customer
ContentType => 'text/plain; charset=ISO-8859-15', # or optional Charset & MimeType
Subject => 'some short description', # required
Body => 'the message text', # required
HistoryType => 'OwnerUpdate', # EmailCustomer|Move|AddNote|PriorityUpdate|WebRequestCustomer|...
HistoryComment => 'Some free text!',
# optional:
From => 'Some Agent <[email protected]>', # not required but useful
To => 'Some Customer A <[email protected]>', # not required but useful
Cc => 'Some Customer B <[email protected]>', # not required but useful
ReplyTo => 'Some Customer B <[email protected]>', # not required
MessageID => '<[email protected]>', # not required but useful
InReplyTo => '<[email protected]>', # not required but useful
References => '<[email protected]> <[email protected]>', # not required but useful
NoAgentNotify => 0, # if you don't want to send agent notifications
AutoResponseType => 'auto reply' # auto reject|auto follow up|auto reply/new ticket|auto remove
ForceNotificationToUserID => [ 1, 43, 56 ], # if you want to force somebody
ExcludeNotificationToUserID => [ 43,56 ], # if you want full exclude somebody from notfications,
# will also be removed in To: line of article,
# higher prio as ForceNotificationToUserID
ExcludeMuteNotificationToUserID => [ 43,56 ], # the same as ExcludeNotificationToUserID but only the
# sending gets muted, agent will still shown in To:
# line of article
}
);
Ticket contains the result of TicketGet including DynamicFields
Config is the Config Hash stored in a Process::TransitionAction's Config key
Returns:
$TicketArticleCreateResult = 1; # 0
);
=cut
sub Run {
my ( $Self, %Param ) = @_;
for my $Needed (qw(UserID Ticket Config)) {
if ( !defined $Param{$Needed} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Need $Needed!",
);
return;
}
}
# Check if we have Ticket to deal with
if ( !IsHashRefWithData( $Param{Ticket} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Ticket has no values!",
);
return;
}
# Check if we have a ConfigHash
if ( !IsHashRefWithData( $Param{Config} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Config has no values!",
);
return;
}
my $Success = $Self->{TicketObject}->ArticleCreate(
%{ $Param{Config} },
TicketID => $Param{Ticket}->{TicketID},
UserID => $Param{UserID},
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Couldn't create article for Ticket: "
. $Param{Ticket}->{TicketID} . '!',
);
return;
}
return 1;
}
1;
=back
=head1 TERMS AND CONDITIONS
This software is part of the OTRS project (L<http://otrs.org/>).
This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (AGPL). If you
did not receive this file, see L<http://www.gnu.org/licenses/agpl.txt>.
=head1 VERSION
$Revision: 1.1 $ $Date: 2013/01/11 06:09:05 $
=cut
--- ResponsibleSet.pm DELETED ---
Author: cr
--- NEW FILE: TicketStateSet.pm ---
# --
# Kernel/System/ProcessManagement/TransitionAction/TicketStateSet.pm - A Module to set the ticket state
# Copyright (C) 2001-2013 OTRS AG, http://otrs.org/
# --
# $Id: TicketStateSet.pm,v 1.1 2013/01/11 06:09:05 cr Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --
package Kernel::System::ProcessManagement::TransitionAction::TicketStateSet;
use strict;
use warnings;
use Kernel::System::VariableCheck qw(:all);
use utf8;
use Kernel::System::State;
use vars qw($VERSION);
$VERSION = qw($Revision: 1.1 $) [1];
=head1 NAME
Kernel::System::ProcessManagement::TransitionAction::TicketStateSet - A module to set the ticket state
=head1 SYNOPSIS
All TicketStateSet functions.
=head1 PUBLIC INTERFACE
=over 4
=cut
=item new()
create an object
use Kernel::Config;
use Kernel::System::Encode;
use Kernel::System::Log;
use Kernel::System::Time;
use Kernel::System::Main;
use Kernel::System::DB;
use Kernel::System::Ticket;
use Kernel::System::ProcessManagement::TransitionAction::TicketStateSet;
my $ConfigObject = Kernel::Config->new();
my $EncodeObject = Kernel::System::Encode->new(
ConfigObject => $ConfigObject,
);
my $LogObject = Kernel::System::Log->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
);
my $TimeObject = Kernel::System::Time->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
);
my $MainObject = Kernel::System::Main->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
);
my $DBObject = Kernel::System::DB->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
MainObject => $MainObject,
);
my $TicketObject = Kernel::System::Ticket->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
EncodeObject => $EncodeObject,
);
my $TicketStateSetActionObject = Kernel::System::ProcessManagement::TransitionAction::TicketStateSet->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
EncodeObject => $EncodeObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
TicketObject => $TicketObject,
);
=cut
sub new {
my ( $Type, %Param ) = @_;
# allocate new hash for object
my $Self = {};
bless( $Self, $Type );
# get needed objects
for my $Needed (
qw(ConfigObject LogObject EncodeObject DBObject MainObject TimeObject TicketObject)
)
{
die "Got no $Needed!" if !$Param{$Needed};
$Self->{$Needed} = $Param{$Needed};
}
$Self->{StateObject} = Kernel::System::State->new(
%Param,
DBObject => $Self->{DBObject},
MainObject => $Self->{MainObject},
TimeObject => $Self->{TimeObject},
);
return $Self;
}
=item Run()
Run Data
my $TicketStateSetResult = $TicketStateSetActionObject->Run(
UserID => 123,
Ticket => \%Ticket, # required
Config => {
State => 'open',
# or
StateID => 3,
}
);
Ticket contains the result of TicketGet including DynamicFields
Config is the Config Hash stored in a Process::TransitionAction's Config key
Returns:
$TicketStateSetResult = 1; # 0
=cut
sub Run {
my ( $Self, %Param ) = @_;
for my $Needed (qw(UserID Ticket Config)) {
if ( !defined $Param{$Needed} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Need $Needed!",
);
return;
}
}
# Check if we have Ticket to deal with
if ( !IsHashRefWithData( $Param{Ticket} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Ticket has no values!",
);
return;
}
# Check if we have a ConfigHash
if ( !IsHashRefWithData( $Param{Config} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Config has no values!",
);
return;
}
if ( !$Param{Config}->{StateID} && !$Param{Config}->{State} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "No State or StateID configured!",
);
return;
}
my $Success;
# If Ticket's StateID is already the same as the Value we
# should set it to, we got nothing to do and return success
if (
defined $Param{Config}->{StateID}
&& $Param{Config}->{StateID} eq $Param{Ticket}->{StateID}
)
{
return 1;
}
# If Ticket's StateID is not the same as the Value we
# should set it to, set the StateID
elsif (
defined $Param{Config}->{StateID}
&& $Param{Config}->{StateID} ne $Param{Ticket}->{StateID}
)
{
$Success = $Self->{TicketObject}->TicketStateSet(
TicketID => $Param{Ticket}->{TicketID},
StateID => $Param{Config}->{StateID},
UserID => $Param{UserID},
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Ticket StateID '
. $Param{Config}->{StateID}
. ' could not be updated for Ticket: '
. $Param{Ticket}->{TicketID} . '!',
);
}
}
# If Ticket's State is already the same as the Value we
# should set it to, we got nothing to do and return success
elsif (
defined $Param{Config}->{State}
&& $Param{Config}->{State} eq $Param{Ticket}->{State}
)
{
return 1;
}
# If Ticket's State is not the same as the Value we
# should set it to, set the State
elsif (
defined $Param{Config}->{State}
&& $Param{Config}->{State} ne $Param{Ticket}->{State}
)
{
$Success = $Self->{TicketObject}->TicketStateSet(
TicketID => $Param{Ticket}->{TicketID},
State => $Param{Config}->{State},
UserID => $Param{UserID},
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Ticket State '
. $Param{Config}->{State}
. ' could not be updated for Ticket: '
. $Param{Ticket}->{TicketID} . '!',
);
}
}
else {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Couldn't update Ticket State - can't find valid State parameter!",
);
return;
}
return $Success;
}
1;
=back
=head1 TERMS AND CONDITIONS
This software is part of the OTRS project (L<http://otrs.org/>).
This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (AGPL). If you
did not receive this file, see L<http://www.gnu.org/licenses/agpl.txt>.
=head1 VERSION
$Revision: 1.1 $ $Date: 2013/01/11 06:09:05 $
=cut
--- QueueMove.pm DELETED ---
Author: cr
--- NEW FILE: TicketServiceSet.pm ---
# --
# Kernel/System/ProcessManagement/TransitionAction/TicketServiceSet.pm - A Module to set the ticket service
# Copyright (C) 2001-2013 OTRS AG, http://otrs.org/
# --
# $Id: TicketServiceSet.pm,v 1.1 2013/01/11 06:09:05 cr Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --
package Kernel::System::ProcessManagement::TransitionAction::TicketServiceSet;
use strict;
use warnings;
use Kernel::System::VariableCheck qw(:all);
use utf8;
use Kernel::System::Service;
use vars qw($VERSION);
$VERSION = qw($Revision: 1.1 $) [1];
=head1 NAME
Kernel::System::ProcessManagement::TransitionAction::TicketServiceSet - A module to set the ticket Service
=head1 SYNOPSIS
All TicketServiceSet functions.
=head1 PUBLIC INTERFACE
=over 4
=cut
=item new()
create an object
use Kernel::Config;
use Kernel::System::Encode;
use Kernel::System::Log;
use Kernel::System::Time;
use Kernel::System::Main;
use Kernel::System::DB;
use Kernel::System::Ticket;
use Kernel::System::ProcessManagement::TransitionAction::TicketServiceSet;
my $ConfigObject = Kernel::Config->new();
my $EncodeObject = Kernel::System::Encode->new(
ConfigObject => $ConfigObject,
);
my $LogObject = Kernel::System::Log->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
);
my $TimeObject = Kernel::System::Time->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
);
my $MainObject = Kernel::System::Main->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
);
my $DBObject = Kernel::System::DB->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
MainObject => $MainObject,
);
my $TicketObject = Kernel::System::Ticket->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
EncodeObject => $EncodeObject,
);
my $TicketServiceSetActionObject
= Kernel::System::ProcessManagement::TransitionAction::TicketServiceSet->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
EncodeObject => $EncodeObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
TicketObject => $TicketObject,
);
=cut
sub new {
my ( $Type, %Param ) = @_;
# allocate new hash for object
my $Self = {};
bless( $Self, $Type );
# get needed objects
for my $Needed (
qw(ConfigObject LogObject EncodeObject DBObject MainObject TimeObject TicketObject)
)
{
die "Got no $Needed!" if !$Param{$Needed};
$Self->{$Needed} = $Param{$Needed};
}
$Self->{ServiceObject} = Kernel::System::Service->new(
%Param,
DBObject => $Self->{DBObject},
MainObject => $Self->{MainObject},
TimeObject => $Self->{TimeObject},
);
return $Self;
}
=item Run()
Run Data
my $TicketServiceSetResult = $TicketServiceSetActionObject->Run(
UserID => 123,
Ticket => \%Ticket, # required
Config => {
Service => 'MyService::Subservice',
# or
ServiceID => 123,
}
);
Ticket contains the result of TicketGet including DynamicFields
Config is the Config Hash stored in a Process::TransitionAction's Config key
Returns:
$TicketServiceSetResult = 1; # 0
=cut
sub Run {
my ( $Self, %Param ) = @_;
for my $Needed (qw(UserID Ticket Config)) {
if ( !defined $Param{$Needed} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Need $Needed!",
);
return;
}
}
# Check if we have Ticket to deal with
if ( !IsHashRefWithData( $Param{Ticket} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Ticket has no values!",
);
return;
}
# Check if we have a ConfigHash
if ( !IsHashRefWithData( $Param{Config} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Config has no values!",
);
return;
}
if ( !$Param{Config}->{ServiceID} && !$Param{Config}->{Service} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "No Service or ServiceID configured!",
);
return;
}
if ( !$Param{Ticket}->{CustomerUserID} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "To set a service the ticket requires a customer!",
);
return;
}
my $Success;
# If Ticket's ServiceID is already the same as the Value we
# should set it to, we got nothing to do and return success
if (
defined $Param{Config}->{ServiceID}
&& defined $Param{Ticket}->{ServiceID}
&& $Param{Config}->{ServiceID} eq $Param{Ticket}->{ServiceID}
)
{
return 1;
}
# If Ticket's ServiceID is not the same as the Value we
# should set it to, set the ServiceID
elsif (
(
defined $Param{Config}->{ServiceID}
&& defined $Param{Ticket}->{ServiceID}
&& $Param{Config}->{ServiceID} ne $Param{Ticket}->{ServiceID}
)
|| !defined $Param{Ticket}->{ServiceID}
)
{
# check if serivce is assigned to Customer User otherwise return
$Success = $Self->_CheckService(
UserLogin => $Param{Ticket}->{CustomerUserID},
ServiceID => $Param{Config}->{ServiceID}
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'ServiceID '
. $Param{Config}->{ServiceID}
. ' is not assigned to Customer User '
. $Param{Ticket}->{CustomerUserID}
);
return;
}
# set ticket service
$Success = $Self->{TicketObject}->TicketServiceSet(
TicketID => $Param{Ticket}->{TicketID},
ServiceID => $Param{Config}->{ServiceID},
UserID => $Param{UserID},
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Ticket ServiceID '
. $Param{Config}->{ServiceID}
. ' could not be updated for Ticket: '
. $Param{Ticket}->{TicketID} . '!',
);
}
}
# If Ticket's Service is already the same as the Value we
# should set it to, we got nothing to do and return success
elsif (
defined $Param{Config}->{Service}
&& defined $Param{Ticket}->{Service}
&& $Param{Config}->{Service} eq $Param{Ticket}->{Service}
)
{
return 1;
}
# If Ticket's Service is not the same as the Value we
# should set it to, set the Service
elsif (
(
defined $Param{Config}->{Service}
&& defined $Param{Ticket}->{Service}
&& $Param{Config}->{Service} ne $Param{Ticket}->{Service}
)
|| !defined $Param{Ticket}->{Service}
)
{
my $ServiceID = $Self->{ServiceObject}->ServiceLookup(
Name => $Param{Config}->{Service},
);
if ( !$ServiceID ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Service '
. $Param{Config}->{Service}
. ' is invalid!'
);
return;
}
# check if service is assigned to Customer User, otherwise return
$Success = $Self->_CheckService(
UserLogin => $Param{Ticket}->{CustomerUserID},
ServiceID => $ServiceID,
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Service '
. $Param{Config}->{Service}
. ' is not assigned to Customer User '
. $Param{Ticket}->{CustomerUserID}
);
return;
}
# set ticket service
$Success = $Self->{TicketObject}->TicketServiceSet(
TicketID => $Param{Ticket}->{TicketID},
Service => $Param{Config}->{Service},
UserID => $Param{UserID},
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Ticket Service '
. $Param{Config}->{Service}
. ' could not be updated for Ticket: '
. $Param{Ticket}->{TicketID} . '!',
);
}
}
else {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Couldn't update Ticket Service - can't find valid Service parameter!",
);
return;
}
return $Success;
}
=item _CheckService()
checks if a service is assigned to a customer user
my $Success = _CheckService(
UserLogin => 'some user',
ServiceID => 123,
);
Returns:
$Success = 1; # or undef
=cut
sub _CheckService {
my ( $Self, %Param ) = @_;
# get a list of assigned services to the customer user
my %Services = $Self->{ServiceObject}->CustomerUserServiceMemberList(
CustomerUserLogin => $Param{UserLogin},
Result => 'HASH',
DefaultServices => 1,
);
# return failure if there are no assigned services for this customer user
return if !IsHashRefWithData( \%Services );
# return failure if the the service is not assigned to the customer
return if !$Services{ $Param{ServiceID} };
# otherwise return success
return 1;
}
1;
=back
=head1 TERMS AND CONDITIONS
This software is part of the OTRS project (L<http://otrs.org/>).
This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (AGPL). If you
did not receive this file, see L<http://www.gnu.org/licenses/agpl.txt>.
=head1 VERSION
$Revision: 1.1 $ $Date: 2013/01/11 06:09:05 $
=cut
Author: cr
--- NEW FILE: TicketQueueSet.pm ---
# --
# Kernel/System/ProcessManagement/TransitionAction/TicketQueueSet.pm - A Module to move a Ticket from to a new queue
# Copyright (C) 2001-2012 OTRS AG, http://otrs.org/
# --
# $Id: TicketQueueSet.pm,v 1.1 2013/01/11 06:09:05 cr Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --
package Kernel::System::ProcessManagement::TransitionAction::TicketQueueSet;
use strict;
use warnings;
use Kernel::System::VariableCheck qw(:all);
use utf8;
use vars qw($VERSION);
$VERSION = qw($Revision: 1.1 $) [1];
=head1 NAME
Kernel::System::ProcessManagement::TransitionAction::TicketQueueSet - A Module to move a Ticket from to a new queue
=head1 SYNOPSIS
All TicketQueueSet functions.
=head1 PUBLIC INTERFACE
=over 4
=cut
=item new()
create an object
use Kernel::Config;
use Kernel::System::Encode;
use Kernel::System::Log;
use Kernel::System::Time;
use Kernel::System::Main;
use Kernel::System::DB;
use Kernel::System::Ticket;
use Kernel::System::ProcessManagement::TransitionAction::TicketQueueSet;
my $ConfigObject = Kernel::Config->new();
my $EncodeObject = Kernel::System::Encode->new(
ConfigObject => $ConfigObject,
);
my $LogObject = Kernel::System::Log->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
);
my $TimeObject = Kernel::System::Time->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
);
my $MainObject = Kernel::System::Main->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
);
my $DBObject = Kernel::System::DB->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
MainObject => $MainObject,
);
my $TicketObject = Kernel::System::Ticket->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
EncodeObject => $EncodeObject,
);
my $TicketQueueSetActionObject = Kernel::System::ProcessManagement::TransitionAction::TicketQueueSet->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
EncodeObject => $EncodeObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
TicketObject => $TicketObject,
);
=cut
sub new {
my ( $Type, %Param ) = @_;
# allocate new hash for object
my $Self = {};
bless( $Self, $Type );
# get needed objects
for my $Needed (
qw(ConfigObject LogObject EncodeObject DBObject MainObject TimeObject TicketObject)
)
{
die "Got no $Needed!" if !$Param{$Needed};
$Self->{$Needed} = $Param{$Needed};
}
return $Self;
}
=item Run()
Run Data
my $TicketQueueSetResult = $TicketQueueSetActionObject->Run(
UserID => 123,
Ticket => \%Ticket, # required
Config => {
TargetQueue => 'Misc',
# or
TargetQueueID => 1,
}
);
Ticket contains the result of TicketGet including DynamicFields
Config is the Config Hash stored in a Process::TransitionAction's Config key
Returns:
$TicketQueueSetResult = 1; # 0
);
=cut
sub Run {
my ( $Self, %Param ) = @_;
for my $Needed (qw(UserID Ticket Config)) {
if ( !defined $Param{$Needed} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Need $Needed!",
);
return;
}
}
# Check if we have Ticket to deal with
if ( !IsHashRefWithData( $Param{Ticket} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Ticket has no values!",
);
return;
}
# Check if we have a ConfigHash
if ( !IsHashRefWithData( $Param{Config} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Config has no values!",
);
return;
}
if ( !$Param{Config}->{TargetQueueID} && !$Param{Config}->{TargetQueue} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "No TargetQueue or TargetQueueID configured!",
);
return;
}
my $Success;
if (
defined $Param{Config}->{TargetQueue}
&& $Param{Config}->{TargetQueue} ne $Param{Ticket}->{Queue}
)
{
$Success = $Self->{TicketObject}->TicketQueueSet(
Queue => $Param{Config}->{TargetQueue},
TicketID => $Param{Ticket}->{TicketID},
UserID => $Param{UserID},
);
}
elsif (
defined $Param{Config}->{TargetQueueID}
&& $Param{Config}->{TargetQueueID} ne $Param{Ticket}->{QueueID}
)
{
$Success = $Self->{TicketObject}->TicketQueueSet(
QueueID => $Param{Config}->{TargetQueueID},
TicketID => $Param{Ticket}->{TicketID},
UserID => $Param{UserID},
);
}
else {
# data is the same as in ticket nothing to do
$Success = 1;
}
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Ticket queue could not be updated for Ticket: '
. $Param{Ticket}->{TicketID} . '!',
);
return;
}
return 1;
}
1;
=back
=head1 TERMS AND CONDITIONS
This software is part of the OTRS project (L<http://otrs.org/>).
This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (AGPL). If you
did not receive this file, see L<http://www.gnu.org/licenses/agpl.txt>.
=head1 VERSION
$Revision: 1.1 $ $Date: 2013/01/11 06:09:05 $
=cut
Author: cr
--- NEW FILE: TicketLockSet.pm ---
# --
# Kernel/System/ProcessManagement/TransitionAction/TicketLockSet.pm - A Module to unlock a ticket
# Copyright (C) 2001-2012 OTRS AG, http://otrs.org/
# --
# $Id: TicketLockSet.pm,v 1.1 2013/01/11 06:09:05 cr Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --
package Kernel::System::ProcessManagement::TransitionAction::TicketLockSet;
use strict;
use warnings;
use Kernel::System::VariableCheck qw(:all);
use utf8;
use vars qw($VERSION);
$VERSION = qw($Revision: 1.1 $) [1];
=head1 NAME
Kernel::System::ProcessManagement::TransitionAction::TicketLockSet - A module to unlock a ticket
=head1 SYNOPSIS
All TicketLockSet functions.
=head1 PUBLIC INTERFACE
=over 4
=cut
=item new()
create an object
use Kernel::Config;
use Kernel::System::Encode;
use Kernel::System::Log;
use Kernel::System::Time;
use Kernel::System::Main;
use Kernel::System::DB;
use Kernel::System::Ticket;
use Kernel::System::ProcessManagement::TransitionAction::TicketLockSet;
my $ConfigObject = Kernel::Config->new();
my $EncodeObject = Kernel::System::Encode->new(
ConfigObject => $ConfigObject,
);
my $LogObject = Kernel::System::Log->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
);
my $TimeObject = Kernel::System::Time->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
);
my $MainObject = Kernel::System::Main->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
);
my $DBObject = Kernel::System::DB->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
MainObject => $MainObject,
);
my $TicketObject = Kernel::System::Ticket->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
EncodeObject => $EncodeObject,
);
my $TicketLockSetActionObject = Kernel::System::ProcessManagement::TransitionAction::TicketLockSet->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
EncodeObject => $EncodeObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
TicketObject => $TicketObject,
);
=cut
sub new {
my ( $Type, %Param ) = @_;
# allocate new hash for object
my $Self = {};
bless( $Self, $Type );
# get needed objects
for my $Needed (
qw(ConfigObject LogObject EncodeObject DBObject MainObject TimeObject TicketObject)
)
{
die "Got no $Needed!" if !$Param{$Needed};
$Self->{$Needed} = $Param{$Needed};
}
$Self->{LockObject} = Kernel::System::Lock->new(
%Param,
DBObject => $Self->{DBObject},
MainObject => $Self->{MainObject},
TimeObject => $Self->{TimeObject},
);
return $Self;
}
=item Run()
Run Data
my $TicketLockSetResult = $TicketLockSetActionObject->Run(
UserID => 123,
Ticket => \%Ticket, # required
Config => {
Lock => 'lock',
# or
LockID => 1,
}
);
Ticket contains the result of TicketGet including DynamicFields
Config is the Config Hash stored in a Process::TransitionAction's Config key
Returns:
$TicketLockSetResult = 1; # 0
=cut
sub Run {
my ( $Self, %Param ) = @_;
for my $Needed (qw(UserID Ticket Config)) {
if ( !defined $Param{$Needed} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Need $Needed!",
);
return;
}
}
# Check if we have Ticket to deal with
if ( !IsHashRefWithData( $Param{Ticket} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Ticket has no values!",
);
return;
}
# Check if we have a ConfigHash
if ( !IsHashRefWithData( $Param{Config} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Config has no values!",
);
return;
}
if ( !$Param{Config}->{LockID} && !$Param{Config}->{Lock} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "No Lock or LockID configured!",
);
return;
}
my $Success;
# If Ticket's LockID is already the same as the Value we
# should set it to, we got nothing to do and return success
if (
defined $Param{Config}->{LoclID}
&& $Param{Config}->{LockID} eq $Param{Ticket}->{LockID}
)
{
return 1;
}
# If Ticket's LockID is not the same as the Value we
# should set it to, set the LockID
elsif (
defined $Param{Config}->{LockID}
&& $Param{Config}->{LockID} ne $Param{Ticket}->{LockID}
)
{
$Success = $Self->{TicketObject}->TicketLockSet(
TicketID => $Param{Ticket}->{TicketID},
LockID => $Param{Config}->{LockID},
UserID => $Param{UserID},
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Ticket LockID '
. $Param{Config}->{LockID}
. ' could not be updated for Ticket: '
. $Param{Ticket}->{TicketID} . '!',
);
}
}
# If Ticket's Lock is already the same as the Value we
# should set it to, we got nothing to do and return success
elsif (
defined $Param{Config}->{Lock}
&& $Param{Config}->{Lock} eq $Param{Ticket}->{Lock}
)
{
return 1;
}
# If Ticket's Lock is not the same as the Value we
# should set it to, set the Lock
elsif (
defined $Param{Config}->{Lock}
&& $Param{Config}->{Lock} ne $Param{Ticket}->{Lock}
)
{
$Success = $Self->{TicketObject}->TicketLockSet(
TicketID => $Param{Ticket}->{TicketID},
Lock => $Param{Config}->{Lock},
UserID => $Param{UserID},
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Ticket Lock '
. $Param{Config}->{Lock}
. ' could not be updated for Ticket: '
. $Param{Ticket}->{TicketID} . '!',
);
}
}
else {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Couldn't update Ticket Lock - can't find valid Lock parameter!",
);
return;
}
return $Success;
}
1;
=back
=head1 TERMS AND CONDITIONS
This software is part of the OTRS project (L<http://otrs.org/>).
This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (AGPL). If you
did not receive this file, see L<http://www.gnu.org/licenses/agpl.txt>.
=head1 VERSION
$Revision: 1.1 $ $Date: 2013/01/11 06:09:05 $
=cut
--- SLASet.pm DELETED ---
--- OwnerSet.pm DELETED ---
--- TicketUnlock.pm DELETED ---
--- CustomerSet.pm DELETED ---
Author: cr
--- NEW FILE: TicketResponsibleSet.pm ---
# --
# Kernel/System/ProcessManagement/TransitionAction/TicketResponsibleSet.pm - A Module to set the ticket responsible
# Copyright (C) 2001-2012 OTRS AG, http://otrs.org/
# --
# $Id: TicketResponsibleSet.pm,v 1.1 2013/01/11 06:09:05 cr Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --
package Kernel::System::ProcessManagement::TransitionAction::TicketResponsibleSet;
use strict;
use warnings;
use Kernel::System::VariableCheck qw(:all);
use utf8;
use vars qw($VERSION);
$VERSION = qw($Revision: 1.1 $) [1];
=head1 NAME
Kernel::System::ProcessManagement::TransitionAction::TicketResponsibleSet - A module to set a new ticket
responsible
=head1 SYNOPSIS
All TicketResponsibleSet functions.
=head1 PUBLIC INTERFACE
=over 4
=cut
=item new()
create an object
use Kernel::Config;
use Kernel::System::Encode;
use Kernel::System::Log;
use Kernel::System::Time;
use Kernel::System::Main;
use Kernel::System::DB;
use Kernel::System::Ticket;
use Kernel::System::ProcessManagement::TransitionAction::TicketResponsibleSet;
my $ConfigObject = Kernel::Config->new();
my $EncodeObject = Kernel::System::Encode->new(
ConfigObject => $ConfigObject,
);
my $LogObject = Kernel::System::Log->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
);
my $TimeObject = Kernel::System::Time->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
);
my $MainObject = Kernel::System::Main->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
);
my $DBObject = Kernel::System::DB->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
MainObject => $MainObject,
);
my $TicketObject = Kernel::System::Ticket->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
EncodeObject => $EncodeObject,
);
my $TicketResponsibleSetActionObject
= Kernel::System::ProcessManagement::TransitionAction::TicketResponsibleSet->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
EncodeObject => $EncodeObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
TicketObject => $TicketObject,
);
=cut
sub new {
my ( $Type, %Param ) = @_;
# allocate new hash for object
my $Self = {};
bless( $Self, $Type );
# get needed objects
for my $Needed (
qw(ConfigObject LogObject EncodeObject DBObject MainObject TimeObject TicketObject)
)
{
die "Got no $Needed!" if !$Param{$Needed};
$Self->{$Needed} = $Param{$Needed};
}
return $Self;
}
=item Run()
Run Data
my $TicketResponsibleSetResult = $TicketResponsibleSetActionObject->Run(
UserID => 123,
Ticket => \%Ticket, # required
Config => {
Responsible => 'root@localhost',
# or
ResponsibleID => 1,
}
);
Ticket contains the result of TicketGet including DynamicFields
Config is the Config Hash stored in a Process::TransitionAction's Config key
Returns:
$TicketResponsibleSetResult = 1; # 0
);
=cut
sub Run {
my ( $Self, %Param ) = @_;
for my $Needed (qw(UserID Ticket Config)) {
if ( !defined $Param{$Needed} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Need $Needed!",
);
return;
}
}
# Check if we have Ticket to deal with
if ( !IsHashRefWithData( $Param{Ticket} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Ticket has no values!",
);
return;
}
# Check if we have a ConfigHash
if ( !IsHashRefWithData( $Param{Config} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Config has no values!",
);
return;
}
if ( !$Param{Config}->{ResponsibleID} && !$Param{Config}->{Responsible} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "No Responsible or ResponsibleID configured!",
);
return;
}
my $Success;
if (
defined $Param{Config}->{Responsible}
&& $Param{Config}->{Responsible} ne $Param{Ticket}->{Responsible}
)
{
$Success = $Self->{TicketObject}->TicketResponsibleSet(
TicketID => $Param{Ticket}->{TicketID},
NewUser => $Param{Config}->{Responsible},
UserID => $Param{UserID},
);
}
elsif (
defined $Param{Config}->{ResponsibleID}
&& $Param{Config}->{ResponsibleID} ne $Param{Ticket}->{ResponsibleID}
)
{
$Success = $Self->{TicketObject}->TicketResponsibleSet(
TicketID => $Param{Ticket}->{TicketID},
NewUserID => $Param{Config}->{ResponsibleID},
UserID => $Param{UserID},
);
}
else {
# data is the same as in ticket nothing to do
$Success = 1;
}
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Ticket responsible could not be updated for Ticket: '
. $Param{Ticket}->{TicketID} . '!',
);
return;
}
return 1;
}
1;
=back
=head1 TERMS AND CONDITIONS
This software is part of the OTRS project (L<http://otrs.org/>).
This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (AGPL). If you
did not receive this file, see L<http://www.gnu.org/licenses/agpl.txt>.
=head1 VERSION
$Revision: 1.1 $ $Date: 2013/01/11 06:09:05 $
=cut
Author: cr
--- NEW FILE: TicketOwnerSet.pm ---
# --
# Kernel/System/ProcessManagement/TransitionAction/TicketOwnerSet.pm - A Module to set the ticket owner
# Copyright (C) 2001-2012 OTRS AG, http://otrs.org/
# --
# $Id: TicketOwnerSet.pm,v 1.1 2013/01/11 06:09:05 cr Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --
package Kernel::System::ProcessManagement::TransitionAction::TicketOwnerSet;
use strict;
use warnings;
use Kernel::System::VariableCheck qw(:all);
use utf8;
use vars qw($VERSION);
$VERSION = qw($Revision: 1.1 $) [1];
=head1 NAME
Kernel::System::ProcessManagement::TransitionAction::TicketOwnerSet - A module to set a new ticket owner
=head1 SYNOPSIS
All TicketOwnerSet functions.
=head1 PUBLIC INTERFACE
=over 4
=cut
=item new()
create an object
use Kernel::Config;
use Kernel::System::Encode;
use Kernel::System::Log;
use Kernel::System::Time;
use Kernel::System::Main;
use Kernel::System::DB;
use Kernel::System::Ticket;
use Kernel::System::ProcessManagement::TransitionAction::TicketOwnerSet;
my $ConfigObject = Kernel::Config->new();
my $EncodeObject = Kernel::System::Encode->new(
ConfigObject => $ConfigObject,
);
my $LogObject = Kernel::System::Log->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
);
my $TimeObject = Kernel::System::Time->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
);
my $MainObject = Kernel::System::Main->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
);
my $DBObject = Kernel::System::DB->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
MainObject => $MainObject,
);
my $TicketObject = Kernel::System::Ticket->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
EncodeObject => $EncodeObject,
);
my $TicketOwnerSetActionObject = Kernel::System::ProcessManagement::TransitionAction::TicketOwnerSet->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
EncodeObject => $EncodeObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
TicketObject => $TicketObject,
);
=cut
sub new {
my ( $Type, %Param ) = @_;
# allocate new hash for object
my $Self = {};
bless( $Self, $Type );
# get needed objects
for my $Needed (
qw(ConfigObject LogObject EncodeObject DBObject MainObject TimeObject TicketObject)
)
{
die "Got no $Needed!" if !$Param{$Needed};
$Self->{$Needed} = $Param{$Needed};
}
return $Self;
}
=item Run()
Run Data
my $TicketOwnerSetResult = $TicketOwnerSetActionObject->Run(
UserID => 123,
Ticket => \%Ticket, # required
Config => {
Owner => 'root@localhost',
# or
OwnerID => 1,
}
);
Ticket contains the result of TicketGet including DynamicFields
Config is the Config Hash stored in a Process::TransitionAction's Config key
Returns:
$TicketOwnerSetResult = 1; # 0
);
=cut
sub Run {
my ( $Self, %Param ) = @_;
for my $Needed (qw(UserID Ticket Config)) {
if ( !defined $Param{$Needed} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Need $Needed!",
);
return;
}
}
# Check if we have Ticket to deal with
if ( !IsHashRefWithData( $Param{Ticket} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Ticket has no values!",
);
return;
}
# Check if we have a ConfigHash
if ( !IsHashRefWithData( $Param{Config} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Config has no values!",
);
return;
}
if ( !$Param{Config}->{OwnerID} && !$Param{Config}->{Owner} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "No Owner or OwnerID configured!",
);
return;
}
my $Success;
if (
defined $Param{Config}->{Owner}
&& $Param{Config}->{Owner} ne $Param{Ticket}->{Owner}
)
{
$Success = $Self->{TicketObject}->TicketOwnerSet(
TicketID => $Param{Ticket}->{TicketID},
NewUser => $Param{Config}->{Owner},
UserID => $Param{UserID},
);
}
elsif (
defined $Param{Config}->{OwnerID}
&& $Param{Config}->{OwnerID} ne $Param{Ticket}->{OwnerID}
)
{
$Success = $Self->{TicketObject}->TicketOwnerSet(
TicketID => $Param{Ticket}->{TicketID},
NewUserID => $Param{Config}->{OwnerID},
UserID => $Param{UserID},
);
}
else {
# data is the same as in ticket nothing to do
$Success = 1;
}
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Ticket owner could not be updated for Ticket: '
. $Param{Ticket}->{TicketID} . '!',
);
return;
}
return 1;
}
1;
=back
=head1 TERMS AND CONDITIONS
This software is part of the OTRS project (L<http://otrs.org/>).
This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (AGPL). If you
did not receive this file, see L<http://www.gnu.org/licenses/agpl.txt>.
=head1 VERSION
$Revision: 1.1 $ $Date: 2013/01/11 06:09:05 $
=cut
--- ArticleCreate.pm DELETED ---
--- ServiceSet.pm DELETED ---
--- StateSet.pm DELETED ---
Author: cr
--- NEW FILE: TicketCustomerSet.pm ---
# --
# Kernel/System/ProcessManagement/TransitionAction/TicketCustomerSet.pm - A Module to set the ticket customer
# Copyright (C) 2001-2012 OTRS AG, http://otrs.org/
# --
# $Id: TicketCustomerSet.pm,v 1.1 2013/01/11 06:09:05 cr Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --
package Kernel::System::ProcessManagement::TransitionAction::TicketCustomerSet;
use strict;
use warnings;
use Kernel::System::VariableCheck qw(:all);
use utf8;
use vars qw($VERSION);
$VERSION = qw($Revision: 1.1 $) [1];
=head1 NAME
Kernel::System::ProcessManagement::TransitionAction::TicketCustomerSet - A module to set a new ticket customer
=head1 SYNOPSIS
All TicketCustomerSet functions.
=head1 PUBLIC INTERFACE
=over 4
=cut
=item new()
create an object
use Kernel::Config;
use Kernel::System::Encode;
use Kernel::System::Log;
use Kernel::System::Time;
use Kernel::System::Main;
use Kernel::System::DB;
use Kernel::System::Ticket;
use Kernel::System::ProcessManagement::TransitionAction::TicketCustomerSet;
my $ConfigObject = Kernel::Config->new();
my $EncodeObject = Kernel::System::Encode->new(
ConfigObject => $ConfigObject,
);
my $LogObject = Kernel::System::Log->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
);
my $TimeObject = Kernel::System::Time->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
);
my $MainObject = Kernel::System::Main->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
);
my $DBObject = Kernel::System::DB->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
MainObject => $MainObject,
);
my $TicketObject = Kernel::System::Ticket->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
EncodeObject => $EncodeObject,
);
my $TicketCustomerSetActionObject = Kernel::System::ProcessManagement::TransitionAction::TicketCustomerSet->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
EncodeObject => $EncodeObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
TicketObject => $TicketObject,
);
=cut
sub new {
my ( $Type, %Param ) = @_;
# allocate new hash for object
my $Self = {};
bless( $Self, $Type );
# get needed objects
for my $Needed (
qw(ConfigObject LogObject EncodeObject DBObject MainObject TimeObject TicketObject)
)
{
die "Got no $Needed!" if !$Param{$Needed};
$Self->{$Needed} = $Param{$Needed};
}
return $Self;
}
=item Run()
Run Data
my $TicketCustomerSetResult = $TicketCustomerSetActionObject->Run(
UserID => 123,
Ticket => \%Ticket, # required
Config => {
CustomerID => 'client123',
# or
CustomerUserID => 'client-user-123',
#OR (Framework wording)
No => 'client123',
# or
User => 'client-user-123',
}
);
Ticket contains the result of TicketGet including DynamicFields
Config is the Config Hash stored in a Process::TransitionAction's Config key
Returns:
$TicketCustomerSetResult = 1; # 0
);
=cut
sub Run {
my ( $Self, %Param ) = @_;
for my $Needed (qw(UserID Ticket Config)) {
if ( !defined $Param{$Needed} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Need $Needed!",
);
return;
}
}
# Check if we have Ticket to deal with
if ( !IsHashRefWithData( $Param{Ticket} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Ticket has no values!",
);
return;
}
# Check if we have a ConfigHash
if ( !IsHashRefWithData( $Param{Config} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Config has no values!",
);
return;
}
if (
!$Param{Config}->{CustomerID}
&& !$Param{Config}->{No}
&& !$Param{Config}->{CustomerUserID}
&& !$Param{Config}->{User}
)
{
$Self->{LogObject}->Log(
Priority => 'error',
Message => "No CustomerID/No or CustomerUserID/User configured!",
);
return;
}
if ( !$Param{Config}->{CustomerID} && $Param{Config}->{No} ) {
$Param{Config}->{CustomerID} = $Param{Config}->{No};
}
if ( !$Param{Config}->{CustomerUserID} && $Param{Config}->{User} ) {
$Param{Config}->{CustomerUserID} = $Param{Config}->{User};
}
if (
defined $Param{Config}->{CustomerID}
&&
(
!defined $Param{Ticket}->{CustomerID}
|| $Param{Config}->{CustomerID} ne $Param{Ticket}->{CustomerID}
)
)
{
my $Success = $Self->{TicketObject}->TicketCustomerSet(
TicketID => $Param{Ticket}->{TicketID},
No => $Param{Config}->{CustomerID},
UserID => $Param{UserID},
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Ticket CustomerID could not be updated for Ticket: '
. $Param{Ticket}->{TicketID} . '!',
);
return;
}
}
if (
defined $Param{Config}->{CustomerUserID}
&&
(
!defined $Param{Ticket}->{CustomerUserID}
|| $Param{Config}->{CustomerUserID} ne $Param{Ticket}->{CustomerUserID}
)
)
{
my $Success = $Self->{TicketObject}->TicketCustomerSet(
TicketID => $Param{Ticket}->{TicketID},
User => $Param{Config}->{CustomerUserID},
UserID => $Param{UserID},
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Ticket CustomerID could not be updated for Ticket: '
. $Param{Ticket}->{TicketID} . '!',
);
return;
}
}
return 1;
}
1;
=back
=head1 TERMS AND CONDITIONS
This software is part of the OTRS project (L<http://otrs.org/>).
This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (AGPL). If you
did not receive this file, see L<http://www.gnu.org/licenses/agpl.txt>.
=head1 VERSION
$Revision: 1.1 $ $Date: 2013/01/11 06:09:05 $
=cut
Author: cr
--- NEW FILE: TicketSLASet.pm ---
# --
# Kernel/System/ProcessManagement/TransitionAction/TicketSLASet.pm - A Module to set the ticket service
# Copyright (C) 2001-2013 OTRS AG, http://otrs.org/
# --
# $Id: TicketSLASet.pm,v 1.1 2013/01/11 06:09:05 cr Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --
package Kernel::System::ProcessManagement::TransitionAction::TicketSLASet;
use strict;
use warnings;
use Kernel::System::VariableCheck qw(:all);
use utf8;
use Kernel::System::SLA;
use vars qw($VERSION);
$VERSION = qw($Revision: 1.1 $) [1];
=head1 NAME
Kernel::System::ProcessManagement::TransitionAction::TicketSLASet - A module to set the ticket SLA
=head1 SYNOPSIS
All TicketSLASet functions.
=head1 PUBLIC INTERFACE
=over 4
=cut
=item new()
create an object
use Kernel::Config;
use Kernel::System::Encode;
use Kernel::System::Log;
use Kernel::System::Time;
use Kernel::System::Main;
use Kernel::System::DB;
use Kernel::System::Ticket;
use Kernel::System::ProcessManagement::TransitionAction::TicketSLASet;
my $ConfigObject = Kernel::Config->new();
my $EncodeObject = Kernel::System::Encode->new(
ConfigObject => $ConfigObject,
);
my $LogObject = Kernel::System::Log->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
);
my $TimeObject = Kernel::System::Time->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
);
my $MainObject = Kernel::System::Main->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
);
my $DBObject = Kernel::System::DB->new(
ConfigObject => $ConfigObject,
EncodeObject => $EncodeObject,
LogObject => $LogObject,
MainObject => $MainObject,
);
my $TicketObject = Kernel::System::Ticket->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
EncodeObject => $EncodeObject,
);
my $TicketSLASetActionObject = Kernel::System::ProcessManagement::TransitionAction::TicketSLASet->new(
ConfigObject => $ConfigObject,
LogObject => $LogObject,
EncodeObject => $EncodeObject,
DBObject => $DBObject,
MainObject => $MainObject,
TimeObject => $TimeObject,
TicketObject => $TicketObject,
);
=cut
sub new {
my ( $Type, %Param ) = @_;
# allocate new hash for object
my $Self = {};
bless( $Self, $Type );
# get needed objects
for my $Needed (
qw(ConfigObject LogObject EncodeObject DBObject MainObject TimeObject TicketObject)
)
{
die "Got no $Needed!" if !$Param{$Needed};
$Self->{$Needed} = $Param{$Needed};
}
$Self->{SLAObject} = Kernel::System::SLA->new(
%Param,
DBObject => $Self->{DBObject},
MainObject => $Self->{MainObject},
TimeObject => $Self->{TimeObject},
);
return $Self;
}
=item Run()
Run Data
my $TicketSLASetResult = $TicketSLASetActionObject->Run(
UserID => 123,
Ticket => \%Ticket, # required
Config => {
SLA => 'MySLA',
# or
SLAID => 123,
}
);
Ticket contains the result of TicketGet including DynamicFields
Config is the Config Hash stored in a Process::TransitionAction's Config key
Returns:
$TicketSLASetResult = 1; # 0
=cut
sub Run {
my ( $Self, %Param ) = @_;
for my $Needed (qw(UserID Ticket Config)) {
if ( !defined $Param{$Needed} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Need $Needed!",
);
return;
}
}
# Check if we have Ticket to deal with
if ( !IsHashRefWithData( $Param{Ticket} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Ticket has no values!",
);
return;
}
# Check if we have a ConfigHash
if ( !IsHashRefWithData( $Param{Config} ) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Config has no values!",
);
return;
}
if ( !$Param{Config}->{SLAID} && !$Param{Config}->{SLA} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "No SLA or SLAID configured!",
);
return;
}
if ( !$Param{Ticket}->{ServiceID} && !$Param{Ticket}->{Service} ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "To set a SLA the ticket requires a service!",
);
return;
}
my $Success;
# If Ticket's SLAID is already the same as the Value we
# should set it to, we got nothing to do and return success
if (
defined $Param{Config}->{SLAID}
&& defined $Param{Ticket}->{SLAID}
&& $Param{Config}->{SLAID} eq $Param{Ticket}->{SLAID}
)
{
return 1;
}
# If Ticket's SLAID is not the same as the Value we
# should set it to, set the SLAID
elsif (
(
defined $Param{Config}->{SLAID}
&& defined $Param{Ticket}->{SLAID}
&& $Param{Config}->{SLAID} ne $Param{Ticket}->{SLAID}
)
|| !defined $Param{Ticket}->{SLAID}
)
{
# check if serivce is assigned to Service otherwise return
$Success = $Self->_CheckSLA(
ServiceID => $Param{Ticket}->{ServiceID},
SLAID => $Param{Config}->{SLAID},
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'SLAID '
. $Param{Config}->{SLAID}
. ' is not assigned to Service '
. $Param{Ticket}->{Service}
);
return;
}
# set ticket SLA
$Success = $Self->{TicketObject}->TicketSLASet(
TicketID => $Param{Ticket}->{TicketID},
SLAID => $Param{Config}->{SLAID},
UserID => $Param{UserID},
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Ticket SLAID '
. $Param{Config}->{SLAID}
. ' could not be updated for Ticket: '
. $Param{Ticket}->{TicketID} . '!',
);
}
}
# If Ticket's SLA is already the same as the Value we
# should set it to, we got nothing to do and return success
elsif (
defined $Param{Config}->{SLA}
&& defined $Param{Ticket}->{SLA}
&& $Param{Config}->{SLA} eq $Param{Ticket}->{SLA}
)
{
return 1;
}
# If Ticket's SLA is not the same as the Value we
# should set it to, set the SLA
elsif (
(
defined $Param{Config}->{SLA}
&& defined $Param{Ticket}->{SLA}
&& $Param{Config}->{SLA} ne $Param{Ticket}->{SLA}
)
|| !defined $Param{Ticket}->{SLA}
)
{
my $SLAID = $Self->{SLAObject}->SLALookup(
Name => $Param{Config}->{SLA},
);
if ( !$SLAID ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'SLA '
. $Param{Config}->{SLA}
. ' is invalid!'
);
return;
}
# check if SLA is assigned to Service, otherwise return
$Success = $Self->_CheckSLA(
ServiceID => $Param{Ticket}->{ServiceID},
SLAID => $SLAID,
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'SLA '
. $Param{Config}->{SLA}
. ' is not assigned to Service '
. $Param{Ticket}->{Service}
);
return;
}
# set ticket SLA
$Success = $Self->{TicketObject}->TicketSLASet(
TicketID => $Param{Ticket}->{TicketID},
SLA => $Param{Config}->{SLA},
UserID => $Param{UserID},
);
if ( !$Success ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => 'Ticket SLA '
. $Param{Config}->{SLA}
. ' could not be updated for Ticket: '
. $Param{Ticket}->{TicketID} . '!',
);
}
}
else {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Couldn't update Ticket SLA - can't find valid SLA parameter!",
);
return;
}
return $Success;
}
=item _CheckSLA()
checks if a SLA is assigned to a Service
my $Success = _CheckSLA(
ServiceID => 123,
SLAID => 123,
);
Returns:
$Success = 1; # or undef
=cut
sub _CheckSLA {
my ( $Self, %Param ) = @_;
# get a list of assigned SLAs to the Service
my %SLAs = $Self->{SLAObject}->SLAList(
ServiceID => $Param{ServiceID},
UserID => 1,
);
# return failure if there are no assigned SLAs for this Service
return if !IsHashRefWithData( \%SLAs );
# return failure if the the SLA is not assigned to the Service
return if !$SLAs{ $Param{SLAID} };
# otherwise return success
return 1;
}
1;
=back
=head1 TERMS AND CONDITIONS
This software is part of the OTRS project (L<http://otrs.org/>).
This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (AGPL). If you
did not receive this file, see L<http://www.gnu.org/licenses/agpl.txt>.
=head1 VERSION
$Revision: 1.1 $ $Date: 2013/01/11 06:09:05 $
=cut
---------------------------------------------------------------------
OTRS mailing list: cvs-log - Webpage: http://otrs.org/
Archive: http://lists.otrs.org/pipermail/cvs-log
To unsubscribe: http://lists.otrs.org/cgi-bin/listinfo/cvs-log