ArticleCopyMoveDelete 1.0.0 c.a.p.e. IT GmbH http://www.cape-it.de/ GNU AFFERO GENERAL PUBLIC LICENSE Version 3, November 2007 CR: extracted functionality from KIX4OTRS. ArticleCopyMoveDelete - allows to copy, move or delete articles. 3.0.x WELCOME You are about to install the OTRS module ArticleCopyMoveDelete. c.a.p.e. IT ...easy. c.a.p.e. IT ...easy. WELCOME You are about to UNINSTALL the ArticleCopyMoveDelete extensions package for OTRS. c.a.p.e. IT ...easy. WELCOME You are about to upgrade the ArticleCopyMoveDelete extensions package for OTRS. c.a.p.e. IT ...easy. c.a.p.e. IT ...easy. my $FunctionName = 'CodeInstall'; my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content}; # The code module has just recently been copied to it's location in the file system. # In a persistent Perl environment an old version of the module might still be loaded, # as watchdogs like Apache2::Reload haven't had a chance to reload it. # So we need to make sure that the new version is being loaded. # Kernel::System::Main::Require() checks the relative file path, so we need to remove that from %INC. # This is only needed in persistent Perl environment, but does no harm in a CGI environment. my $CodeModulePath = $CodeModule; $CodeModulePath =~ s/::/\//g; $CodeModulePath .= '.pm'; delete $INC{$CodeModulePath}; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}) ) { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method $FunctionName() on $CodeModule.pm." ); } } else { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method new() on $CodeModule.pm." ); } } my $FunctionName = 'CodeUpgrade'; my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content}; # The code module has just recently been copied to it's location in the file system. # In a persistent Perl environment an old version of the module might still be loaded, # as watchdogs like Apache2::Reload haven't had a chance to reload it. # So we need to make sure that the new version is being loaded. # Kernel::System::Main::Require() checks the relative file path, so we need to remove that from %INC. # This is only needed in persistent Perl environment, but does no harm in a CGI environment. my $CodeModulePath = $CodeModule; $CodeModulePath =~ s/::/\//g; $CodeModulePath .= '.pm'; delete $INC{$CodeModulePath}; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}) ) { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method $FunctionName() on $CodeModule.pm." ); } } else { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method new() on $CodeModule.pm." ); } } my $FunctionName = 'CodeUninstall'; my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content}; # The code module has just recently been copied to it's location in the file system. # In a persistent Perl environment an old version of the module might still be loaded, # as watchdogs like Apache2::Reload haven't had a chance to reload it. # So we need to make sure that the new version is being loaded. # Kernel::System::Main::Require() checks the relative file path, so we need to remove that from %INC. # This is only needed in persistent Perl environment, but does no harm in a CGI environment. my $CodeModulePath = $CodeModule; $CodeModulePath =~ s/::/\//g; $CodeModulePath .= '.pm'; delete $INC{$CodeModulePath}; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}) ) { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method $FunctionName() on $CodeModule.pm." ); } } else { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method new() on $CodeModule.pm." ); } } my $FunctionName = 'CodeReinstall'; my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content}; # The code module has just recently been copied to it's location in the file system. # In a persistent Perl environment an old version of the module might still be loaded, # as watchdogs like Apache2::Reload haven't had a chance to reload it. # So we need to make sure that the new version is being loaded. # Kernel::System::Main::Require() checks the relative file path, so we need to remove that from %INC. # This is only needed in persistent Perl environment, but does no harm in a CGI environment. my $CodeModulePath = $CodeModule; $CodeModulePath =~ s/::/\//g; $CodeModulePath .= '.pm'; delete $INC{$CodeModulePath}; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}) ) { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method $FunctionName() on $CodeModule.pm." ); } } else { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method new() on $CodeModule.pm." ); } } 2011-12-28 11:38:01 cvs.intra.cape-it.de IyAtLQojIENIQU5HRVNfYXJ0aWNsZWNvcHltb3ZlZGVsZXRlIC0gY2hhbmdlIGxvZyBvZiBBcnRpY2xlQ29weU1vdmVEZWxldGUKIyBDb3B5cmlnaHQgKEMpIDIwMDYtMjAxMiBjLmEucC5lLiBJVCBHbWJILCBodHRwOi8vd3d3LmNhcGUtaXQuZGUvCiMgLS0KIyAkSWQ6IENIQU5HRVNfYXJ0aWNsZWNvcHltb3ZlZGVsZXRlLHYgMS4yIDIwMTEtMTItMjggMTA6MzY6NDEgdHRvIEV4cCAkCiMgLS0KIyBUaGlzIHNvZnR3YXJlIGNvbWVzIHdpdGggQUJTT0xVVEVMWSBOTyBXQVJSQU5UWS4gRm9yIGRldGFpbHMsIHNlZQojIHRoZSBlbmNsb3NlZCBmaWxlIENPUFlJTkcgZm9yIGxpY2Vuc2UgaW5mb3JtYXRpb24gKEdQTCkuIElmIHlvdQojIGRpZCBub3QgcmVjZWl2ZSB0aGlzIGZpbGUsIHNlZSBodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvYWdwbC50eHQuCiMgLS0KIwojLS0tLS0tLS0tLS0tLS0tLS0tLS0gMS4wLjEgKDIwMTIvPz8vPz8pIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQojICogKDIwMTIvTU0vREQpIC0gQnVnZml4OiAoTE9HSU4pCiMKIy0tLS0tLS0tLS0tLS0tLS0tLS0tIDEuMC4wICgyMDExLzEyLzI4KSAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIyAqICgyMDExLzEyLzI4KSAtIENSOiBleHRyYWN0ZWQgZnVuY3Rpb25hbGl0eSBmcm9tIEtJWDRPVFJTIC0gc2VlIFsxXSAodHRvKQojCiMgWzFdIGh0dHBzOi8vb3Ryc3RlYW0uaWRlYXNjYWxlLmNvbS9hL2R0ZC9Db3B5LU9SLU1lcmdlLVNpbmdsZS1BcnRpY2xlLVRvLU90aGVyLVRpY2tldC8zMjE0NDktMTAzNjkKIwojLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo= <?xml version="1.0" encoding="utf-8" ?>
<otrs_package version="1.0">
    <CVS>$Id: ArticleCopyMoveDelete.sopm,v 1.2 2011-12-28 10:36:41 tto Exp $</CVS>
    <Name>ArticleCopyMoveDelete</Name>
    <Vendor>c.a.p.e. IT GmbH</Vendor>
    <URL>http://www.cape-it.de/</URL>
    <Description Lang="en">ArticleCopyMoveDelete - allows to copy, move or delete articles.</Description>
    <License>GNU AFFERO GENERAL PUBLIC LICENSE Version 3, November 2007</License>
    <Version>1.0.0</Version>
    <Framework>3.0.x</Framework>
    <BuildDate>?</BuildDate>
    <BuildHost>?</BuildHost>
    <Filelist>
        <File Permission="644" Location="CHANGES_articlecopymovedelete"/>
        <File Permission="644" Location="ArticleCopyMoveDelete.sopm"/>
        <File Permission="644" Location="doc/en/ArticleCopyMoveDelete.pod"/>
        <File Permission="644" Location="Kernel/Config/Files/AgentArticleCopyMove.xml"/>
        <File Permission="644" Location="Kernel/Language/de_ArticleCopyMoveDelete.pm"/>
        <File Permission="644" Location="Kernel/Modules/AgentArticleCopyMove.pm"/>
        <File Permission="644" Location="Kernel/Output/HTML/OutputFilterArticleCopyMoveDelete.pm"/>
        <File Permission="644" Location="Kernel/Output/HTML/Standard/AgentArticleCopyMove.dtl"/>
        <File Permission="644" Location="Kernel/System/Ticket/TicketExtensionsArticleCopyMove.pm"/>
        <File Permission="644" Location="var/packagesetup/AgentArticleCopyMove.pm"/>
    </Filelist>
    <DatabaseInstall></DatabaseInstall>
    <DatabaseReinstall></DatabaseReinstall>
    <DatabaseUpgrade></DatabaseUpgrade>
    <DatabaseUninstall></DatabaseUninstall>
    <CodeInstall Type="post">
        my $FunctionName = 'CodeInstall';
        my $CodeModule = 'var::packagesetup::' . $Param{Structure}-&gt;{Name}-&gt;{Content};

        # The code module has just recently been copied to it's location in the file system.
        # In a persistent Perl environment an old version of the module might still be loaded,
        # as watchdogs like Apache2::Reload haven't had a chance to reload it.
        # So we need to make sure that the new version is being loaded.
        # Kernel::System::Main::Require() checks the relative file path, so we need to remove that from %INC.
        # This is only needed in persistent Perl environment, but does no harm in a CGI environment.
        my $CodeModulePath = $CodeModule;
        $CodeModulePath =~ s/::/\//g;
        $CodeModulePath .= '.pm';
        delete $INC{$CodeModulePath};

        if ( $Self-&gt;{MainObject}-&gt;Require($CodeModule) ) {
            my $CodeObject = $CodeModule-&gt;new( %{$Self} );
            if ($CodeObject) {
                if ( !$CodeObject-&gt;$FunctionName(%{$Self}) ) {
                    $Self-&gt;{LogObject}-&gt;Log(
                        Priority =&gt; 'error',
                        Message  =&gt; &quot;Could not call method $FunctionName() on $CodeModule.pm.&quot;
                    );
                }
            }
            else {
                $Self-&gt;{LogObject}-&gt;Log(
                    Priority =&gt; 'error',
                    Message  =&gt; &quot;Could not call method new() on $CodeModule.pm.&quot;
                );
            }
        }
    </CodeInstall>
    <CodeReinstall Type="post">
        my $FunctionName = 'CodeReinstall';
        my $CodeModule = 'var::packagesetup::' . $Param{Structure}-&gt;{Name}-&gt;{Content};

        # The code module has just recently been copied to it's location in the file system.
        # In a persistent Perl environment an old version of the module might still be loaded,
        # as watchdogs like Apache2::Reload haven't had a chance to reload it.
        # So we need to make sure that the new version is being loaded.
        # Kernel::System::Main::Require() checks the relative file path, so we need to remove that from %INC.
        # This is only needed in persistent Perl environment, but does no harm in a CGI environment.
        my $CodeModulePath = $CodeModule;
        $CodeModulePath =~ s/::/\//g;
        $CodeModulePath .= '.pm';
        delete $INC{$CodeModulePath};

        if ( $Self-&gt;{MainObject}-&gt;Require($CodeModule) ) {
            my $CodeObject = $CodeModule-&gt;new( %{$Self} );
            if ($CodeObject) {
                if ( !$CodeObject-&gt;$FunctionName(%{$Self}) ) {
                    $Self-&gt;{LogObject}-&gt;Log(
                        Priority =&gt; 'error',
                        Message  =&gt; &quot;Could not call method $FunctionName() on $CodeModule.pm.&quot;
                    );
                }
            }
            else {
                $Self-&gt;{LogObject}-&gt;Log(
                    Priority =&gt; 'error',
                    Message  =&gt; &quot;Could not call method new() on $CodeModule.pm.&quot;
                );
            }
        }
    </CodeReinstall>
    <CodeUpgrade Type="post">
        my $FunctionName = 'CodeUpgrade';
        my $CodeModule = 'var::packagesetup::' . $Param{Structure}-&gt;{Name}-&gt;{Content};

        # The code module has just recently been copied to it's location in the file system.
        # In a persistent Perl environment an old version of the module might still be loaded,
        # as watchdogs like Apache2::Reload haven't had a chance to reload it.
        # So we need to make sure that the new version is being loaded.
        # Kernel::System::Main::Require() checks the relative file path, so we need to remove that from %INC.
        # This is only needed in persistent Perl environment, but does no harm in a CGI environment.
        my $CodeModulePath = $CodeModule;
        $CodeModulePath =~ s/::/\//g;
        $CodeModulePath .= '.pm';
        delete $INC{$CodeModulePath};

        if ( $Self-&gt;{MainObject}-&gt;Require($CodeModule) ) {
            my $CodeObject = $CodeModule-&gt;new( %{$Self} );
            if ($CodeObject) {
                if ( !$CodeObject-&gt;$FunctionName(%{$Self}) ) {
                    $Self-&gt;{LogObject}-&gt;Log(
                        Priority =&gt; 'error',
                        Message  =&gt; &quot;Could not call method $FunctionName() on $CodeModule.pm.&quot;
                    );
                }
            }
            else {
                $Self-&gt;{LogObject}-&gt;Log(
                    Priority =&gt; 'error',
                    Message  =&gt; &quot;Could not call method new() on $CodeModule.pm.&quot;
                );
            }
        }
    </CodeUpgrade>
    <CodeUninstall Type="pre">
        my $FunctionName = 'CodeUninstall';
        my $CodeModule = 'var::packagesetup::' . $Param{Structure}-&gt;{Name}-&gt;{Content};

        # The code module has just recently been copied to it's location in the file system.
        # In a persistent Perl environment an old version of the module might still be loaded,
        # as watchdogs like Apache2::Reload haven't had a chance to reload it.
        # So we need to make sure that the new version is being loaded.
        # Kernel::System::Main::Require() checks the relative file path, so we need to remove that from %INC.
        # This is only needed in persistent Perl environment, but does no harm in a CGI environment.
        my $CodeModulePath = $CodeModule;
        $CodeModulePath =~ s/::/\//g;
        $CodeModulePath .= '.pm';
        delete $INC{$CodeModulePath};

        if ( $Self-&gt;{MainObject}-&gt;Require($CodeModule) ) {
            my $CodeObject = $CodeModule-&gt;new( %{$Self} );
            if ($CodeObject) {
                if ( !$CodeObject-&gt;$FunctionName(%{$Self}) ) {
                    $Self-&gt;{LogObject}-&gt;Log(
                        Priority =&gt; 'error',
                        Message  =&gt; &quot;Could not call method $FunctionName() on $CodeModule.pm.&quot;
                    );
                }
            }
            else {
                $Self-&gt;{LogObject}-&gt;Log(
                    Priority =&gt; 'error',
                    Message  =&gt; &quot;Could not call method new() on $CodeModule.pm.&quot;
                );
            }
        }
    </CodeUninstall>
    <IntroInstall Type="pre" Title="Install Information" Lang="en"><![CDATA[
        <br/>
        <strong>WELCOME</strong>
        <br/>
        <br/>
        You are about to install the OTRS module ArticleCopyMoveDelete.
        <br/>
        <br/>
        <br/>
        c.a.p.e. IT ...easy.<br/>
        <br/>
    ]]></IntroInstall>
    <IntroInstall Type="post" Title="Installation Information" Lang="en"><![CDATA[
        <br/>
        <br/>
        <br/>
        c.a.p.e. IT ...easy.<br/>
        <br/>
    ]]></IntroInstall>
    <IntroUpgrade Type="pre" Title="Upgrade Information" Lang="en"><![CDATA[
        <br/>
        <strong>WELCOME</strong>
        <br/>
        <br/>
        You are about to upgrade the ArticleCopyMoveDelete extensions package for OTRS.<br/>
        <br/>
        <br/>
        c.a.p.e. IT ...easy.<br/>
        <br/>
    ]]></IntroUpgrade>
    <IntroUpgrade Type="post" Title="Upgrade Information" Lang="en"><![CDATA[
        <br/>
        <br/>
        <br/>
        c.a.p.e. IT ...easy.<br/>
        <br/>
    ]]></IntroUpgrade>
    <IntroUninstall Type="pre" Title="Uninstallation Information" Lang="en"><![CDATA[
        <br/>
        <strong>WELCOME</strong>
        <br/>
        <br/>
        You are about to UNINSTALL the ArticleCopyMoveDelete extensions package for OTRS.<br/>
        <br/>
        <br/>
        <br/>
        c.a.p.e. IT ...easy.<br/>
        <br/>
    ]]></IntroUninstall>
</otrs_package>
 IyAkSWQ6IEFydGljbGVDb3B5TW92ZURlbGV0ZS5wb2QsdiAxLjEgMjAxMS0xMi0yOCAxMDozMDo1NiB0dG8gRXhwICQKCj1oZWFkMSBHZW5lcmFsCgpUaGlzIHBhY2thZ2UgcHJvdmlkZXMgYW4gYWRkaXRpb25hbCBhcnRpY2xlIGFjdGlvbiB3aGljaCBhbGxvd3MgdG8gY29weSwgbW92ZSBmcm9tIG9uZSB0aWNrZXQgdG8gYW5vdGhlci4gSXQgYWxzbyBhbGxvd3MgdG8gZGVsZXRlIGFydGljbGVzIC0gc2VlIGh0dHBzOi8vb3Ryc3RlYW0uaWRlYXNjYWxlLmNvbS9hL2R0ZC9Db3B5LU9SLU1lcmdlLVNpbmdsZS1BcnRpY2xlLVRvLU90aGVyLVRpY2tldC8zMjE0NDktMTAzNjkuCgpUaGlzIGZ1bmN0aW9uYWxpdHkgaGFzIGJlZW4gZXh0cmFjdGVkIGZyb20gT1RSUyBleHRlbnNpb24gcGFja2FnZSBLSVg0T1RSUy4gCgo9aGVhZDEgVXNhZ2UgUmVtYXJrcwoKPW92ZXIgNCAKCj1pdGVtICogVGhlIGZ1bmN0aW9uIGlzIHJlc3RyaWN0ZWQgdG8gdGhlIG93bmVyIG9mIHRoZSB0aWNrZXQuCgo9aXRlbSAqIElmIHRoZXJlIGlzIG9ubHkgb25lIGFydGljbGUgbGVmdCBpbiB0aGUgdGlja2V0LCBvcHRpb25zIGZvciBtb3ZpbmcgYW5kIGRlbGV0aW5nIGFyZSBub3QgYXZhaWxhYmxlLgoKPWl0ZW0gKiBJZiB0aGVyZSBpcyB0aW1lIGFjY291bnRlZCBpbiBhbiBhcnRpY2xlIHdoaWNoIHdpbGwgYmUgY29waWVkLCB5b3UgbWF5IGRlZmluZSBpZiBhbmQgaG93IHRoaXMgYWNjb3VudGVkIHRpbWUgaXMgY29waWVkIHRvIHRoZSBkZXN0aW5hdGlvbiB0aWNrZXQuIAoKPWl0ZW0gKiBEdWUgdG8gdGhlIGxhY2sgb2YgZXh0ZW5zaW9uIG1ldGhvZHMgZm9yIGZyb250ZW5kIG1vZHVsZXMgb2Ygb3RoZXIgZXh0ZW5zaW9ucyAoaS5lLiBPVFJTOjpJVFNNKSBpbiBPVFJTIGFuZCBtaXNzaW5nIGNvbmZpZ3VyYWJpbGl0eSBvZiBhcnRpY2xlIGFjdGlvbnMsIHRoZSBhcnRpY2xlIGNvcHktLCBtb3ZlLSwgZGVsZXRlLSBmdW5jdGlvbiBpcyBpbnRlZ3JhdGVkIGludG8gdGhlIGZyb250ZW5kIGJ5IE91dHB1dEZpbHRlcnMuIERpc2FibGluZyBBcnRpY2xlUHJpbnQgd2lsbCBhbHNvIGRpc2FibGUgdGhpcyBmdW5jdGlvbi4KCj1iYWNrCgo9aGVhZDEgVG8gRG8KCj1vdmVyIDQgCgo9aXRlbSAqIG91dHB1dCBmaWx0ZXIgY3JlYXRlcyB0d28gYWN0aW9uIGxpbmtzIGFmdGVyIHJlbG9hZCBvZiBBZ2VudFRpY2tldFpvb20gYWZ0ZXIgYXJ0aWNsZSBjcmVhdGlvbgoKPWl0ZW0gKiBtYWtlIHJlc3RyaWN0aW9uIHRvIG93bmVyIGNvbmZpZ3VyYWJsZQoKCj1iYWNrCgoKPWhlYWQxIENvcHlyaWdodAoKQ29weXJpZ2h0IChDKSAyMDA2LTIwMTIgYy5hLnAuZS4gSVQgR21iSCwgaHR0cDovL3d3dy5jYXBlLWl0LmRlCgpBcnRpY2xlQ29weU1vdmVEZWxldGUgd3JpdHRlbi9lZGl0ZWQgYnk6Cgo9b3ZlciA0IAoKPWl0ZW0gKiBSZW5lKGRvdClCb2VobShhdCljYXBlKGRhc2gpaXQoZG90KWRlCgo9aXRlbSAqIE1hcnRpbihkb3QpQmFsemFyZWsoYXQpY2FwZShkYXNoKWl0KGRvdClkZQoKPWl0ZW0gKiBUb3JzdGVuKGRvdClUaGF1KGF0KWNhcGUoZGFzaClpdChkb3QpZGUKCj1iYWNrCgpUaGlzIHNvZnR3YXJlIGNvbWVzIHdpdGggQUJTT0xVVEVMWSBOTyBXQVJSQU5UWS4gRm9yIGRldGFpbHMsIHNlZSB0aGUgZW5jbG9zZWQgZmlsZSBDT1BZSU5HIGZvciBsaWNlbnNlIGluZm9ybWF0aW9uIChBR1BMKS4gSWYgeW91IGRpZCBub3QgcmVjZWl2ZSB0aGlzIGZpbGUsIHNlZSBodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvYWdwbC50eHQuCgo9Y3V0Cg== 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 # --
# Kernel/Modules/AgentArticleCopyMove.pm - to copy or move articles
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by:
# * Stefan(dot)Mehlig(at)cape(dash)it(dot)de
# * Rene(dot)Boehm(at)cape(dash)it(dot)de
# * Martin(dot)Balzarek(at)cape(dash)it(dot)de
#
# --
# $Id: AgentArticleCopyMove.pm,v 1.1 2011-12-28 10:30:57 tto 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::Modules::AgentArticleCopyMove;

use strict;
use warnings;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.1 $) [1];

sub new {
    my ( $Type, %Param ) = @_;

    # allocate new hash for object
    my $Self = {%Param};
    bless( $Self, $Type );

    # check needed objects
    for my $Needed (qw(ParamObject DBObject TicketObject LayoutObject LogObject ConfigObject)) {
        if ( !$Self->{$Needed} ) {
            $Self->{LayoutObject}->FatalError( Message => "Got no $Needed!" );
        }
    }

    return $Self;
}

sub Run {
    my ( $Self, %Param ) = @_;

    my $Output = $Self->{LayoutObject}->Header( Type => 'Small' );

    # check permissions
    my $Access = 0;
    my $Groups = $Self->{ConfigObject}->Get('Frontend::Module')->{AgentArticleCopyMove}->{Group}
        || '';
    if ( $Groups && ref($Groups) eq 'ARRAY' ) {
        for my $Group ( @{$Groups} ) {
            next if !$Self->{LayoutObject}->{"UserIsGroup[$Group]"};
            if ( $Self->{LayoutObject}->{"UserIsGroup[$Group]"} eq 'Yes' ) {
                $Access = 1;
                last;
            }
        }
    }
    else {
        $Access = 1;
    }

    if ( !$Access ) {
        $Output .= $Self->{LayoutObject}->Warning(
            Message => 'Sorry, you are not a member of allowed groups!',
            Comment => 'Please contact your admin.',
        );
        $Output .= $Self->{LayoutObject}->Footer( Type => 'Small' );
        return $Output;
    }

    # get params
    my %GetParam;
    for (qw(ArticleID TicketID ArticleAction NewTicketNumber TimeUnits TimeUnitsOriginal)) {
        $GetParam{$_} = $Self->{ParamObject}->GetParam( Param => $_ ) || '';
    }

    # check needed stuff
    for (qw(ArticleID TicketID)) {
        if ( !$GetParam{$_} ) {
            return $Self->{LayoutObject}->ErrorScreen(
                Message => "AgentArticleCopyMove: Need $_!",
                Comment => 'Please contact your admin.',
            );
        }
    }

    # check permissions
    $Access = $Self->{TicketObject}->OwnerCheck(
        TicketID => $GetParam{TicketID},
        OwnerID  => $Self->{UserID},
    );

    # error screen, don't show ticket
    if ( !$Access ) {
        $Output .= $Self->{LayoutObject}->Warning(
            Message => 'Sorry, you need to be owner of the selected ticket to do this action!',
            Comment => 'Please change the owner first.',
        );
        $Output .= $Self->{LayoutObject}->Footer( Type => 'Small' );
        return $Output;
    }

    # get first article
    my %FirstArticle = $Self->{TicketObject}->ArticleFirstArticle(
        TicketID => $GetParam{TicketID},
    );

    # check copy or move first article
    if ( $GetParam{ArticleID} != $FirstArticle{ArticleID} ) {
        $GetParam{FurtherActionOptions} = 1;
    }

    # get article content
    my %Article = $Self->{TicketObject}->ArticleGet(
        ArticleID => $GetParam{ArticleID},
    );

    # get accounting time
    $Param{AccountedTime} = $Self->{TicketObject}->ArticleAccountedTimeGet(
        ArticleID => $GetParam{ArticleID},
    );
    if ( $Self->{ConfigObject}->Get('Ticket::Frontend::NeedAccountedTime') ) {
        $Param{NeedAccountedTime} = 'Validate_Required';
    }

    if ( $Param{AccountedTime} ) {
        $Self->{LayoutObject}->Block(
            Name => 'TimeUnitsJs',
            Data => {
                %Param,
                TimeUnitsOriginal => $GetParam{TimeUnitsOriginal} || 'Difference',
            },
        );
        $Self->{LayoutObject}->Block(
            Name => 'TimeUnits',
            Data => \%Param,
        );
    }

    if ( $Self->{Subaction} eq 'Update' ) {
        my $NewTicketID = $GetParam{TicketID};

        # challenge token check for write action
        $Self->{LayoutObject}->ChallengeTokenCheck();

        # delete article
        if ( $GetParam{ArticleAction} eq 'Delete' ) {
            my $DeleteResult = $Self->{TicketObject}->ArticleFullDelete(
                ArticleID => $GetParam{ArticleID},
                UserID    => $Self->{UserID},
            );
            if ( !$DeleteResult ) {
                return $Self->{LayoutObject}->ErrorScreen(
                    Message =>
                        "Can't delete article $GetParam{ArticleID} from ticket $Article{TicketNumber}!",
                    Comment => 'Please contact your admin.',
                );
            }

            # add history to original ticket
            $Self->{TicketObject}->HistoryAdd(
                Name => "Deleted article $GetParam{ArticleID} from ticket $Article{TicketNumber}",
                HistoryType  => 'Misc',
                TicketID     => $GetParam{TicketID},
                CreateUserID => $Self->{UserID},
            );
        }

        # preparations for move and copy
        else {

            # check needed stuff
            if ( !$GetParam{NewTicketNumber} ) {
                $Output .= $Self->{LayoutObject}->Notify(
                    Info => 'Perhaps, you forgot to enter a ticket number!',
                );
                $Output .= $Self->Form(
                    %Article,
                    %GetParam,
                    NewTicketNumberInvalid => 'ServerError',
                );
                return $Output;
            }

            # get new ticket id
            $NewTicketID = $Self->{TicketObject}->TicketCheckNumber(
                Tn => $GetParam{NewTicketNumber},
            );
            if ( !$NewTicketID ) {
                $Output .= $Self->{LayoutObject}->Notify(
                    Info =>
                        $Self->{LayoutObject}->{LanguageObject}
                        ->Get('Sorry, no ticket found for ticket number: ')
                        . $GetParam{NewTicketNumber}
                        . '!',
                );
                $Output .= $Self->Form(
                    %Article,
                    %GetParam,
                    NewTicketNumberInvalid => 'ServerError',
                );
                return $Output;
            }

            # check owner of new ticket
            my $NewAccessOk = $Self->{TicketObject}->OwnerCheck(
                TicketID => $NewTicketID,
                OwnerID  => $Self->{UserID},
            );
            if ( !$NewAccessOk ) {
                $Output .= $Self->{LayoutObject}->Notify(
                    Info => 'Sorry, you need to be owner of the new ticket to do this action!',
                );
                $Output .= $Self->Form(
                    %Article,
                    %GetParam,
                );
                $Output .= $Self->{LayoutObject}->Footer( Type => 'Small' );
                return $Output;
            }
        }

        # copy article
        if ( $GetParam{ArticleAction} eq 'Copy' ) {
            my $CopyResult = $Self->{TicketObject}->ArticleCopy(
                TicketID  => $NewTicketID,
                ArticleID => $GetParam{ArticleID},
                UserID    => $Self->{UserID},
            );
            if ( $CopyResult eq 'CopyFailed' ) {
                return $Self->{LayoutObject}->ErrorScreen(
                    Message =>
                        "Can't copy article $GetParam{ArticleID} to ticket $GetParam{NewTicketNumber}!",
                    Comment => 'Please contact your admin.',
                );
            }
            elsif ( $CopyResult eq 'UpdateFailed' ) {
                return $Self->{LayoutObject}->ErrorScreen(
                    Message => "Can't update times for article $GetParam{ArticleID}!",
                    Comment => 'Please contact your admin.',
                );
            }

            # add accounted time to new article
            if ( $GetParam{TimeUnits} ) {
                $Self->{TicketObject}->TicketAccountTime(
                    TicketID  => $NewTicketID,
                    ArticleID => $CopyResult,
                    TimeUnit  => $GetParam{TimeUnits},
                    UserID    => $Self->{UserID},
                );
            }

            # delete accounted time from old article
            if ( $GetParam{TimeUnitsOriginal} ne 'Keep' ) {
                $Self->{TicketObject}->ArticleAccountedTimeDelete(
                    ArticleID => $GetParam{ArticleID},
                );
            }

            # save residual if choosen to old article
            if ( $GetParam{TimeUnitsOriginal} eq 'Difference' ) {
                $Self->{TicketObject}->TicketAccountTime(
                    TicketID  => $GetParam{TicketID},
                    ArticleID => $GetParam{ArticleID},
                    TimeUnit  => ( $Param{AccountedTime} - $GetParam{TimeUnits} ),
                    UserID    => $Self->{UserID},
                );
            }

            # add history to original ticket
            $Self->{TicketObject}->HistoryAdd(
                Name => "Copied article $GetParam{ArticleID} from "
                    . "ticket $Article{TicketNumber} to ticket $GetParam{NewTicketNumber} "
                    . "as article $CopyResult",
                HistoryType  => 'Misc',
                TicketID     => $GetParam{TicketID},
                ArticleID    => $GetParam{ArticleID},
                CreateUserID => $Self->{UserID},
            );
        }

        # move article
        elsif ( $GetParam{ArticleAction} eq 'Move' ) {
            my $MoveResult = $Self->{TicketObject}->ArticleMove(
                TicketID  => $NewTicketID,
                ArticleID => $GetParam{ArticleID},
                UserID    => $Self->{UserID},
            );
            if ( $MoveResult eq 'MoveFailed' ) {
                return $Self->{LayoutObject}->ErrorScreen(
                    Message =>
                        "Can't move article $GetParam{ArticleID} to ticket $GetParam{NewTicketNumber}!",
                    Comment => 'Please contact your admin.',
                );
            }
            if ( $MoveResult eq 'AccountFailed' ) {
                return $Self->{LayoutObject}->ErrorScreen(
                    Message =>
                        "Can't update ticket id in time accounting data for article $GetParam{ArticleID}!",
                    Comment => 'Please contact your admin.',
                );
            }

            # add history to new ticket
            $Self->{TicketObject}->HistoryAdd(
                Name => "Moved article $GetParam{ArticleID} from ticket"
                    . " $Article{TicketNumber} to ticket $GetParam{NewTicketNumber} ",
                HistoryType  => 'Misc',
                TicketID     => $NewTicketID,
                ArticleID    => $GetParam{ArticleID},
                CreateUserID => $Self->{UserID},
            );

            # add history to old ticket
            $Self->{TicketObject}->HistoryAdd(
                Name => "Moved article $GetParam{ArticleID} from ticket"
                    . " $Article{TicketNumber} to ticket $GetParam{NewTicketNumber} ",
                HistoryType  => 'Misc',
                TicketID     => $GetParam{TicketID},
                ArticleID    => $GetParam{ArticleID},
                CreateUserID => $Self->{UserID},
            );
        }

        # redirect
        return $Self->{LayoutObject}->PopupClose(
            URL => "Action=AgentTicketZoom&TicketID=$NewTicketID"
        );
    }

    # show form
    $GetParam{CopyTypeChecked} = 'checked="checked"';
    $Output .= $Self->Form(
        %Article,
        %GetParam,
    );
    return $Output;
}

sub Form {
    my ( $Self, %Param ) = @_;

    $Self->{LayoutObject}->Block(
        Name => 'ArticleActionOptions',
        Data => \%Param,
    );

    if ( $Param{FurtherActionOptions} ) {
        $Self->{LayoutObject}->Block(
            Name => 'FurtherActionOptions',
            Data => \%Param,
        );
    }

    # start output
    my $Output = $Self->{LayoutObject}->Output(
        TemplateFile => 'AgentArticleCopyMove',
        Data         => {
            %Param,
            ArticleAction => $Param{ArticleAction} || 'Copy',
        },
    );
    $Output .= $Self->{LayoutObject}->Footer( Type => 'Small' );
    return $Output;
}

1;
 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 # --
# AgentArticleCopyMove.dtl - provides HTML form for AgentArticleCopyMove
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by:
# * Martin(dot)Balzarek(at)cape(dash)it(dot)de
# * Stefan(dot)Mehlig(at)cape(dash)it(dot)de
#
# --
# $Id: AgentArticleCopyMove.dtl,v 1.1 2011-12-28 10:30:57 tto 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.
# --

<form action="$Env{"CGIHandle"}" method="post" enctype="multipart/form-data" name="compose" id="Compose" class="Validate PreventMultipleSubmits">
    <input type="hidden" name="Action" value="$Env{"Action"}"/>
    <input type="hidden" name="Subaction" value="Update"/>
    <input type="hidden" name="TicketID" value="$QData{"TicketID"}"/>
    <input type="hidden" name="ArticleID" value="$QData{"ArticleID"}"/>

    <div class="LayoutPopup ARIARoleMain">
        <div class="Header">
            <h1>$Text{"Copy/Move/Delete"} $Config{"Ticket::Hook"}$QData{"TicketNumber"} - $QData{"Title", "50"}</h1>

            <p>
                <a class="CancelClosePopup" href="#">$Text{"Cancel & close window"}</a>
            </p>

        </div>

        <div class="Content">

            <h2>$Text{"Options"}</h2>

            <fieldset class="TableLike FixedLabel">
                <label class="Mandatory">
                    $Text{"Article"}-$Text{"Subject"}:
                </label>
                <div class="Field">
                    $QData{"Subject"}
                </div>
                <div class="Clear"></div>

                <label class="Mandatory">
                    <span class="Marker">*</span>
                    $Text{"Action to be performed"}:
                </label>
<!-- dtl:block:ArticleActionOptions -->
                <div class="Field">
				    <input type="radio" name="ArticleAction" id="CopyCheckbox" class="ArticleActionRadio" value="Copy"/>
                    <label for="CopyCheckbox">$Text{"Copy"}</label>
                    <br/>

<!-- dtl:block:FurtherActionOptions -->
                    <input type="radio" name="ArticleAction" id="MoveCheckbox" class="ArticleActionRadio" value="Move"/>
                    <label for="MoveCheckbox">$Text{"Move"}</label>
                    <br/>

                    <input type="radio" name="ArticleAction" id="DeleteCheckbox" class="ArticleActionRadio" value="Delete"/>
                    <label for="DeleteCheckbox">$Text{"Delete"}</label>
                    <br/>
<!-- dtl:block:FurtherActionOptions -->
                </div>
                <div class="SpacingTop Clear"></div>
<!-- dtl:block:ArticleActionOptions -->
            </fieldset>

            <fieldset class="TableLike FixedLabel Hidden DeleteOptions">
                <label class="Mandatory">
                    $Text{"Options for Delete"}
                </label>
                <div class="Clear"></div>
                <label for="DeletedConfirm">
                    $Text{"Really delete this article?"}
                </label>
                <div class="Field">
                    <input type="checkbox" name="DeletedConfirm" id="DeletedConfirm" value="Delete" class="Validate_Required"/>
                    <div id="DeletedConfirmError" class="TooltipErrorMessage"><p>$Text{"This field is required."}</p></div>
                    <div id="DeletedConfirmServerError" class="TooltipErrorMessage"><p>$Text{"This field is required."}</p></div>
                </div>
                <div class="Clear"></div>
            </fieldset>

            <fieldset class="TableLike FixedLabel Hidden MoveOptions CopyOptions">
                <label class="Mandatory" id="MoveCopyTitle">
                    $Text{"Options for Copy"}
                </label>
                <div class="Clear"></div>
                <label class="Mandatory" for="NewTicketNumber">
                    <span class="Marker">*</span>
                    $Config{"Ticket::Hook"} $Text{"of destination ticket"}:
                </label>
                <div class="Value">
                    <input type="text" name="NewTicketNumber" id="NewTicketNumber" value="$QData{"NewTicketNumber"}" class="W20pc Validate_Required $QData{"NewTicketNumberInvalid"}"/>
                    <div id="NewTicketNumberError" class="TooltipErrorMessage"><p>$Text{"This field is required."}</p></div>
                    <div id="NewTicketNumberServerError" class="TooltipErrorMessage"><p>$Text{"Invalid ticket number!"}</p></div>
                </div>
                <div class="Clear"></div>
            </fieldset>

<!-- dtl:block:TimeUnits -->
            <fieldset class="TableLike FixedLabel Hidden CopyOptions">
                <label for="TimeUnits">
                    $Text{"Copied time units of the source article"}
                </label>
                <div class="Field">
                    <input type="text" name="TimeUnits" id="TimeUnits" value="$QData{"AccountedTime"}" class="W10pc Validate_TimeUnits Validate_Lower Validate_Lower_$QData{"AccountedTime"} $QData{"NeedAccountedTime"}"/>
                    $Text{"$Config{"Ticket::Frontend::TimeUnits"}"}
                    <div id="TimeUnitsError" class="TooltipErrorMessage"><p>$Text{"Invalid time!"}<br/>$Text{"You cannot asign more time units as in the source article!"}</p></div>
                </div>
                <div class="Clear"></div>

                <label>
                    $Text{"Handling of accounted time from source article?"}
                </label>
                <div class="Field">
                    <input type="radio" name="TimeUnitsOriginal" id="TimeUnitsOriginalKeep" class="TimeUnitsOriginal" value="Keep"/>
                    <label for="TimeUnitsOriginalKeep">$Text{"Leave unchanged"}</label>
                    <br/>

                    <input type="radio" name="TimeUnitsOriginal" id="TimeUnitsOriginalDifference" class="TimeUnitsOriginal" value="Difference"/>
                    <label for="TimeUnitsOriginalDifference">$Text{"Change to residue"}</label>
                    <br/>

                    <input type="radio" name="TimeUnitsOriginal" id="TimeUnitsOriginalDelete" class="TimeUnitsOriginal" value="Delete"/>
                    <label for="TimeUnitsOriginalDelete">$Text{"Delete"}</label>
                </div>
                <div class="Clear"></div>
            </fieldset>
<!-- dtl:block:TimeUnits -->

        </div>
        <div class="Footer">
            <button class="Primary" id="submitRichText" accesskey="g" title="$Text{"Submit"} (g)" type="submit" value="$Text{"Send mail!"}" >$Text{"Submit"}</button>
        </div>
    </div>
</form>

<!--dtl:js_on_document_complete-->
<script type="text/javascript">//<![CDATA[
var InitVal = $('.ArticleActionRadio:checked').val(),
    $CopyOptions = $('.CopyOptions'),
    $DeleteOptions = $('.DeleteOptions'),
    $MoveOptions = $('.MoveOptions'),
    $DeleteConfirm = $('#DeletedConfirm'),
    $NewTicketNumber = $('#NewTicketNumber'),
    $MoveCopyTitle = $('#MoveCopyTitle');

// show only options, which belong to selected article
$('.' + InitVal + 'Options').removeClass('Hidden');

// show options according to selected article action
$('.ArticleActionRadio').bind('change', function () {
    var CurrVal = $(this).val();

    // change required fields and labels according to selected article action
    if (CurrVal == 'Delete') {
        $DeleteConfirm.addClass('Validate_Required');
        $NewTicketNumber.removeClass('Validate_Required');

        $CopyOptions.addClass('Hidden');
        $MoveOptions.addClass('Hidden');
        $DeleteOptions.removeClass('Hidden');
    }
    else {
        $DeleteConfirm.removeClass('Validate_Required');
        $NewTicketNumber.addClass('Validate_Required');

        if (CurrVal == 'Copy') {
            $DeleteOptions.addClass('Hidden');
            $MoveOptions.addClass('Hidden');
            $CopyOptions.removeClass('Hidden');
            $MoveCopyTitle.html('$Text{"Options for Copy"}');
        }
        else if (CurrVal == 'Move') {
            $CopyOptions.addClass('Hidden');
            $DeleteOptions.addClass('Hidden');
            $MoveOptions.removeClass('Hidden');
            $MoveCopyTitle.html('$Text{"Options for Move"}');
        }
    }

    return;
});
$('.ArticleActionRadio').filter('[value=$QData{"ArticleAction"}]').attr('checked', true).trigger('change');

<!-- dtl:block:TimeUnitsJs -->
// add validation for maximum time units
$.validator.addMethod("Validate_Lower", function (Value, Element) {
    var Classes = $(Element).attr('class'),
        MaxValue = 0,
        LowerClassPrefix = 'Validate_Lower_',
        RegExLower = new RegExp(LowerClassPrefix);

    $.each(Classes.split(' '), function (Index, Value) {
        if (RegExLower.test(Value)) {
            MaxValue = Value.replace(LowerClassPrefix, '');
        }
    });

    return (parseInt(Value, 10) <= MaxValue);
});

$.validator.addClassRules("Validate_Lower", {
    Validate_Lower: true
});

// disable validation of time units, if it is not a copy action
$('.ArticleActionRadio').bind('change', function () {
    var $TimeUnits = $('#TimeUnits');
    if ($(this).val() == 'Copy') $TimeUnits.addClass('Validate_Lower $QData{"NeedAccountedTime"}');
    else $TimeUnits.removeClass('Validate_Lower $QData{"NeedAccountedTime"}');
    return;
});

$('.TimeUnitsOriginal').filter('[value=$QData{"TimeUnitsOriginal"}]').attr('checked', true).trigger('change');

<!-- dtl:block:TimeUnitsJs -->
//]]></script>
<!--dtl:js_on_document_complete-->
 # --
# Kernel/System/Ticket/TicketExtensionsArticleCopyMove.pm - ArticleCopyMoveDelete ticket changes
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by:
# * Torsten(dot)Thau(at)cape(dash)it(dot)de
# * Rene(dot)Boehm(at)cape(dash)it(dot)de
# * Martin(dot)Balzarek(at)cape(dash)it(dot)de
# * Stefan(dot)Mehlig(at)cape(dash)it(dot)de
# * Anna(dot)Litvinova(at)cape(dash)it(dot)de
# * Frank(dot)Oberender(at)cape(dash)it(dot)de
# * Dorothea(dot)Doerffel(at)cape(dash)it(dot)de
#
# --
# $Id: TicketExtensionsArticleCopyMove.pm,v 1.1 2011-12-28 10:30:57 tto 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::Ticket::TicketExtensionsArticleCopyMove;

use strict;
use warnings;

use vars qw(@ISA $VERSION);
$VERSION = qw($Revision: 1.1 $) [1];

=item ArticleMove()

Moves an article to another ticket

    my $Result = $TicketObject->ArticleMove(
        TicketID  => 123,
        ArticleID => 123,
        UserID    => 123,
    );

Result:
    1
    MoveFailed
    AccountFailed

Events:
    ArticleMove

=cut

sub ArticleMove {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Needed (qw(ArticleID TicketID UserID)) {
        if ( !$Param{$Needed} ) {
            $Self->{LogObject}->Log( Priority => 'error', Message => "ArticleMove: Need $Needed!" );
            return;
        }
    }

    # update article data
    return 'MoveFailed' if !$Self->{DBObject}->Do(
        SQL => "UPDATE article SET ticket_id = ?, "
            . "change_time = current_timestamp, change_by = ? WHERE id = ?",
        Bind => [ \$Param{TicketID}, \$Param{UserID}, \$Param{ArticleID} ],
    );

    # update time accounting data
    return 'AccountFailed' if !$Self->{DBObject}->Do(
        SQL => 'UPDATE time_accounting SET ticket_id = ?, '
            . "change_time = current_timestamp, change_by = ? WHERE article_id = ?",
        Bind => [ \$Param{TicketID}, \$Param{UserID}, \$Param{ArticleID} ],
    );

    # clear ticket cache
    delete $Self->{ 'Cache::GetTicket' . $Param{TicketID} };

    # event
    $Self->EventHandler(
        Event => 'ArticleMove',
        Data  => {
            TicketID  => $Param{TicketID},
            ArticleID => $Param{ArticleID},
        },
        UserID => $Param{UserID},
    );

    return 1;
}

=item ArticleCopy()

Copies an article to another ticket including all attachments

    my $Result = $TicketObject->ArticleCopy(
        TicketID  => 123,
        ArticleID => 123,
        UserID    => 123,
    );

Result:
    NewArticleID
    'NoOriginal'
    'CopyFailed'
    'UpdateFailed'

Events:
    ArticleCopy

=cut

sub ArticleCopy {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Needed (qw(ArticleID TicketID UserID)) {
        if ( !$Param{$Needed} ) {
            $Self->{LogObject}->Log( Priority => 'error', Message => "ArticleCopy: Need $Needed!" );
            return;
        }
    }

    # get original article content
    my %Article = $Self->ArticleGet(
        ArticleID => $Param{ArticleID},
    );
    return 'NoOriginal' if !%Article;

    # copy original article
    my $CopyArticleID = $Self->ArticleCreate(
        %Article,
        TicketID       => $Param{TicketID},
        UserID         => $Param{UserID},
        HistoryType    => 'Misc',
        HistoryComment => "Copied article $Param{ArticleID} from "
            . "ticket $Article{TicketID} to ticket $Param{TicketID}",
    );
    return 'CopyFailed' if !$CopyArticleID;

    # set article times from original article
    return 'UpdateFailed' if !$Self->{DBObject}->Do(
        SQL =>
            'UPDATE article SET create_time = ?, change_time = ?, incoming_time = ? WHERE id = ?',
        Bind => [
            \$Article{Created},      \$Article{Changed},
            \$Article{IncomingTime}, \$CopyArticleID
        ],
    );

    # copy attachments from original article
    my %ArticleIndex = $Self->ArticleAttachmentIndex(
        ArticleID => $Param{ArticleID},
        UserID    => $Param{UserID},
    );
    for my $Index ( keys %ArticleIndex ) {
        my %Attachment = $Self->ArticleAttachment(
            ArticleID => $Param{ArticleID},
            FileID    => $Index,
            UserID    => $Param{UserID},
        );
        $Self->ArticleWriteAttachment(
            %Attachment,
            ArticleID => $CopyArticleID,
            UserID    => $Param{UserID},
        );
    }

    # clear ticket cache
    delete $Self->{ 'Cache::GetTicket' . $Param{TicketID} };

    # event
    $Self->EventHandler(
        Event => 'ArticleCopy',
        Data  => {
            TicketID     => $Param{TicketID},
            ArticleID    => $CopyArticleID,
            OldArticleID => $Param{ArticleID},
        },
        UserID => $Param{UserID},
    );

    return $CopyArticleID;
}

=item ArticleFullDelete()

Delete an article, its history, its plain message, and all attachments

    my $Success = $TicketObject->ArticleFullDelete(
        ArticleID => 123,
        UserID    => 123,
    );

ATTENTION:
    sub ArticleDelete is used in this sub, but this sub does not delete
    article history

Events:
    ArticleFullDelete

=cut

sub ArticleFullDelete {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Needed (qw(ArticleID UserID)) {
        if ( !$Param{$Needed} ) {
            $Self->{LogObject}
                ->Log( Priority => 'error', Message => "ArticleFullDelete: Need $Needed!" );
            return;
        }
    }

    # get article content
    my %Article = $Self->ArticleGet(
        ArticleID => $Param{ArticleID},
    );
    return if !%Article;

    # clear ticket cache
    delete $Self->{ 'Cache::GetTicket' . $Article{TicketID} };

    # delete article history
    return if !$Self->{DBObject}->Do(
        SQL  => 'DELETE FROM ticket_history WHERE article_id = ?',
        Bind => [ \$Param{ArticleID} ],
    );

    # delete article, attachments and plain emails
    return if !$Self->ArticleDelete(
        ArticleID => $Param{ArticleID},
        UserID    => $Param{UserID},
    );

    # event
    $Self->EventHandler(
        Event => 'ArticleFullDelete',
        Data  => {
            TicketID  => $Article{TicketID},
            ArticleID => $Param{ArticleID},
        },
        UserID => $Param{UserID},
    );

    return 1;
}

=item ArticleCreateDateUpdate()

Manipulates the article create date

    my $Result = $TicketObject->ArticleCreateDateUpdate(
        ArticleID => 123,
        UserID    => 123,
    );

Events:
    ArticleUpdate

=cut

sub ArticleCreateDateUpdate {
    my ( $Self, %Param ) = @_;

    # check needed stuff
    for my $Needed (qw(TicketID ArticleID UserID Created IncomingTime)) {
        if ( !$Param{$Needed} ) {
            $Self->{LogObject}
                ->Log( Priority => 'error', Message => "ArticleCreateDateUpdate: Need $Needed!" );
            return;
        }
    }

    # db update
    return if !$Self->{DBObject}->Do(
        SQL => "UPDATE article SET incoming_time = ?, create_time = ?,"
            . "change_time = current_timestamp, change_by = ? WHERE id = ?",
        Bind => [ \$Param{IncomingTime}, \$Param{Created}, \$Param{UserID}, \$Param{ArticleID} ],
    );

    # event
    $Self->EventHandler(
        Event => 'ArticleUpdate',
        Data  => {
            TicketID  => $Param{TicketID},
            ArticleID => $Param{ArticleID},
        },
        UserID => $Param{UserID},
    );
    return 1;
}

# disable redefine warnings in this scope
{
    no warnings 'redefine';

    # reset all warnings
}

1;
 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