LightAdmin-AutoRepliesAndSignatures 11.0.2 Rother OSS GmbH https://otobo.io/ GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Provide a small documentation. Initial Release. Enable the LightAdmin capability for the Signature and Auto Response features 11.0.x 0e25d6a5504911e0dd56dfd82fa00ac6e033870d 2026-10-01 09:08:31 opms.rother-oss.com # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - 6efdc7bf2a3325277cd79a60f0f2407f8ad59e87 - Kernel/Modules/AdminAutoResponse.pm
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

package Kernel::Modules::AdminAutoResponse;

use strict;
use warnings;

use Kernel::Language qw(Translatable);

our $ObjectManagerDisabled = 1;

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

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

    # set pref for columns key
    $Self->{PrefKeyIncludeInvalid} = 'IncludeInvalid' . '-' . $Self->{Action};

    my %Preferences = $Kernel::OM->Get('Kernel::System::User')->GetPreferences(
        UserID => $Self->{UserID},
    );

    $Self->{IncludeInvalid} = $Preferences{ $Self->{PrefKeyIncludeInvalid} };
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
    if ( !$Param{AccessRw} && $Param{AccessRo} ) {
        $Self->{LightAdmin} = 1;
    }
# EO LightAdmin-AutoRepliesAndSignatures
    return $Self;
}

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

    my $LayoutObject       = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
    my $ParamObject        = $Kernel::OM->Get('Kernel::System::Web::Request');
    my $AutoResponseObject = $Kernel::OM->Get('Kernel::System::AutoResponse');
    my $QueueObject        = $Kernel::OM->Get('Kernel::System::Queue');

    $Param{IncludeInvalid} = $ParamObject->GetParam( Param => 'IncludeInvalid' );

    if ( defined $Param{IncludeInvalid} ) {
        $Kernel::OM->Get('Kernel::System::User')->SetPreferences(
            UserID => $Self->{UserID},
            Key    => $Self->{PrefKeyIncludeInvalid},
            Value  => $Param{IncludeInvalid},
        );

        $Self->{IncludeInvalid} = $Param{IncludeInvalid};
    }

    # ------------------------------------------------------------ #
    # change
    # ------------------------------------------------------------ #
    if ( $Self->{Subaction} eq 'Change' ) {
        my $ID   = $ParamObject->GetParam( Param => 'ID' ) || '';
        my %Data = $AutoResponseObject->AutoResponseGet(
            ID => $ID,
        );

        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
        if ( $Self->{LightAdmin} ) {
            my %Queues = $QueueObject->QueueAutoResponseMemberList( AutoResponseID => $ID );
            $Data{Permission} = $QueueObject->QueueListPermission(
                QueueIDs => [ keys %Queues ],
                UserID   => $Self->{UserID},
                Default  => 'rw',
            );

            # No permission for the template.
            if ( !$Data{Permission} ) {
                %Data = ();
            }
            elsif ( $Data{Permission} eq 'ro' ) {
                $Output .= $LayoutObject->Notify(
                    Priority => 'Notice',
                    Data     => $LayoutObject->{LanguageObject}->Translate('No permission to edit this auto response.'),
                );
            }
        }
# EO LightAdmin-AutoRepliesAndSignatures
        $Self->_Edit(
            Action => 'Change',
            %Data,
        );
        $Output .= $LayoutObject->Output(
            TemplateFile => 'AdminAutoResponse',
            Data         => \%Param,
        );
        $Output .= $LayoutObject->Footer();
        return $Output;
    }

    # ------------------------------------------------------------ #
    # change action
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'ChangeAction' ) {

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

        my ( %GetParam, %Errors );
        for my $Parameter (qw(ID Name Comment ValidID Response Subject TypeID AddressID)) {
            $GetParam{$Parameter} = $ParamObject->GetParam( Param => $Parameter ) || '';
        }

        # get composed content type
        $GetParam{ContentType} = 'text/plain';
        if ( $LayoutObject->{BrowserRichText} ) {
            $GetParam{ContentType} = 'text/html';
        }

        # get charset
        $GetParam{Charset} = $LayoutObject->{UserCharset};

        # check needed data
        for my $Needed (qw(Name ValidID AddressID TypeID Subject)) {
            if ( !$GetParam{$Needed} ) {
                $Errors{ $Needed . 'Invalid' } = 'ServerError';
            }
        }
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
        if ( $Self->{LightAdmin} ) {
            my %Queues = $QueueObject->QueueAutoResponseMemberList( AutoResponseID => $GetParam{ID} );
            my $Permission = $QueueObject->QueueListPermission(
                QueueIDs => [ keys %Queues ],
                UserID   => $Self->{UserID},
                Default  => 'rw',
            );

            # No permission to change the template.
            if ( $Permission ne 'rw' ) {
                $Errors{NoPermission} = 1;
            }
        }
# EO LightAdmin-AutoRepliesAndSignatures

        # if no errors occurred
        if ( !%Errors ) {

            # update auto response
            my $Update = $AutoResponseObject->AutoResponseUpdate( %GetParam, UserID => $Self->{UserID} );

            if ($Update)
            {

                # if the user would like to continue editing the auto response, just redirect to the edit screen
                if (
                    defined $ParamObject->GetParam( Param => 'ContinueAfterSave' )
                    && ( $ParamObject->GetParam( Param => 'ContinueAfterSave' ) eq '1' )
                    )
                {
                    my $ID = $ParamObject->GetParam( Param => 'ID' ) || '';
                    return $LayoutObject->Redirect( OP => "Action=$Self->{Action};Subaction=Change;ID=$ID" );
                }
                else {

                    # otherwise return to overview
                    return $LayoutObject->Redirect( OP => "Action=$Self->{Action}" );
                }
            }
        }

        # something has gone wrong
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();
        $Output .= $LayoutObject->Notify( Priority => 'Error' );
        $Self->_Edit(
            Action => 'Change',
            Errors => \%Errors,
            %GetParam,
        );
        $Output .= $LayoutObject->Output(
            TemplateFile => 'AdminAutoResponse',
            Data         => \%Param,
        );
        $Output .= $LayoutObject->Footer();
        return $Output;
    }

    # ------------------------------------------------------------ #
    # add
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'Add' ) {
        my %GetParam;
        $GetParam{Name} = $ParamObject->GetParam( Param => 'Name' );
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();
        $Self->_Edit(
            Action => 'Add',
            %GetParam,
        );
        $Output .= $LayoutObject->Output(
            TemplateFile => 'AdminAutoResponse',
            Data         => \%Param,
        );
        $Output .= $LayoutObject->Footer();
        return $Output;
    }

    # ------------------------------------------------------------ #
    # add action
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'AddAction' ) {

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

        my ( %GetParam, %Errors );
        for my $Parameter (qw(ID Name Comment ValidID Response Subject TypeID AddressID)) {
            $GetParam{$Parameter} = $ParamObject->GetParam( Param => $Parameter ) || '';
        }

        # get composed content type
        $GetParam{ContentType} = 'text/plain';
        if ( $LayoutObject->{BrowserRichText} ) {
            $GetParam{ContentType} = 'text/html';
        }

        # get charset
        $GetParam{Charset} = $LayoutObject->{UserCharset};

        # check needed data
        for my $Needed (qw(Name ValidID AddressID TypeID Subject)) {
            if ( !$GetParam{$Needed} ) {
                $Errors{ $Needed . 'Invalid' } = 'ServerError';
            }
        }

        # if no errors occurred
        if ( !%Errors ) {

            # add state
            my $AutoResponseID = $AutoResponseObject->AutoResponseAdd(
                %GetParam,
                UserID => $Self->{UserID}
            );
            if ($AutoResponseID) {
                $Self->_Overview();
                my $Output = $LayoutObject->Header();
                $Output .= $LayoutObject->NavigationBar();
                $Output .= $LayoutObject->Notify( Info => Translatable('Auto Response added!') );
                $Output .= $LayoutObject->Output(
                    TemplateFile => 'AdminAutoResponse',
                    Data         => \%Param,
                );
                $Output .= $LayoutObject->Footer();
                return $Output;
            }
        }

        # something has gone wrong
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();
        $Output .= $LayoutObject->Notify( Priority => 'Error' );
        $Self->_Edit(
            Action => 'Add',
            Errors => \%Errors,
            %GetParam,
        );
        $Output .= $LayoutObject->Output(
            TemplateFile => 'AdminAutoResponse',
            Data         => \%Param,
        );
        $Output .= $LayoutObject->Footer();
        return $Output;
    }

    # ------------------------------------------------------------
    # overview
    # ------------------------------------------------------------
    else {
        $Self->_Overview();
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();
        $Output .= $LayoutObject->Output(
            TemplateFile => 'AdminAutoResponse',
            Data         => \%Param,
        );
        $Output .= $LayoutObject->Footer();
        return $Output;
    }
}

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

    my $LayoutObject       = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
    my $AutoResponseObject = $Kernel::OM->Get('Kernel::System::AutoResponse');

    $LayoutObject->Block(
        Name => 'Overview',
        Data => \%Param,
    );

    $LayoutObject->Block( Name => 'ActionList' );
    $LayoutObject->Block( Name => 'ActionOverview' );

    # get valid list
    my %ValidList        = $Kernel::OM->Get('Kernel::System::Valid')->ValidList();
    my %ValidListReverse = reverse %ValidList;

    $Param{ValidOption} = $LayoutObject->BuildSelection(
        Data       => \%ValidList,
        Name       => 'ValidID',
        SelectedID => $Param{ValidID} || $ValidListReverse{valid},
        Class      => 'Modernize Validate_Required ' . ( $Param{Errors}->{'ValidIDInvalid'} || '' ),
    );

    $Param{TypeOption} = $LayoutObject->BuildSelection(
        Data       => { $AutoResponseObject->AutoResponseTypeList(), },
        Name       => 'TypeID',
        SelectedID => $Param{TypeID},
        Class      => 'Modernize Validate_Required ' . ( $Param{Errors}->{'TypeIDInvalid'} || '' ),
    );

    $Param{SystemAddressOption} = $LayoutObject->BuildSelection(
        Data        => { $Kernel::OM->Get('Kernel::System::SystemAddress')->SystemAddressList( Valid => 1 ), },
        Name        => 'AddressID',
        SelectedID  => $Param{AddressID},
        Translation => 0,
        Class       => 'Modernize Validate_Required ' . ( $Param{Errors}->{'AddressIDInvalid'} || '' ),
    );

    my $HTMLUtilsObject = $Kernel::OM->Get('Kernel::System::HTMLUtils');

    # add rich text editor
    if ( $LayoutObject->{BrowserRichText} ) {

        # reformat from plain to html
        if ( $Param{ContentType} && $Param{ContentType} =~ /text\/plain/i ) {
            $Param{Response} = $HTMLUtilsObject->ToHTML(
                String => $Param{Response},
            );
        }
    }
    else {

        # reformat from html to plain
        if ( $Param{ContentType} && $Param{ContentType} =~ /text\/html/i ) {
            $Param{Response} = $HTMLUtilsObject->ToAscii(
                String => $Param{Response},
            );
        }
    }

    $LayoutObject->Block(
        Name => 'OverviewUpdate',
        Data => {
            %Param,
            %{ $Param{Errors} },
        },
    );

    if ( $LayoutObject->{BrowserRichText} ) {

        # set up rich text editor
        $LayoutObject->SetRichTextParameters(
            Data => \%Param,
        );
    }

    return 1;
}

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

    my $LayoutObject       = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
    my $QueueObject  = $Kernel::OM->Get('Kernel::System::Queue');
# EO LightAdmin-AutoRepliesAndSignatures

    $LayoutObject->Block(
        Name => 'Overview',
        Data => \%Param,
    );

    $LayoutObject->Block( Name => 'ActionList' );
    $LayoutObject->Block( Name => 'ActionAdd' );
    $LayoutObject->Block(
        Name => 'IncludeInvalid',
        Data => {
            IncludeInvalid        => $Self->{IncludeInvalid},
            IncludeInvalidChecked => $Self->{IncludeInvalid} ? 'checked' : '',
        },
    );
    $LayoutObject->Block( Name => 'Filter' );

    $LayoutObject->Block(
        Name => 'OverviewResult',
        Data => \%Param,
    );
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
    my $AutoResponseObject = $Kernel::OM->Get('Kernel::System::AutoResponse');
    my %List = $AutoResponseObject->AutoResponseList(
        Valid => $Self->{IncludeInvalid} ? 0 : 1,
    );
    if ( $Self->{LightAdmin} ) {

        # check queue permissions of linked templates.
        for my $ListKey ( keys %List ) {
            my %Data = $AutoResponseObject->AutoResponseGet( ID => $ListKey );
            my %Queues = $QueueObject->QueueAutoResponseMemberList(
                AutoResponseID => $Data{ID}
            );
            $Data{Permission} = $QueueObject->QueueListPermission(
                QueueIDs => [ keys %Queues ],
                UserID   => $Self->{UserID},
                Default  => 'rw',
            );
            if (!$Data{Permission}) {
                delete $List{$ListKey}
            }
        }
    }
# EO LightAdmin-AutoRepliesAndSignatures

    # if there are any results, they are shown
    if (%List) {

        # get valid list
        my %ValidList = $Kernel::OM->Get('Kernel::System::Valid')->ValidList();
        for my $ID ( sort { $List{$a} cmp $List{$b} } keys %List ) {
            my %Data = $AutoResponseObject->AutoResponseGet(
                ID => $ID,
            );
            $LayoutObject->Block(
                Name => 'OverviewResultRow',
                Data => {
                    Valid => $ValidList{ $Data{ValidID} },
                    %Data,
                    Attachments => int rand 5,
                },
            );
        }
    }

    # otherwise a no data message is displayed
    else {
        $LayoutObject->Block(
            Name => 'NoDataFoundMsg',
            Data => {},
        );
    }
    return 1;
}

1;
 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - ff9e297baf287e16071d3ac6ad7f6c13f11ac7fa - Kernel/Modules/AdminQueueAutoResponse.pm
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

package Kernel::Modules::AdminQueueAutoResponse;

use strict;
use warnings;

use Kernel::Language qw(Translatable);

our $ObjectManagerDisabled = 1;

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

    # allocate new hash for object
    my $Self = {%Param};
    bless( $Self, $Type );
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
    if ( !$Param{AccessRw} && $Param{AccessRo} ) {
        $Self->{LightAdmin} = 1;
    }
# EO LightAdmin-AutoRepliesAndSignatures

    return $Self;
}

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

    my $ParamObject = $Kernel::OM->Get('Kernel::System::Web::Request');
    my $Output      = '';
    $Param{ID}     = $ParamObject->GetParam( Param => 'ID' ) || '';
    $Param{Action} = $ParamObject->GetParam( Param => 'Action' )
        || 'AdminQueueAutoResponse';
    $Param{Filter} = $ParamObject->GetParam( Param => 'Filter' ) || '';

    my $LayoutObject       = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
    my $QueueObject        = $Kernel::OM->Get('Kernel::System::Queue');
    my $AutoResponseObject = $Kernel::OM->Get('Kernel::System::AutoResponse');

    if ( $Self->{Subaction} eq 'Change' ) {
        $Output .= $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();

        # get Type Auto Responses data
        my %TypeResponsesData = $AutoResponseObject->AutoResponseTypeList();

        # get queue data
        my %QueueData = $QueueObject->QueueGet(
            ID => $Param{ID},
        );
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
        if ( $Self->{LightAdmin} ) {
            $QueueData{Permission} = $QueueObject->QueueListPermission(
                QueueIDs => [ $Param{ID} ],
                UserID   => $Self->{UserID},
            );

            # No permission for the queue.
            if ( !$QueueData{Permission} ) {
                %QueueData = ();
            }
            elsif ( $QueueData{Permission} eq 'ro' ) {
                $Output .= $LayoutObject->Notify(
                    Priority => 'Notice',
                    Data     => $LayoutObject->{LanguageObject}->Translate('No permission to edit auto responses for this queue.'),
                );
            }
        }
# EO LightAdmin-AutoRepliesAndSignatures

        $LayoutObject->Block(
            Name => 'Overview',
            Data => {
                Subaction => $Self->{Subaction},
                QueueName => $QueueData{Name},
            },
        );
        $LayoutObject->Block( Name => 'ActionList' );
        $LayoutObject->Block( Name => 'ActionOverview' );

        $LayoutObject->Block(
            Name => 'Selection',
            Data => {
                Queue => $QueueData{Name},
                %QueueData,
                %Param,
                ActionHome => 'AdminQueue',
            },
        );
        for my $TypeID ( sort keys %TypeResponsesData ) {

# Rother OSS / LightAdmin-AutoRepliesAndSignatures
#            # get all valid Auto Responses data for appropriate Auto Responses type
#            my %AutoResponseListByType = $AutoResponseObject->AutoResponseList(
#                TypeID => $TypeID,
#            );
#
#            # get selected Auto Responses for appropriate Auto Responses type and Queue
#            my %AutoResponseData = $AutoResponseObject->AutoResponseGetByTypeQueueID(
#                QueueID => $Param{ID},
#                Type    => $TypeResponsesData{$TypeID},
#            );
#
#            $Param{DataStrg} = $LayoutObject->BuildSelection(
#                Name         => "IDs_$TypeID",
#                SelectedID   => $AutoResponseData{AutoResponseID} || '',
#                Data         => \%AutoResponseListByType,
#                Size         => 1,
#                PossibleNone => 1,
#                Class        => 'Modernize W50pc',
#            );
            if (%QueueData) {

                # get all valid Auto Responses data for appropriate Auto Responses type
                my %AutoResponseListByType = $AutoResponseObject->AutoResponseList(
                    TypeID => $TypeID,
                );

                if ( $Self->{LightAdmin} ) {
                    for my $AutoResponseID ( sort keys %AutoResponseListByType ) {
                        my %Queues     = $QueueObject->QueueAutoResponseMemberList( AutoResponseID => $AutoResponseID );
                        my $Permission = $QueueObject->QueueListPermission(
                            QueueIDs => [ keys %Queues ],
                            UserID   => $Self->{UserID},
                            Default  => 'rw',
                        );
                        if ( $Permission ne 'rw' ) {
                            delete $AutoResponseListByType{$AutoResponseID};
                        }
                    }
                }


                # get selected Auto Responses for appropriate Auto Responses type and Queue
                my %AutoResponseData = $AutoResponseObject->AutoResponseGetByTypeQueueID(
                    QueueID => $Param{ID},
                    Type    => $TypeResponsesData{$TypeID},
                );

                $Param{DataStrg} = $LayoutObject->BuildSelection(
                    Name         => "IDs_$TypeID",
                    SelectedID   => $AutoResponseData{AutoResponseID} || '',
                    Data         => \%AutoResponseListByType,
                    Size         => 1,
                    PossibleNone => 1,
                    Class        => 'Modernize W50pc',
                );
            }
# EO LightAdmin-AutoRepliesAndSignatures
            $LayoutObject->Block(
                Name => 'ChangeItemList',
                Data => {
                    Type   => $TypeResponsesData{$TypeID},
                    TypeID => $TypeID,
                    %Param,
                },
            );
        }
        $Output .= $LayoutObject->Output(
            TemplateFile => 'AdminQueueAutoResponse',
            Data         => \%Param,
        );
        $Output .= $LayoutObject->Footer();
    }

    # queues to queue_auto_responses
    elsif ( $Self->{Subaction} eq 'ChangeAction' ) {

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

        my @NewIDs = ();

        # get Type Auto Responses data
        my %TypeResponsesData = $AutoResponseObject->AutoResponseTypeList();

# Rother OSS / LightAdmin-AutoRepliesAndSignatures
        if ( $Self->{LightAdmin} ) {

            # check if user has rw permissions on the QueueID
            my $Permission = $QueueObject->QueueListPermission(
                QueueIDs => [ $Param{ID} ],
                UserID   => $Self->{UserID},
            );

            # no permission to change.
            if ( $Permission ne 'rw' ) {
                return $LayoutObject->Redirect(
                    OP => "Action=$Self->{Action};Subaction=Change;ID=$Param{ID}"
                );
            }

            # check if user has permissions on every AutoResponseID
            CHECK_AUTO_RESPONSE_ID:
            for my $TypeID ( sort keys %TypeResponsesData ) {
                my $ParamAutoResponseID = $ParamObject->GetParam( Param => "IDs_$TypeID" );

                next CHECK_AUTO_RESPONSE_ID if !$ParamAutoResponseID;
                my %AutoResponseListByType = $AutoResponseObject->AutoResponseList( TypeID => $TypeID );

                for my $AutoResponseID ( keys %AutoResponseListByType ) {
                    my %Queues     = $QueueObject->QueueAutoResponseMemberList( AutoResponseID => $AutoResponseID );
                    my $Permission = $QueueObject->QueueListPermission(
                        QueueIDs => [ keys %Queues ],
                        UserID   => $Self->{UserID},
                        Default  => 'rw',
                    );
                    if ( $Permission ne 'rw' ) {
                        delete $AutoResponseListByType{$AutoResponseID};
                    }
                }

                # no permission to change.
                if ( !$AutoResponseListByType{ $ParamAutoResponseID } ) {
                    return $LayoutObject->Redirect(
                        OP => "Action=$Self->{Action};Subaction=Change;ID=$Param{ID}"
                    );
                }
            }
        }
# EO LightAdmin-AutoRepliesAndSignatures

        # set Auto Responses IDs for this queue.
        for my $TypeID ( sort keys %TypeResponsesData ) {
            push( @NewIDs, $ParamObject->GetParam( Param => "IDs_$TypeID" ) );
        }

        $AutoResponseObject->AutoResponseQueue(
            QueueID         => $Param{ID},
            AutoResponseIDs => \@NewIDs,
            UserID          => $Self->{UserID},
        );

        # if the user would like to continue editing the queue - auto response relation, just redirect to the edit screen
        # otherwise return to overview
        if (
            defined $ParamObject->GetParam( Param => 'ContinueAfterSave' )
            && ( $ParamObject->GetParam( Param => 'ContinueAfterSave' ) eq '1' )
            )
        {
            return $LayoutObject->Redirect( OP => "Action=$Self->{Action};Subaction=Change;ID=$Param{ID}" );
        }
        else {
            return $LayoutObject->Redirect( OP => "Action=$Self->{Action}" );
        }
    }

    # else ! print form
    else {
        $Output .= $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();

        # get queue data
        my %QueueData;
        my $QueueHeader;

        # filter queues without auto responses
        if ( $Param{Filter} eq 'QueuesWithoutAutoResponses' ) {

            %QueueData = $AutoResponseObject->AutoResponseWithoutQueue();

            # use appropriate header
            $QueueHeader = Translatable('Queues ( without auto responses )');

        }
        else {
            %QueueData   = $QueueObject->QueueList( Valid => 1 );
            $QueueHeader = Translatable('Queues');
        }

        $LayoutObject->Block(
            Name => 'Overview',
            Data => { %QueueData, %Param, }
        );

        $LayoutObject->Block( Name => 'FilterQueues' );
        $LayoutObject->Block( Name => 'FilterAutoResponses' );
        $LayoutObject->Block( Name => 'ActionList' );

        if ( $Param{Filter} eq 'QueuesWithoutAutoResponses' ) {
            $LayoutObject->Block( Name => 'ShowAllQueues' );
        }
        else {
            $LayoutObject->Block( Name => 'QueuesWithoutAutoResponses' );
        }

        $LayoutObject->Block(
            Name => 'OverviewResult',
            Data => {
                QueueHeader => $QueueHeader,
            },
        );
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
        if ( $Self->{LightAdmin} ) {

            # Filter out queues without permission.
            my %RwQueues = $QueueObject->GetAllQueues(
                UserID => $Self->{UserID},
                Type   => 'rw',
            );

            for my $QueueID ( keys %QueueData ) {
                delete $QueueData{$QueueID} if !$RwQueues{$QueueID};
            }
        }
# EO LightAdmin-AutoRepliesAndSignatures

        # if there are any queues, they are shown
        if (%QueueData) {
            for ( sort { $QueueData{$a} cmp $QueueData{$b} } keys %QueueData ) {
                $LayoutObject->Block(
                    Name => 'Item',
                    Data => {
                        Queue   => $QueueData{$_},
                        QueueID => $_,
                        %QueueData,
                        %Param,
                    },
                );
            }
        }

        # otherwise a no data found message is displayed
        else {
            $LayoutObject->Block(
                Name => 'NoQueuesFoundMsg',
                Data => {},
            );
        }

        # get valid Auto Response IDs
        my %AutoResponseList = $AutoResponseObject->AutoResponseList();
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
        if ( $Self->{LightAdmin} ) {
            for my $AutoResponseID ( sort keys %AutoResponseList ) {
                my %Queues     = $QueueObject->QueueAutoResponseMemberList( AutoResponseID => $AutoResponseID );
                my $Permission = $QueueObject->QueueListPermission(
                    QueueIDs => [ keys %Queues ],
                    UserID   => $Self->{UserID},
                    Default  => 'rw',
                );
                if ( $Permission ne 'rw' ) {
                    delete $AutoResponseList{$AutoResponseID};
                }
            }
        }
# EO LightAdmin-AutoRepliesAndSignatures

        # if there are any auto responses, they are shown
        if ( keys %AutoResponseList ) {
            for my $AutoResponseID ( sort keys %AutoResponseList ) {

                my %Data = $AutoResponseObject->AutoResponseGet(
                    ID => $AutoResponseID,
                );

                my %ResponseDataItem = (
                    ID   => $Data{ID},
                    Type => $Data{Type},
                    Name => $Data{Name},
                );

                $LayoutObject->Block(
                    Name => 'ItemList',
                    Data => \%ResponseDataItem,
                );
            }
        }

        # otherwise a no data found message is displayed
        else {
            $LayoutObject->Block(
                Name => 'NoAutoResponsesFoundMsg',
                Data => {},
            );
        }

        $Output .= $LayoutObject->Output(
            TemplateFile => 'AdminQueueAutoResponse',
            Data         => \%Param,
        );
        $Output .= $LayoutObject->Footer();
    }
    return $Output;
}

1;
 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - 6efdc7bf2a3325277cd79a60f0f2407f8ad59e87 - Kernel/Modules/AdminSignature.pm
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

package Kernel::Modules::AdminSignature;

use strict;
use warnings;

use Kernel::Language qw(Translatable);

our $ObjectManagerDisabled = 1;

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

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

    # set pref for columns key
    $Self->{PrefKeyIncludeInvalid} = 'IncludeInvalid' . '-' . $Self->{Action};

    my %Preferences = $Kernel::OM->Get('Kernel::System::User')->GetPreferences(
        UserID => $Self->{UserID},
    );

    $Self->{IncludeInvalid} = $Preferences{ $Self->{PrefKeyIncludeInvalid} };

# Rother OSS / LightAdmin-AutoRepliesAndSignatures
    if ( !$Param{AccessRw} && $Param{AccessRo} ) {
        $Self->{LightAdmin} = 1;
    }
# EO LightAdmin-AutoRepliesAndSignatures

    return $Self;
}

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

    my $ParamObject     = $Kernel::OM->Get('Kernel::System::Web::Request');
    my $LayoutObject    = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
    my $SignatureObject = $Kernel::OM->Get('Kernel::System::Signature');

# Rother OSS / LightAdmin-AutoRepliesAndSignatures
    my $QueueObject     = $Kernel::OM->Get('Kernel::System::Queue');
# EO LightAdmin-AutoRepliesAndSignatures
    my $Notification = $ParamObject->GetParam( Param => 'Notification' ) || '';

    $Param{IncludeInvalid} = $ParamObject->GetParam( Param => 'IncludeInvalid' );

    if ( defined $Param{IncludeInvalid} ) {
        $Kernel::OM->Get('Kernel::System::User')->SetPreferences(
            UserID => $Self->{UserID},
            Key    => $Self->{PrefKeyIncludeInvalid},
            Value  => $Param{IncludeInvalid},
        );

        $Self->{IncludeInvalid} = $Param{IncludeInvalid};
    }

    # ------------------------------------------------------------ #
    # change
    # ------------------------------------------------------------ #
    if ( $Self->{Subaction} eq 'Change' ) {
        my $ID   = $ParamObject->GetParam( Param => 'ID' ) || '';
        my %Data = $SignatureObject->SignatureGet(
            ID => $ID,
        );
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
        if ( $Self->{LightAdmin} ) {
            my %Queues = $QueueObject->QueueSignatureMemberList(
                SignatureID => $ID
            );
            $Data{Permission} = $QueueObject->QueueListPermission(
                QueueIDs => [ keys %Queues ],
                UserID   => $Self->{UserID},
                Default  => 'rw',
            );

            # No permission for the template.
            if ( !$Data{Permission} ) {
                %Data = ();
            }
            elsif ( $Data{Permission} eq 'ro' ) {
                $Output .= $LayoutObject->Notify(
                    Priority => 'Notice',
                    Data     => $LayoutObject->{LanguageObject}->Translate('No permission to edit this signature.'),
                );
            }
        }
# EO LightAdmin-AutoRepliesAndSignatures
        $Output .= $LayoutObject->Notify( Info => Translatable('Signature updated!') )
            if ( $Notification && $Notification eq 'Update' );

        $Self->_Edit(
            Action => 'Change',
            %Data,
        );
        $Output .= $LayoutObject->Output(
            TemplateFile => 'AdminSignature',
            Data         => \%Param,
        );
        $Output .= $LayoutObject->Footer();
        return $Output;
    }

    # ------------------------------------------------------------ #
    # change action
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'ChangeAction' ) {

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

        my ( %GetParam, %Errors );
        for my $Parameter (qw(ID Name Text Comment ValidID)) {
            $GetParam{$Parameter} = $ParamObject->GetParam( Param => $Parameter ) || '';
        }
        $GetParam{'Text'} = $ParamObject->GetParam(
            Param => 'Text',
            Raw   => 1
        ) || '';

        # get content type
        my $ContentType = 'text/plain';
        if ( $LayoutObject->{BrowserRichText} ) {
            $ContentType = 'text/html';
        }

        # check needed data
        for my $Needed (qw(Name ValidID Text)) {
            if ( !$GetParam{$Needed} ) {
                $Errors{ $Needed . 'Invalid' } = 'ServerError';
            }
        }
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
        if ( $Self->{LightAdmin} ) {

            my %Queues = $QueueObject->QueueSignatureMemberList(
                SignatureID => $GetParam{ID}
            );
            my $Permission = $QueueObject->QueueListPermission(
                QueueIDs => [ keys %Queues ],
                UserID   => $Self->{UserID},
                Default  => 'rw',
            );

            # No permission to change the template.
            if ( $Permission ne 'rw' ) {
                $Errors{NoPermission} = 1;
            }
        }
# EO LightAdmin-AutoRepliesAndSignatures

        # if no errors occurred
        if ( !%Errors ) {

            # update signature
            my $Update = $SignatureObject->SignatureUpdate(
                %GetParam,
                ContentType => $ContentType,
                UserID      => $Self->{UserID},
            );
            if ($Update) {

                # if the user would like to continue editing the signature, just redirect to the edit screen
                if (
                    defined $ParamObject->GetParam( Param => 'ContinueAfterSave' )
                    && ( $ParamObject->GetParam( Param => 'ContinueAfterSave' ) eq '1' )
                    )
                {
                    my $ID = $ParamObject->GetParam( Param => 'ID' ) || '';
                    return $LayoutObject->Redirect(
                        OP => "Action=$Self->{Action};Subaction=Change;ID=$ID;Notification=Update"
                    );
                }
                else {

                    # otherwise return to overview
                    return $LayoutObject->Redirect( OP => "Action=$Self->{Action};Notification=Update" );
                }
            }
        }

        # something has gone wrong
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
#        $Output .= $LayoutObject->Notify( Priority => 'Error' );
        my $ErrorInfo = $Errors{NoPermission} ?
                        'No permission to update this signature.' :
                        'There were errors, could not update this signature.';
        $Output .= $LayoutObject->Notify(
            Info => $ErrorInfo,
            Priority => 'Error'
        );
# EO LightAdmin-AutoRepliesAndSignatures
        $Self->_Edit(
            Action => 'Change',
            Errors => \%Errors,
            %GetParam,
        );
        $Output .= $LayoutObject->Output(
            TemplateFile => 'AdminSignature',
            Data         => \%Param,
        );
        $Output .= $LayoutObject->Footer();
        return $Output;
    }

    # ------------------------------------------------------------ #
    # add
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'Add' ) {
        my %GetParam = ();
        $GetParam{Name} = $ParamObject->GetParam( Param => 'Name' );
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();
        $Self->_Edit(
            Action => 'Add',
            %GetParam,
        );
        $Output .= $LayoutObject->Output(
            TemplateFile => 'AdminSignature',
            Data         => \%Param,
        );
        $Output .= $LayoutObject->Footer();
        return $Output;
    }

    # ------------------------------------------------------------ #
    # add action
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'AddAction' ) {

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

        my ( %GetParam, %Errors );
        for my $Parameter (qw(ID Name Comment ValidID)) {
            $GetParam{$Parameter} = $ParamObject->GetParam( Param => $Parameter ) || '';
        }
        $GetParam{'Text'} = $ParamObject->GetParam(
            Param => 'Text',
            Raw   => 1
        ) || '';

        # get content type
        my $ContentType = 'text/plain';
        if ( $LayoutObject->{BrowserRichText} ) {
            $ContentType = 'text/html';
        }

        # check needed data
        for my $Needed (qw(Name ValidID Text)) {
            if ( !$GetParam{$Needed} ) {
                $Errors{ $Needed . 'Invalid' } = 'ServerError';
            }
        }

        # if no errors occurred
        if ( !%Errors ) {

            # add signature
            my $NewSignature = $SignatureObject->SignatureAdd(
                %GetParam,
                ContentType => $ContentType,
                UserID      => $Self->{UserID},
            );

            if ($NewSignature) {
                $Self->_Overview();
                my $Output = $LayoutObject->Header();
                $Output .= $LayoutObject->NavigationBar();
                $Output .= $LayoutObject->Notify( Info => Translatable('Signature added!') );
                $Output .= $LayoutObject->Output(
                    TemplateFile => 'AdminSignature',
                    Data         => \%Param,
                );
                $Output .= $LayoutObject->Footer();
                return $Output;
            }
        }

        # something has gone wrong
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();
        $Output .= $LayoutObject->Notify( Priority => 'Error' );
        $Self->_Edit(
            Action => 'Add',
            Errors => \%Errors,
            %GetParam,
        );
        $Output .= $LayoutObject->Output(
            TemplateFile => 'AdminSignature',
            Data         => \%Param,
        );
        $Output .= $LayoutObject->Footer();
        return $Output;
    }

    # ------------------------------------------------------------
    # overview
    # ------------------------------------------------------------
    else {
        $Self->_Overview();
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();
        $Output .= $LayoutObject->Notify( Info => Translatable('Signature updated!') )
            if ( $Notification && $Notification eq 'Update' );

        $Output .= $LayoutObject->Output(
            TemplateFile => 'AdminSignature',
            Data         => \%Param,
        );
        $Output .= $LayoutObject->Footer();
        return $Output;
    }

}

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

    my $LayoutObject    = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
    my $HTMLUtilsObject = $Kernel::OM->Get('Kernel::System::HTMLUtils');

    # add rich text editor
    if ( $LayoutObject->{BrowserRichText} ) {

        # set up rich text editor
        $LayoutObject->SetRichTextParameters(
            Data => \%Param,
        );

        # reformat from plain to html
        if ( $Param{ContentType} && $Param{ContentType} =~ /text\/plain/i ) {
            $Param{Text} = $HTMLUtilsObject->ToHTML(
                String => $Param{Text},
            );
        }
    }
    else {

        # reformat from html to plain
        if ( $Param{ContentType} && $Param{ContentType} =~ /text\/html/i ) {
            $Param{Text} = $HTMLUtilsObject->ToAscii(
                String => $Param{Text},
            );
        }
    }

    $LayoutObject->Block(
        Name => 'Overview',
        Data => \%Param,
    );

    $LayoutObject->Block(
        Name => 'ActionList',
    );

    $LayoutObject->Block(
        Name => 'ActionOverview',
    );

    # get valid list
    my %ValidList        = $Kernel::OM->Get('Kernel::System::Valid')->ValidList();
    my %ValidListReverse = reverse %ValidList;

    $Param{ValidOption} = $LayoutObject->BuildSelection(
        Data       => \%ValidList,
        Name       => 'ValidID',
        SelectedID => $Param{ValidID} || $ValidListReverse{valid},
        Class      => 'Modernize Validate_Required ' . ( $Param{Errors}->{'ValidIDInvalid'} || '' ),
    );
    $LayoutObject->Block(
        Name => 'OverviewUpdate',
        Data => {
            %Param,
            %{ $Param{Errors} },
        },
    );

    # shows header
    if ( $Param{Action} eq 'Change' ) {
        $LayoutObject->Block( Name => 'HeaderEdit' );
    }
    else {
        $LayoutObject->Block( Name => 'HeaderAdd' );
    }

    return 1;
}

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

    my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
    my $QueueObject  = $Kernel::OM->Get('Kernel::System::Queue');
# EO LightAdmin-AutoRepliesAndSignatures

    $LayoutObject->Block(
        Name => 'Overview',
        Data => \%Param,
    );

    $LayoutObject->Block(
        Name => 'ActionList',
    );

    $LayoutObject->Block(
        Name => 'ActionAdd',
    );

    $LayoutObject->Block(
        Name => 'OverviewResult',
        Data => \%Param,
    );

    $LayoutObject->Block(
        Name => 'IncludeInvalid',
        Data => {
            IncludeInvalid        => $Self->{IncludeInvalid},
            IncludeInvalidChecked => $Self->{IncludeInvalid} ? 'checked' : '',
        },
    );

    $LayoutObject->Block(
        Name => 'Filter',
    );

    my $SignatureObject = $Kernel::OM->Get('Kernel::System::Signature');
    my %List            = $SignatureObject->SignatureList(
        Valid => $Self->{IncludeInvalid} ? 0 : 1,
    );
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
    if ( $Self->{LightAdmin} ) {

        # check queue permissions of linked signatures.
        for my $ListKey ( keys %List ) {
            my %Data = $SignatureObject->SignatureGet( ID => $ListKey );
            my %Queues = $QueueObject->QueueSignatureMemberList(
                SignatureID => $Data{ID}
            );
            $Data{Permission} = $QueueObject->QueueListPermission(
                QueueIDs => [ keys %Queues ],
                UserID   => $Self->{UserID},
                Default  => 'rw',
            );
            if (!$Data{Permission}) {
                delete $List{$ListKey}
            }
        }
    }
# EO LightAdmin-AutoRepliesAndSignatures

    # if there are any results, they are shown
    if (%List) {

        # get valid list
        my %ValidList = $Kernel::OM->Get('Kernel::System::Valid')->ValidList();
        for my $ListKey ( sort { $List{$a} cmp $List{$b} } keys %List ) {

            my %Data = $SignatureObject->SignatureGet( ID => $ListKey );
            $LayoutObject->Block(
                Name => 'OverviewResultRow',
                Data => {
                    Valid => $ValidList{ $Data{ValidID} },
                    %Data,
                },
            );
        }
    }

    # otherwise a no data message is displayed
    else {
        $LayoutObject->Block(
            Name => 'NoDataFoundMsg',
            Data => {},
        );
    }
    return 1;
}

1;
 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - 6efdc7bf2a3325277cd79a60f0f2407f8ad59e87 - Kernel/Output/HTML/Templates/Standard/AdminAutoResponse.tt
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

[% RenderBlockStart("Overview") %]
<div class="MainBox ARIARoleMain LayoutFixedSidebar SidebarFirst">
    <h1 class="InvisibleText">[% Translate("Auto Response Management") | html %]</h1>

    [% BreadcrumbPath = [
            {
                Name => Translate('Auto Response Management'),
                Link => Env("Action"),
            },
        ]
    %]

    [% SWITCH Data.Action %]
        [% CASE 'Add' %]
            [% BreadcrumbPath.push({ Name => Translate("Add Auto Response"),}) %]
        [% CASE 'Change' %]
            [% USE EditTitle = String(Translate("Edit Auto Response")) %]
            [% BreadcrumbPath.push({ Name => EditTitle.append( ': ', Data.Name ) }) %]
    [% END %]

    [% INCLUDE "Breadcrumb.tt" Path = BreadcrumbPath %]

    <div class="SidebarColumn">
[% RenderBlockStart("IncludeInvalid") %]
        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("Filter by valid state") | html %]</h2>
            </div>
            <div class="Content">
                <input type="checkbox" id="IncludeInvalid" name="IncludeInvalid" value="1" title="[% Translate("Include invalid auto responses") | html %]" [% Data.IncludeInvalidChecked | html %]/>
                <label for="IncludeInvalid">[% Translate("Include invalid auto responses") | html %]</label>
            </div>
        </div>
[% RenderBlockEnd("IncludeInvalid") %]
[% RenderBlockStart("ActionList") %]
        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("Actions") | html %]</h2>
            </div>
            <div class="Content">
                <ul class="ActionList">
[% RenderBlockStart("ActionOverview") %]
                    <li>
                        <a href="[% Env("Baselink") %]Action=[% Env("Action") %]" class="CallForAction Fullsize Center"><span><i class="fa fa-caret-left"></i>[% Translate("Go to overview") | html %]</span></a>
                    </li>
[% RenderBlockEnd("ActionOverview") %]
[% RenderBlockStart("ActionAdd") %]
                    <li>
                        <a href="[% Env("Baselink") %]Action=[% Env("Action") %];Subaction=Add" class="CallForAction Fullsize Center"><span><i class="fa fa-plus-square"></i>[% Translate("Add Auto Response") | html %]</span></a>
                    </li>
[% RenderBlockEnd("ActionAdd") %]
                </ul>
            </div>
        </div>
[% RenderBlockEnd("ActionList") %]

[% RenderBlockStart("Filter") %]
        <div class="WidgetSimple">
            <div class="Header">
                <h2><label for="FilterAutoResponses">[% Translate("Filter for Auto Responses") | html %]</label></h2>
            </div>
            <div class="Content">
                <input type="text" id="FilterAutoResponses" class="FilterBox" placeholder="[% Translate("Just start typing to filter...") | html %]" name="FilterAutoResponses" value="" title="[% Translate("Filter for auto responses") | html %]">
            </div>
        </div>
[% RenderBlockEnd("Filter") %]
    </div>


    <div class="ContentColumn">
[% RenderBlockStart("OverviewResult") %]
        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("List") | html %]</h2>
            </div>
            <div class="Content">
                <table class="DataTable" id="AutoResponses">
                    <thead>

                        <tr>
                            <th class="W33pc">[% Translate("Name") | html %]</th>
                            <th>[% Translate("Type") | html %]</th>
                            <th>[% Translate("Comment") | html %]</th>
                            <th>[% Translate("Validity") | html %]</th>
                            <th>[% Translate("Changed") | html %]</th>
                            <th>[% Translate("Created") | html %]</th>
                        </tr>
                    </thead>
                    <tbody>
[% RenderBlockStart("NoDataFoundMsg") %]
                        <tr>
                            <td colspan="6">
                                [% Translate("No data found.") | html %]
                            </td>
                        </tr>
[% RenderBlockEnd("NoDataFoundMsg") %]
[% RenderBlockStart("OverviewResultRow") %]
                        <tr [% IF Data.ValidID != 1 %]class="Invalid"[% END %]>
                            <td><a class="AsBlock" href="[% Env("Baselink") %]Action=[% Env("Action") %];Subaction=Change;ID=[% Data.ID | uri %]">[% Translate(Data.Name) | html %]</a></td>
                            <td>[% Translate(Data.Type) | html %]</td>
                            <td title="[% Data.Comment | html %]">[% Data.Comment | truncate(20) | html %]</td>
                            <td>[% Translate(Data.Valid) | html %]</td>
                            <td>[% Data.ChangeTime | Localize("TimeShort") %]</td>
                            <td>[% Data.CreateTime | Localize("TimeShort") %]</td>
                        </tr>
[% RenderBlockEnd("OverviewResultRow") %]
                        <tr class="FilterMessage Hidden">
                            <td colspan="6">[% Translate("No matches found.") | html %]</td>
                        </tr>
                    </tbody>
                </table>
            </div>
        </div>
[% RenderBlockEnd("OverviewResult") %]
[% RenderBlockStart("OverviewUpdate") %]

        <div class="WidgetSimple">
            <div class="Header">

            [% IF Data.Action == 'Add' %]
                <h2>[% Translate("Add Auto Response") | html %]</h2>
            [% ELSE %]
                <h2>[% Translate("Edit Auto Response") | html %]</h2>
            [% END %]

            </div>
            <div class="Content">
                <form action="[% Env("CGIHandle") %]" method="post" class="Validate PreventMultipleSubmits">
                    <input type="hidden" name="Action" value="[% Env("Action") %]"/>
                    <input type="hidden" name="Subaction" value="[% Data.Action | uri %]Action"/>
                    <input type="hidden" name="ID" value="[% Data.ID | html %]"/>
                    [% IF Data.Action == 'Change' %]
                        <input type="hidden" name="ContinueAfterSave" id="ContinueAfterSave" value=""/>
                    [% END %]
                    <fieldset class="TableLike">

                        <label class="Mandatory" for="Name"><span class="Marker">*</span> [% Translate("Name") | html %]:</label>
                        <div class="Field">
                            <input type="text" name="Name" id="Name" value="[% Data.Name | html %]" class="W50pc Validate_Required [% Data.NameInvalid | html %]" maxlength="200"/>
                            <div id="NameError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                            <div id="NameServerError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                        </div>
                        <div class="Clear"></div>

                        <label class="Mandatory" for="Subject"><span class="Marker">*</span> [% Translate("Subject") | html %]:</label>
                        <div class="Field">
                            <input type="text" name="Subject" id="Subject" value="[% Data.Subject | html %]" class="W50pc Validate_Required [% Data.SubjectInvalid | html %]" maxlength="250"/>
                            <div id="SubjectError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                            <div id="SubjectServerError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                        </div>
                        <div class="Clear"></div>

                        <label for="RichText">[% Translate("Response") | html %]:</label>
                        <div class="RichTextField">
                            <textarea id="RichText" class="RichText" rows="10" cols="60" name="Response">[% Data.Response | html %]</textarea>
                        </div>
                        <div class="Clear"></div>

                        <label class="Mandatory" for="TypeID"><span class="Marker">*</span> [% Translate("Type") | html %]:</label>
                        <div class="Field">
                            [% Data.TypeOption %]
                            <div id="TypeIDError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                            <div id="TypeIDServerError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                        </div>
                        <div class="Clear"></div>

                        <label class="Mandatory" for="AddressID"><span class="Marker">*</span> [% Translate("Auto response from") | html %]:</label>
                        <div class="Field">
                            [% Data.SystemAddressOption %]
                            <div id="AddressIDError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                            <div id="AddressIDServerError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                        </div>
                        <div class="Clear"></div>

                        <label class="Mandatory" for="ValidID"><span class="Marker">*</span> [% Translate("Validity") | html %]:</label>
                        <div class="Field">
                            [% Data.ValidOption %]
                            <div id="ValidIDError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                            <div id="ValidIDServerError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                        </div>
                        <div class="Clear"></div>

                        <label for="Comment">[% Translate("Comment") | html %]:</label>
                        <div class="Field">
                            <input type="text" name="Comment" id="Comment" value="[% Data.Comment | html %]" class="W50pc" maxlength="250"/>
                        </div>
                        <div class="Clear"></div>
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
                    [% IF Data.Permission != 'ro' %]
# EO LightAdmin-AutoRepliesAndSignatures
                        <div class="Field">
                            [% IF Data.Action == 'Change' %]
                                <button class="CallForAction Primary" id="SubmitAndContinue" type="button" value="[% Translate("Save") | html %]"><span>[% Translate("Save") | html %]</span></button>
                                [% Translate("or") | html %]
                                <button class="CallForAction Primary" id="Submit" type="submit" value="[% Translate("Save") | html %]"><span>[% Translate("Save and finish") | html %]</span></button>
                            [% ELSE %]
                                <button class="CallForAction Primary" id="Submit" type="submit" value="[% Translate("Save") | html %]"><span>[% Translate("Save") | html %]</span></button>
                            [% END %]
                            [% Translate("or") | html %]
                            <a href="[% Env("Baselink") %]Action=[% Env("Action") %]">[% Translate("Cancel") | html %]</a>
                        </div>
                        <div class="Clear"></div>
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
                    [% END %]
# EO LightAdmin-AutoRepliesAndSignatures
                    </fieldset>
                </form>
            </div>
        </div>

        <div class="WidgetSimple SpacingTop">
            <div class="Header">
                <h2>[% Translate("Reference") | html %]</h2>
            </div>
            <div class="Content">

                <p>[% Translate("You can use the following tags") | html %]:</p>
                <dl>

                    <dt><code>&lt;OTOBO_CUSTOMER_SUBJECT[20]&gt;</code></dt>
                    <dd>
                        [% Translate("To get the first 20 character of the subject.") | html %]
                    </dd>

                    <dt><code>&lt;OTOBO_CUSTOMER_EMAIL[5]&gt;</code></dt>
                    <dd>
                        [% Translate("To get the first 5 lines of the email.") | html %]
                    </dd>

                    <dt><code>&lt;OTOBO_CUSTOMER_REALNAME&gt;</code></dt>
                    <dd>
                        [% Translate("To get the name of the ticket's customer user (if given).") | html %]
                    </dd>

                    <dt><code>&lt;OTOBO_CUSTOMER_*&gt;</code></dt>
                    <dd>
                        [% Translate("To get the article attribute") | html %]
                        ([% Translate(" e. g.") | html %] <code>&lt;OTOBO_CUSTOMER_From&gt;, &lt;OTOBO_CUSTOMER_To&gt;,
                        &lt;OTOBO_CUSTOMER_Cc&gt;, &lt;OTOBO_CUSTOMER_Subject&gt;, &lt;OTOBO_CUSTOMER_Body&gt;</code>).
                    </dd>

                    <dt><code>&lt;OTOBO_CUSTOMER_DATA_*&gt;</code></dt>
                    <dd>
                        [% Translate("Options of the current customer user data") | html %]
                        ([% Translate(" e. g.") | html %] <code>&lt;OTOBO_CUSTOMER_DATA_UserFirstname&gt;</code>).
                    </dd>

                    <dt><code>&lt;OTOBO_OWNER_*&gt;</code></dt>
                    <dd>
                        [% Translate("Ticket owner options") | html %]
                        ([% Translate(" e. g.") | html %] <code>&lt;OTOBO_OWNER_UserFirstname&gt;</code>).
                    </dd>

                    <dt><code>&lt;OTOBO_RESPONSIBLE_*&gt;</code></dt>
                    <dd>
                        [% Translate("Ticket responsible options") | html %]
                        ([% Translate(" e. g.") | html %] <code>&lt;OTOBO_RESPONSIBLE_UserFirstname&gt;</code>).
                    </dd>

                    <dt><code>&lt;OTOBO_CURRENT_*&gt;</code></dt>
                    <dd>
                        [% Translate("Options of the current user who requested this action") | html %]
                        ([% Translate(" e. g.") | html %] <code>&lt;OTOBO_CURRENT_UserFirstname&gt;</code>).
                    </dd>

                    <dt><code>&lt;OTOBO_TICKET_*&gt;</code></dt>
                    <dd>
                        [% Translate("Options of the ticket data") | html %]
                        ([% Translate(" e. g.") | html %] <code>&lt;OTOBO_TICKET_TicketNumber&gt;, &lt;OTOBO_TICKET_TicketID&gt;,
                        &lt;OTOBO_TICKET_Queue&gt;, &lt;OTOBO_TICKET_State&gt;</code>).
                    </dd>

                    <dt><code>&lt;OTOBO_TICKET_DynamicField_*&gt;</code></dt>
                    <dd>
                        [% Translate("Options of ticket dynamic fields internal key values") | html %]
                        ([% Translate(" e. g.") | html %] <code>&lt;OTOBO_TICKET_DynamicField_TestField&gt;,
                        &lt;OTOBO_TICKET_DynamicField_TicketFreeText1&gt;</code>).
                    </dd>

                    <dt><code>&lt;OTOBO_TICKET_DynamicField_*_Value&gt;</code></dt>
                    <dd>
                        [% Translate("Options of ticket dynamic fields display values, useful for Dropdown and Multiselect fields") | html %]
                        ([% Translate(" e. g.") | html %] <code>&lt;OTOBO_TICKET_DynamicField_TestField_Value&gt;,
                        &lt;OTOBO_TICKET_DynamicField_TicketFreeText1_Value&gt;</code>).
                    </dd>

                    <dt><code>&lt;OTOBO_CONFIG_*&gt;</code></dt>
                    <dd>
                        [% Translate("Config options") | html %]
                        ([% Translate(" e. g.") | html %] <code>&lt;OTOBO_CONFIG_HttpType&gt;</code>).
                    </dd>

                </dl>

                <div class="SpacingTop">
                    <label for="ResponseReference">
                        [% Translate("Example response") | html %]:
                    </label>
                </div>
                <textarea rows="5" cols="60" id="ResponseReference">
Thanks for your email.

You wrote:
&lt;snip&gt;
&lt;OTOBO_CUSTOMER_EMAIL[6]&gt;
&lt;/snip&gt;

--
Super Support Company Inc. - Waterford Business Park
5201 Blue Lagoon Drive - 8th Floor &amp; 9th Floor - Miami, 33126 USA
Email: hot@florida.com - Web: http://hot.florida.com/
                </textarea>
            </div>
        </div>
[% RenderBlockEnd("OverviewUpdate") %]

    </div>
    <div class="Clear"></div>
</div>
[% RenderBlockEnd("Overview") %]
 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - 6efdc7bf2a3325277cd79a60f0f2407f8ad59e87 - Kernel/Output/HTML/Templates/Standard/AdminSignature.tt
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

[% RenderBlockStart("Overview") %]
<div class="MainBox ARIARoleMain LayoutFixedSidebar SidebarFirst">
    <h1 class="InvisibleText">[% Translate("Signature Management") | html %]</h1>

    [% BreadcrumbPath = [
            {
                Name => Translate('Signature Management'),
                Link => Env("Action"),
            },
        ]
    %]

    [% SWITCH Data.Action %]
        [% CASE 'Add' %]
            [% BreadcrumbPath.push({ Name => Translate("Add Signature"),}) %]
        [% CASE 'Change' %]
            [% USE EditTitle = String(Translate("Edit Signature")) %]
            [% BreadcrumbPath.push({ Name => EditTitle.append( ': ', Data.Name ) }) %]
    [% END %]

    [% INCLUDE "Breadcrumb.tt" Path = BreadcrumbPath %]

    <div class="Clear"></div>
    <div class="SidebarColumn">
[% RenderBlockStart("IncludeInvalid") %]
        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("Filter by valid state") | html %]</h2>
            </div>
            <div class="Content">
                <input type="checkbox" id="IncludeInvalid" name="IncludeInvalid" value="1" title="[% Translate("Include invalid signatures") | html %]" [% Data.IncludeInvalidChecked | html %]/>
                <label for="IncludeInvalid">[% Translate("Include invalid signatures") | html %]</label>
            </div>
        </div>
[% RenderBlockEnd("IncludeInvalid") %]
[% RenderBlockStart("ActionList") %]
        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("Actions") | html %]</h2>
            </div>
            <div class="Content">
                <ul class="ActionList">
[% RenderBlockStart("ActionOverview") %]
                    <li>
                        <a href="[% Env("Baselink") %]Action=[% Env("Action") %]" class="CallForAction Fullsize Center"><span><i class="fa fa-caret-left"></i>[% Translate("Go to overview") | html %]</span></a>
                    </li>
[% RenderBlockEnd("ActionOverview") %]
[% RenderBlockStart("ActionAdd") %]
                    <li>
                        <a class="CallForAction Fullsize Center" href="[% Env("Baselink") %]Action=[% Env("Action") %];Subaction=Add">
                            <span><i class="fa fa-plus-square"></i>[% Translate("Add Signature") | html %]</span>
                        </a>
                    </li>
[% RenderBlockEnd("ActionAdd") %]
                </ul>
            </div>
        </div>
[% RenderBlockEnd("ActionList") %]
[% RenderBlockStart("Filter") %]
        <div class="WidgetSimple">
            <div class="Header">
                <h2><label for="FilterSignatures">[% Translate("Filter for Signatures") | html %]</label></h2>
            </div>
            <div class="Content">
                <input type="text" id="FilterSignatures" class="FilterBox" placeholder="[% Translate("Just start typing to filter...") | html %]" name="FilterSignatures" value="" title="[% Translate("Filter for signatures") | html %]">
            </div>
        </div>
[% RenderBlockEnd("Filter") %]
    </div>
    <div class="ContentColumn">
[% RenderBlockStart("OverviewResult") %]
        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("List") | html %]</h2>
            </div>
            <div class="Content">
                <table class="DataTable" id="Signatures">
                    <thead>
                        <tr>
                            <th>[% Translate("Name") | html %]</th>
                            <th>[% Translate("Comment") | html %]</th>
                            <th>[% Translate("Validity") | html %]</th>
                            <th>[% Translate("Changed") | html %]</th>
                            <th>[% Translate("Created") | html %]</th>
                        </tr>
                    </thead>
                    <tbody>
[% RenderBlockStart("NoDataFoundMsg") %]
                        <tr>
                            <td colspan="5">
                                [% Translate("No data found.") | html %]
                            </td>
                        </tr>
[% RenderBlockEnd("NoDataFoundMsg") %]
[% RenderBlockStart("OverviewResultRow") %]
                        <tr [% IF Data.ValidID != 1 %]class="Invalid"[% END %]>
                            <td>
                                <a class="AsBlock" href="[% Env("Baselink") %]Action=[% Env("Action") %];Subaction=Change;ID=[% Data.ID | uri %]">[% Data.Name | html %]</a>
                            </td>
                            <td title="[% Data.Comment | html %]">[% Data.Comment | truncate(20) | html %]</td>
                            <td>[% Translate(Data.Valid) | html %]</td>
                            <td>[% Data.ChangeTime | Localize("TimeShort") %]</td>
                            <td>[% Data.CreateTime | Localize("TimeShort") %]</td>
                        </tr>
[% RenderBlockEnd("OverviewResultRow") %]
                        <tr class="FilterMessage Hidden">
                            <td colspan="5">[% Translate("No matches found.") | html %]</td>
                        </tr>
                    </tbody>
                </table>
            </div>
        </div>
[% RenderBlockEnd("OverviewResult") %]
[% RenderBlockStart("OverviewUpdate") %]
        <div class="WidgetSimple">
            <div class="Header">
            [% IF Data.Action == 'Add' %]
                <h2>[% Translate("Add Signature") | html %]</h2>
            [% ELSE %]
                <h2>[% Translate("Edit Signature") | html %]</h2>
            [% END %]
            </div>
            <div class="Content">

                <form action="[% Env("CGIHandle") %]" method="post" class="Validate PreventMultipleSubmits">
                    <input type="hidden" name="Action" value="[% Env("Action") %]"/>
                    <input type="hidden" name="Subaction" value="[% Data.Action | uri %]Action"/>
                    <input type="hidden" name="ID" value="[% Data.ID | html %]"/>
                    [% IF Data.Action == 'Change' %]
                        <input type="hidden" name="ContinueAfterSave" id="ContinueAfterSave" value=""/>
                    [% END %]
                    <fieldset class="TableLike">
                        <label class="Mandatory" for="Name"><span class="Marker">*</span> [% Translate("Name") | html %]:</label>
                        <div class="Field">
                            <input type="text" name="Name" id="Name" value="[% Data.Name | html %]" class="W50pc Validate_Required [% Data.NameInvalid | html %]" maxlength="200"/>
                            <div id="NameError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                            <div id="NameServerError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                        </div>
                        <div class="Clear"></div>

                        <label class="Mandatory" for="RichText"><span class="Marker">*</span> [% Translate("Signature") | html %]:</label>
                        <div class="RichTextField">
                            [%# Textareas always swallow the first newline from their data, therefore we must prepend one since we want to preserve white space. %]
                            <textarea id="RichText" class="RichText Validate_Required" rows="10" cols="60" name="Text">[% "\n" _ Data.Text | html %]</textarea>
                            <div id="RichTextError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                            <div id="RichTextServerError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                        </div>
                        <div class="Clear"></div>

                        <label class="Mandatory" for="ValidID"><span class="Marker">*</span> [% Translate("Validity") | html %]:</label>
                        <div class="Field">
                            [% Data.ValidOption %]
                            <div id="ValidIDError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                            <div id="ValidIDServerError" class="TooltipErrorMessage">
                                <p>[% Translate("This field is required.") | html %]</p>
                            </div>
                        </div>
                        <div class="Clear"></div>

                        <label for="Comment">[% Translate("Comment") | html %]:</label>
                        <div class="Field">
                            <input type="text" name="Comment" id="Comment" value="[% Data.Comment | html %]" class="W50pc" maxlength="250"/>
                        </div>
                        <div class="Clear"></div>
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
                    [% IF Data.Permission != 'ro' %]
# EO LightAdmin-AutoRepliesAndSignatures
                        <div class="Field">
                            [% IF Data.Action == 'Change' %]
                                <button class="CallForAction Primary" id="SubmitAndContinue" type="button" value="[% Translate("Save") | html %]"><span>[% Translate("Save") | html %]</span></button>
                                [% Translate("or") | html %]
                                <button class="CallForAction Primary" id="Submit" type="submit" value="[% Translate("Save") | html %]"><span>[% Translate("Save and finish") | html %]</span></button>
                            [% ELSE %]
                                <button class="CallForAction Primary" id="Submit" type="submit" value="[% Translate("Save") | html %]"><span>[% Translate("Save") | html %]</span></button>
                            [% END %]
                            [% Translate("or") | html %]
                            <a href="[% Env("Baselink") %]Action=[% Env("Action") %]">[% Translate("Cancel") | html %]</a>
                        </div>
                        <div class="Clear"></div>
# Rother OSS / LightAdmin-AutoRepliesAndSignatures
                    [% END %]
# EO LightAdmin-AutoRepliesAndSignatures
                    </fieldset>
                </form>
            </div>
        </div>
        <div class="WidgetSimple SpacingTop">
            <div class="Header">
                <h2>[% Translate("Hint") | html %]</h2>
            </div>
            <div class="Content">
                <p>[% Translate("You can use the following tags") | html %]:</p>
                <dl>
                    <dt><code>&lt;OTOBO_OWNER_*&gt;</code></dt>
                    <dd>
                        [% Translate("Ticket owner options") | html %] ([% Translate("e. g.") | html %]
                        <code>&lt;OTOBO_OWNER_UserFirstname&gt;</code>).
                    </dd>

                    <dt><code>&lt;OTOBO_RESPONSIBLE_*&gt;</code></dt>
                    <dd>
                        [% Translate("Ticket responsible options") | html %] ([% Translate("e. g.") | html %]
                        <code>&lt;OTOBO_RESPONSIBLE_UserFirstname&gt;</code>).
                    </dd>

                    <dt><code>&lt;OTOBO_CURRENT_*&gt;</code></dt>
                    <dd>
                        [% Translate("Options of the current user who requested this action") | html %] ([% Translate("e. g.") | html %]
                        <code>&lt;OTOBO_CURRENT_UserFirstname&gt;</code>).
                    </dd>

                    <dt><code>&lt;OTOBO_TICKET_*&gt;</code></dt>
                    <dd>
                        [% Translate("Options of the ticket data") | html %] ([% Translate("e. g.") | html %]
                        <code>&lt;OTOBO_TICKET_TicketNumber>, &lt;OTOBO_TICKET_TicketID&gt;, &lt;OTOBO_TICKET_Queue&gt;, &lt;OTOBO_TICKET_State&gt;</code>).
                    </dd>

                    <dt><code>&lt;OTOBO_CUSTOMER_DATA_*&gt;</code></dt>
                    <dd>
                        [% Translate("Options of the current customer user data") | html %] ([% Translate("e. g.") | html %]
                        <code>&lt;OTOBO_CUSTOMER_DATA_UserFirstname&gt;</code>).
                    </dd>

                    <dt><code>&lt;OTOBO_CONFIG_*&gt;</code></dt>
                    <dd>
                        [% Translate("Config options") | html %] ([% Translate("e. g.") | html %] <code>&lt;OTOBO_CONFIG_HttpType&gt;</code>).
                    </dd>
                </dl>

                <p class="SpacingTop">
                    [% Translate("Example signature") | html %]:
                </p>
                <textarea rows="5" cols="60" name="Response">
Your OTOBO-Team

&lt;OTOBO_CURRENT_UserFirstname&gt; &lt;OTOBO_CURRENT_UserLastname&gt;

--
Super Support Company Inc. - Waterford Business Park
5201 Blue Lagoon Drive - 8th Floor & 9th Floor - Miami, 33126 USA
Email: hot@florida.com - Web: http://hot.florida.com/
--
PS: Your email address in our database is "&lt;OTOBO_CUSTOMER_DATA_UserEmail&gt;".
                </textarea>
            </div>
        </div>
[% RenderBlockEnd("OverviewUpdate") %]
    </div>
    <div class="Clear"></div>
</div>
[% RenderBlockEnd("Overview") %]
 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - 6efdc7bf2a3325277cd79a60f0f2407f8ad59e87 - Kernel/System/Queue.pm
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

package Kernel::System::Queue;

use strict;
use warnings;

use parent                        qw(Kernel::System::EventHandler);
use Kernel::System::VariableCheck qw(IsArrayRefWithData);

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::System::Cache',
    'Kernel::System::CustomerGroup',
    'Kernel::System::DB',
    'Kernel::System::Group',
    'Kernel::System::Log',
    'Kernel::System::Main',
    'Kernel::System::StandardTemplate',
    'Kernel::System::SysConfig',
    'Kernel::System::Translations',
    'Kernel::System::Valid',
);

=head1 NAME

Kernel::System::Queue - queue lib

=head1 DESCRIPTION

All queue functions. E. g. to add queue or other functions.

=head1 PUBLIC INTERFACE

=head2 new()

Don't use the constructor directly, use the ObjectManager instead:

    my $QueueObject = $Kernel::OM->Get('Kernel::System::Queue');

=cut

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

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

    $Self->{QueueID} = $Param{QueueID} || '';

    $Self->{CacheType} = 'Queue';
    $Self->{CacheTTL}  = 60 * 60 * 24 * 20;

    # load generator preferences module
    my $GeneratorModule = $Kernel::OM->Get('Kernel::Config')->Get('Queue::PreferencesModule')
        || 'Kernel::System::Queue::PreferencesDB';
    if ( $Kernel::OM->Get('Kernel::System::Main')->Require($GeneratorModule) ) {
        $Self->{PreferencesObject} = $GeneratorModule->new();
    }

    # --------------------------------------------------- #
    #  default queue settings                             #
    #  these settings are used by the CLI version         #
    # --------------------------------------------------- #
    $Self->{QueueDefaults} = {
        Calendar            => '',
        UnlockTimeout       => 0,
        FirstResponseTime   => 0,
        FirstResponseNotify => 0,
        UpdateTime          => 0,
        UpdateNotify        => 0,
        SolutionTime        => 0,
        SolutionNotify      => 0,
        SystemAddressID     => 1,
        SalutationID        => 1,
        SignatureID         => 1,
        FollowUpID          => 1,
        FollowUpLock        => 0,
    };

    # init of event handler
    $Self->EventHandlerInit(
        Config => 'Queue::EventModulePost',
    );

    return $Self;
}

=head2 GetSystemAddress()

get a queue system email address as hash (Email, RealName)

    my %Address = $QueueObject->GetSystemAddress(
        QueueID => 123,
    );

=cut

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

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    my %Address;
    my $QueueID = $Param{QueueID} || $Self->{QueueID};

    return if !$DBObject->Prepare(
        SQL => 'SELECT sa.value0, sa.value1 FROM system_address sa, queue sq '
            . 'WHERE sq.id = ? AND sa.id = sq.system_address_id',
        Bind  => [ \$QueueID ],
        Limit => 1,
    );

    while ( my @Row = $DBObject->FetchrowArray() ) {
        $Address{Email}    = $Row[0];
        $Address{RealName} = $Row[1];
    }

    # prepare realname quote
    if ( $Address{RealName} =~ /(,|@|\(|\)|:)/ && $Address{RealName} !~ /^("|')/ ) {
        $Address{RealName} =~ s/"/\"/g;
        $Address{RealName} = '"' . $Address{RealName} . '"';
    }

    return %Address;
}

=head2 GetSignature()

get a queue signature

    my $Signature = $QueueObject->GetSignature(QueueID => 123);

=cut

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

    # check needed stuff
    if ( !$Param{QueueID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need QueueID!',
        );
        return;
    }

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    return if !$DBObject->Prepare(
        SQL => 'SELECT text FROM signature si, queue sq '
            . ' WHERE sq.id = ? AND sq.signature_id = si.id',
        Bind  => [ \$Param{QueueID} ],
        Limit => 1,
    );

    # fetch the result
    my $String = '';
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $String = $Row[0];
    }

    return $String;
}

=head2 QueueStandardTemplateMemberAdd()

to add a template to a queue

    my $Success = $QueueObject->QueueStandardTemplateMemberAdd(
        QueueID            => 123,
        StandardTemplateID => 123,
        Active             => 1,        # to set/confirm (1) or remove (0) the relation
        UserID             => 123,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(QueueID StandardTemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # delete existing relation
    return if !$DBObject->Do(
        SQL => 'DELETE FROM queue_standard_template
            WHERE queue_id = ?
            AND standard_template_id = ?',
        Bind => [ \$Param{QueueID}, \$Param{StandardTemplateID} ],
    );

    # return if relation is not active
    if ( !$Param{Active} ) {
        $Kernel::OM->Get('Kernel::System::Cache')->CleanUp(
            Type => $Self->{CacheType},
        );
        return 1;
    }

    # insert new relation
    my $Success = $DBObject->Do(
        SQL => '
            INSERT INTO queue_standard_template (queue_id, standard_template_id, create_time,
                create_by, change_time, change_by)
            VALUES (?, ?, current_timestamp, ?, current_timestamp, ?)',
        Bind => [ \$Param{QueueID}, \$Param{StandardTemplateID}, \$Param{UserID}, \$Param{UserID} ],
    );

    $Kernel::OM->Get('Kernel::System::Cache')->CleanUp(
        Type => $Self->{CacheType},
    );
    return $Success;
}

=head2 QueueStandardTemplateMemberList()

get standard responses of a queue

    my %Templates = $QueueObject->QueueStandardTemplateMemberList( QueueID => 123 );

Returns:
    %Templates = (
        1 => 'Some Name',
        2 => 'Some Name',
    );

    my %Responses = $QueueObject->QueueStandardTemplateMemberList(
        QueueID       => 123,
        TemplateTypes => 1,
    );

Returns:
    %Responses = (
        Answer => {
            1 => 'Some Name',
            2 => 'Some Name',
        },
        # ...
    );

    my %Queues = $QueueObject->QueueStandardTemplateMemberList( StandardTemplateID => 123 );

Returns:
    %Queues = (
        1 => 'Some Name',
        2 => 'Some Name',
    );

=cut

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

    # check needed stuff
    if ( !$Param{QueueID} && !$Param{StandardTemplateID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Got no StandardTemplateID or QueueID!',
        );
        return;
    }

    # get needed objects
    my $ValidObject = $Kernel::OM->Get('Kernel::System::Valid');
    my $DBObject    = $Kernel::OM->Get('Kernel::System::DB');

    my $TemplateTypes = $Param{TemplateTypes} || '0';

    my $CacheKey;

    if ( $Param{QueueID} ) {

        # check if this result is present (in cache)
        $CacheKey = "StandardTemplates::$Param{QueueID}::$TemplateTypes";
        my $Cache = $Kernel::OM->Get('Kernel::System::Cache')->Get(
            Type => $Self->{CacheType},
            Key  => $CacheKey,
        );
        return %{$Cache} if ref $Cache eq 'HASH';

        # get std. templates
        my $SQL = "SELECT st.id, st.name, st.template_type "
            . " FROM standard_template st, queue_standard_template qst WHERE "
            . " qst.queue_id IN ("
            . $DBObject->Quote( $Param{QueueID}, 'Integer' )
            . ") AND "
            . " qst.standard_template_id = st.id AND "
            . " st.valid_id IN ( ${\(join ', ', $ValidObject->ValidIDsGet())} )"
            . " ORDER BY st.name";

        return if !$DBObject->Prepare( SQL => $SQL );

        # fetch the result
        my %StandardTemplates;
        while ( my @Row = $DBObject->FetchrowArray() ) {

            if ( $Param{TemplateTypes} ) {
                $StandardTemplates{ $Row[2] }->{ $Row[0] } = $Row[1];
            }
            else {
                $StandardTemplates{ $Row[0] } = $Row[1];
            }
        }

        # store std templates (in cache)
        $Kernel::OM->Get('Kernel::System::Cache')->Set(
            Type  => $Self->{CacheType},
            TTL   => $Self->{CacheTTL},
            Key   => $CacheKey,
            Value => \%StandardTemplates,

        );
        return %StandardTemplates;
    }

    else {

        # check if this result is present (in cache)
        $CacheKey = "Queues::$Param{StandardTemplateID}";
        my $Cache = $Kernel::OM->Get('Kernel::System::Cache')->Get(
            Type => $Self->{CacheType},
            Key  => $CacheKey,
        );
        return %{$Cache} if ref $Cache eq 'HASH';

        # get queues
        my $SQL = "SELECT q.id, q.name "
            . " FROM queue q, queue_standard_template qst WHERE "
            . " qst.standard_template_id IN ("
            . $DBObject->Quote( $Param{StandardTemplateID}, 'Integer' )
            . ") AND "
            . " qst.queue_id = q.id AND "
            . " q.valid_id IN ( ${\(join ', ', $ValidObject->ValidIDsGet())} )"
            . " ORDER BY q.name";

        return if !$DBObject->Prepare( SQL => $SQL );

        # fetch the result
        my %Queues;
        while ( my @Row = $DBObject->FetchrowArray() ) {
            $Queues{ $Row[0] } = $Row[1];
        }

        # store queues (in cache)
        $Kernel::OM->Get('Kernel::System::Cache')->Set(
            Type  => $Self->{CacheType},
            TTL   => $Self->{CacheTTL},
            Key   => $CacheKey,
            Value => \%Queues,
        );

        return %Queues;
    }
}

=head2 GetAllQueues()

get all valid system queues

    my %Queues = $QueueObject->GetAllQueues();

get all system queues of a user with permission type (e. g. C<ro>, C<move_into>, C<rw>, ...)

    my %Queues = $QueueObject->GetAllQueues( UserID => 123, Type => 'ro' );

=cut

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

    my $Type = $Param{Type} || 'ro';

    # get needed objects
    my $ValidObject = $Kernel::OM->Get('Kernel::System::Valid');
    my $DBObject    = $Kernel::OM->Get('Kernel::System::DB');

    # fetch all queues
    my $CacheKey;
    if ( $Param{UserID} ) {

        # get group list
        my %GroupList = $Kernel::OM->Get('Kernel::System::Group')->PermissionUserGet(
            UserID => $Param{UserID},
            Type   => $Type,
        );

        return if !%GroupList;

        my $GroupString = join ', ', sort keys %GroupList;
        $CacheKey = "GetAllQueues::UserID::${Type}::${GroupString}::$Param{UserID}";

        # check cache
        my $Cache = $Kernel::OM->Get('Kernel::System::Cache')->Get(
            Type => $Self->{CacheType},
            Key  => $CacheKey,
        );
        return %{$Cache} if $Cache;

        return if !$DBObject->Prepare(
            SQL => "SELECT id, name FROM queue WHERE "
                . " group_id IN ( $GroupString ) AND "
                . " valid_id IN ( ${\(join ', ', $ValidObject->ValidIDsGet())} )",
        );
    }
    elsif ( $Param{CustomerUserID} ) {

        # get group ids
        my @GroupIDs = $Kernel::OM->Get('Kernel::System::CustomerGroup')->GroupMemberList(
            UserID => $Param{CustomerUserID},
            Type   => $Type,
            Result => 'ID',
        );

        return if !@GroupIDs;

        my $GroupString = join ', ', sort @GroupIDs;
        $CacheKey = "GetAllQueues::CustomerUserID::${Type}::${GroupString}::$Param{CustomerUserID}";

        # check cache
        my $Cache = $Kernel::OM->Get('Kernel::System::Cache')->Get(
            Type => $Self->{CacheType},
            Key  => $CacheKey,
        );
        return %{$Cache} if $Cache;

        return if !$DBObject->Prepare(
            SQL => "SELECT id, name FROM queue WHERE "
                . " group_id IN ( $GroupString ) AND "
                . " valid_id IN ( ${\(join ', ', $ValidObject->ValidIDsGet())} )",
        );
    }
    else {

        $CacheKey = 'GetAllQueues';

        # check cache
        my $Cache = $Kernel::OM->Get('Kernel::System::Cache')->Get(
            Type => $Self->{CacheType},
            Key  => $CacheKey,
        );
        return %{$Cache} if $Cache;

        return if !$DBObject->Prepare(
            SQL => "SELECT id, name FROM queue WHERE valid_id IN "
                . "( ${\(join ', ', $ValidObject->ValidIDsGet())} )",
        );
    }

    my %MoveQueues;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $MoveQueues{ $Row[0] } = $Row[1];
    }

    # set cache
    $Kernel::OM->Get('Kernel::System::Cache')->Set(
        Type  => $Self->{CacheType},
        TTL   => $Self->{CacheTTL},
        Key   => $CacheKey,
        Value => \%MoveQueues,
    );

    return %MoveQueues;
}

=head2 GetAllCustomQueues()

get all custom queues of one user

    my @Queues = $QueueObject->GetAllCustomQueues( UserID => 123 );

=cut

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

    # check needed stuff
    if ( !$Param{UserID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need UserID!'
        );
        return;
    }

    # check cache
    my $CacheKey = 'GetAllCustomQueues::' . $Param{UserID};
    my $Cache    = $Kernel::OM->Get('Kernel::System::Cache')->Get(
        Type => $Self->{CacheType},
        Key  => $CacheKey,
    );
    return @{$Cache} if $Cache;

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # search all custom queues
    return if !$DBObject->Prepare(
        SQL  => 'SELECT queue_id FROM personal_queues WHERE user_id = ?',
        Bind => [ \$Param{UserID} ],
    );

    # fetch the result
    my @QueueIDs;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        push @QueueIDs, $Row[0];
    }

    # set cache
    $Kernel::OM->Get('Kernel::System::Cache')->Set(
        Type  => $Self->{CacheType},
        TTL   => $Self->{CacheTTL},
        Key   => $CacheKey,
        Value => \@QueueIDs,
    );

    return @QueueIDs;
}

=head2 QueueLookup()

get id or name for queue

    my $Queue = $QueueObject->QueueLookup( QueueID => $QueueID );

    my $QueueID = $QueueObject->QueueLookup( Queue => $Queue );

=cut

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

    # check needed stuff
    if ( !$Param{Queue} && !$Param{QueueID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Got no Queue or QueueID!'
        );
        return;
    }

    # get (already cached) queue data
    my %QueueList = $Self->QueueList(
        Valid => 0,
    );

    my $Key;
    my $Value;
    my $ReturnData;
    if ( $Param{QueueID} ) {
        $Key        = 'QueueID';
        $Value      = $Param{QueueID};
        $ReturnData = $QueueList{ $Param{QueueID} };
    }
    else {
        $Key   = 'Queue';
        $Value = $Param{Queue};
        my %QueueListReverse = reverse %QueueList;
        $ReturnData = $QueueListReverse{ $Param{Queue} };
    }

    # check if data exists
    if ( !$ReturnData ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Found no $Key for $Value!",
        );
        return;
    }

    return $ReturnData;
}

=head2 GetFollowUpOption()

get FollowUpOption for the given QueueID

    my $FollowUpOption = $QueueObject->GetFollowUpOption( QueueID => $QueueID );

returns any of 'possible', 'reject', 'new ticket'.

=cut

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

    # check needed stuff
    if ( !$Param{QueueID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need QueueID!'
        );
        return;
    }

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # fetch queues data
    return if !$DBObject->Prepare(
        SQL => 'SELECT sf.name FROM follow_up_possible sf, queue sq '
            . ' WHERE sq.follow_up_id = sf.id AND sq.id = ?',
        Bind  => [ \$Param{QueueID} ],
        Limit => 1,
    );

    my $Return = '';
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $Return = $Row[0];
    }

    return $Return;
}

=head2 GetFollowUpOptionList()

get Follow-Up Option list

    my %FollowUpOptionList = $QueueObject->GetFollowUpOptionList(
        Valid => 0,             # (optional) default 1
    );

Return:

    %FollowUpOptionList = (
              '1' => 'possible',
              '3' => 'new ticket',
              '2' => 'reject'
            )

=cut

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

    # set default value
    my $Valid = $Param{Valid} ? 1 : 0;

    # create the valid list
    my $ValidIDs = join ', ', $Kernel::OM->Get('Kernel::System::Valid')->ValidIDsGet();

    # build SQL
    my $SQL = 'SELECT id, name FROM follow_up_possible';

    # add WHERE statement
    if ($Valid) {
        $SQL .= ' WHERE valid_id IN (' . $ValidIDs . ')';
    }

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # get data from database
    return if !$DBObject->Prepare(
        SQL => $SQL,
    );

    # fetch the result
    my %FollowUpOptionList;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $FollowUpOptionList{ $Row[0] } = $Row[1];
    }

    return %FollowUpOptionList;
}

=head2 GetFollowUpLockOption()

get FollowUpLockOption for the given QueueID

    my $FollowUpLockOption = $QueueObject->GetFollowUpLockOption( QueueID => $QueueID );

returns '1' if ticket should be locked after a follow up, '0' if not.

=cut

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

    # check needed stuff
    if ( !$Param{QueueID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need QueueID!'
        );
        return;
    }

    # get (already cached) queue data
    my %Queue = $Self->QueueGet(
        ID => $Param{QueueID},
    );

    return if !%Queue;
    return $Queue{FollowUpLock};
}

=head2 GetQueueGroupID()

get GroupID defined for the given QueueID.

    my $GroupID = $QueueObject->GetQueueGroupID( QueueID => $QueueID );

=cut

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

    # check needed stuff
    if ( !$Param{QueueID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need QueueID!'
        );
        return;
    }

    # get (already cached) queue data
    my %Queue = $Self->QueueGet(
        ID => $Param{QueueID},
    );

    return if !%Queue;
    return $Queue{GroupID};
}

=head2 QueueAdd()

add queue with attributes

    my $QueueID = $QueueObject->QueueAdd(
        Name                => 'Some::Queue',
        ValidID             => 1,
        GroupID             => 1,
        Calendar            => '1',         # (optional)
        FirstResponseTime   => 120,         # (optional)
        FirstResponseNotify => 60,          # (optional, notify agent if first response escalation is 60% reached)
        UpdateTime          => 180,         # (optional)
        UpdateNotify        => 80,          # (optional, notify agent if update escalation is 80% reached)
        SolutionTime        => 580,         # (optional)
        SolutionNotify      => 80,          # (optional, notify agent if solution escalation is 80% reached)
        UnlockTimeout       => 480,         # (optional)
        FollowUpID          => 3,           # possible (1), reject (2) or new ticket (3) (optional, default 0)
        FollowUpLock        => 0,           # yes (1) or no (0) (optional, default 0)
        DefaultSignKey      => 'key name',  # (optional)
        SystemAddressID     => 1,
        SalutationID        => 1,
        SignatureID         => 1,
        Comment             => 'Some comment',
        UserID              => 123,
    );

=cut

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

    # check if this request is from web and not from command line
    if ( !$Param{NoDefaultValues} ) {
        for (
            qw(UnlockTimeout FirstResponseTime FirstResponseNotify UpdateTime UpdateNotify SolutionTime SolutionNotify
            FollowUpLock SystemAddressID SalutationID SignatureID
            FollowUpID FollowUpLock DefaultSignKey Calendar)
            )
        {

            # I added default values in the Load Routine
            if ( !$Param{$_} ) {
                $Param{$_} = $Self->{QueueDefaults}->{$_} || 0;
            }
        }
    }

    for (qw(Name GroupID SystemAddressID SalutationID SignatureID ValidID UserID FollowUpID)) {
        if ( !$Param{$_} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $_!"
            );
            return;
        }
    }

    # cleanup queue name
    $Param{Name} =~ s/(\n|\r)//g;
    $Param{Name} =~ s/\s$//g;

    # check queue name
    if ( $Param{Name} =~ /::$/i ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Invalid Queue name '$Param{Name}'!",
        );
        return;
    }

    # check if a queue with this name already exists
    if ( $Self->NameExistsCheck( Name => $Param{Name} ) ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "A queue with the name '$Param{Name}' already exists.",
        );
        return;
    }

    # get needed objects
    my $ConfigObject = $Kernel::OM->Get('Kernel::Config');
    my $DBObject     = $Kernel::OM->Get('Kernel::System::DB');

    return if !$DBObject->Do(
        SQL => 'INSERT INTO queue (name, group_id, unlock_timeout, system_address_id, '
            . ' calendar_name, default_sign_key, salutation_id, signature_id, '
            . ' first_response_time, first_response_notify, update_time, '
            . ' update_notify, solution_time, solution_notify, follow_up_id, '
            . ' follow_up_lock, valid_id, comments, create_time, create_by, '
            . ' change_time, change_by) VALUES '
            . ' (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '
            . ' ?, current_timestamp, ?, current_timestamp, ?)',
        Bind => [
            \$Param{Name},              \$Param{GroupID},             \$Param{UnlockTimeout}, \$Param{SystemAddressID},
            \$Param{Calendar},          \$Param{DefaultSignKey},      \$Param{SalutationID},  \$Param{SignatureID},
            \$Param{FirstResponseTime}, \$Param{FirstResponseNotify}, \$Param{UpdateTime},
            \$Param{UpdateNotify},      \$Param{SolutionTime},        \$Param{SolutionNotify},
            \$Param{FollowUpID},        \$Param{FollowUpLock},        \$Param{ValidID},
            \$Param{Comment},           \$Param{UserID},              \$Param{UserID},
        ],
    );

    # get new id
    return if !$DBObject->Prepare(
        SQL   => 'SELECT id FROM queue WHERE name = ?',
        Bind  => [ \$Param{Name} ],
        Limit => 1,
    );

    # fetch the result
    my $QueueID = '';
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $QueueID = $Row[0];
    }

    # reset cache
    $Kernel::OM->Get('Kernel::System::Cache')->CleanUp(
        Type => $Self->{CacheType},
    );

    my $StandardTemplate2QueueByCreating = $ConfigObject->Get('StandardTemplate2QueueByCreating');

    # add default responses (if needed), add response by name
    if (
        $StandardTemplate2QueueByCreating
        && ref $StandardTemplate2QueueByCreating eq 'ARRAY'
        && @{$StandardTemplate2QueueByCreating}
        )
    {

        # get standard template object
        my $StandardTemplateObject = $Kernel::OM->Get('Kernel::System::StandardTemplate');

        ST:
        for my $ST ( @{$StandardTemplate2QueueByCreating} ) {

            my $StandardTemplateID = $StandardTemplateObject->StandardTemplateLookup(
                StandardTemplate => $ST,
            );

            next ST if !$StandardTemplateID;

            $Self->QueueStandardTemplateMemberAdd(
                QueueID            => $QueueID,
                StandardTemplateID => $StandardTemplateID,
                Active             => 1,
                UserID             => $Param{UserID},
            );
        }
    }

    # get standard template id
    my $StandardTemplateID2QueueByCreating = $ConfigObject->Get(' StandardTemplate2QueueByCreating');

    # get queue data with updated name for QueueCreate event
    my %Queue = $Self->QueueGet( Name => $Param{Name} );

    # trigger event
    $Self->EventHandler(
        Event => 'QueueCreate',
        Data  => {
            Queue => \%Queue,
        },
        UserID => $Param{UserID},
    );

    my %Queues = $Self->QueueList();

    # generate chained translations automatically
    $Kernel::OM->Get('Kernel::System::Translations')->TranslateParentChildElements(
        Strings => [ values %Queues ],
    );

    return $QueueID if !$StandardTemplateID2QueueByCreating;
    return $QueueID if ref $StandardTemplateID2QueueByCreating ne 'ARRAY';
    return $QueueID if !@{$StandardTemplateID2QueueByCreating};

    # add template by id
    for my $StandardTemplateID ( @{$StandardTemplateID2QueueByCreating} ) {

        $Self->QueueStandardTemplateMemberAdd(
            QueueID            => $QueueID,
            StandardTemplateID => $StandardTemplateID,
            Active             => 1,
            UserID             => $Param{UserID},
        );
    }

    return $QueueID;
}

=head2 QueueGet()

get queue attributes

    my %Queue = $QueueObject->QueueGet(
        ID    => 123,
    );

    my %Queue = $QueueObject->QueueGet(
        Name  => 'Some::Queue',
    );

=cut

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

    # check needed stuff
    if ( !$Param{ID} && !$Param{Name} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need ID or Name!'
        );
        return;
    }

    # check runtime cache
    my $CacheKey;
    my $Key;
    my $Value;
    if ( $Param{ID} ) {
        $CacheKey = 'QueueGetID::' . $Param{ID};
        $Key      = 'ID';
        $Value    = $Param{ID};
    }
    else {
        $CacheKey = 'QueueGetName::' . $Param{Name};
        $Key      = 'Name';
        $Value    = $Param{Name};
    }

    # check cache
    my $Cache = $Kernel::OM->Get('Kernel::System::Cache')->Get(
        Type => $Self->{CacheType},
        Key  => $CacheKey,
    );
    return %{$Cache} if $Cache;

    # sql
    my @Bind;
    my $SQL = 'SELECT q.name, q.group_id, q.unlock_timeout, '
        . 'q.system_address_id, q.salutation_id, q.signature_id, q.comments, q.valid_id, '
        . 'q.first_response_time, q.first_response_notify, '
        . 'q.update_time, q.update_notify, q.solution_time, q.solution_notify, '
        . 'q.follow_up_id, q.follow_up_lock, sa.value0, sa.value1, q.id, '
        . 'q.default_sign_key, q.calendar_name, q.create_time, q.change_time FROM queue q, '
        . 'system_address sa WHERE q.system_address_id = sa.id AND ';

    if ( $Param{ID} ) {
        $SQL .= 'q.id = ?';
        push @Bind, \$Param{ID};
    }
    else {
        $SQL .= 'q.name = ?';
        push @Bind, \$Param{Name};
    }

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    return if !$DBObject->Prepare(
        SQL   => $SQL,
        Bind  => \@Bind,
        Limit => 1,
    );

    # fetch the result
    my %Data;
    while ( my @Data = $DBObject->FetchrowArray() ) {
        %Data = (
            QueueID             => $Data[18],
            Name                => $Data[0],
            GroupID             => $Data[1],
            UnlockTimeout       => $Data[2],
            FirstResponseTime   => $Data[8],
            FirstResponseNotify => $Data[9],
            UpdateTime          => $Data[10],
            UpdateNotify        => $Data[11],
            SolutionTime        => $Data[12],
            SolutionNotify      => $Data[13],
            FollowUpID          => $Data[14],
            FollowUpLock        => $Data[15],
            SystemAddressID     => $Data[3],
            SalutationID        => $Data[4],
            SignatureID         => $Data[5],
            Comment             => $Data[6],
            ValidID             => $Data[7],
            Email               => $Data[16],
            RealName            => $Data[17],
            DefaultSignKey      => $Data[19],
            Calendar            => $Data[20] || '',
            CreateTime          => $Data[21],
            ChangeTime          => $Data[22],
        );
    }

    # check if data exists
    if ( !%Data ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Found no $Key for $Value!",
        );
        return;
    }

    # get queue preferences
    my %Preferences = $Self->QueuePreferencesGet( QueueID => $Data{QueueID} );

    # merge hash
    if (%Preferences) {
        %Data = ( %Data, %Preferences );
    }

    # set cache
    $Kernel::OM->Get('Kernel::System::Cache')->Set(
        Type  => $Self->{CacheType},
        TTL   => $Self->{CacheTTL},
        Key   => $CacheKey,
        Value => \%Data,
    );

    return %Data;
}

=head2 QueueUpdate()

update queue attributes

    my $Success = $QueueObject->QueueUpdate(
        QueueID             => 123,
        Name                => 'Some::Queue',
        ValidID             => 1,
        GroupID             => 1,
        Calendar            => '1', # (optional) default ''
        FirstResponseTime   => 120, # (optional)
        FirstResponseNotify => 60,  # (optional, notify agent if first response escalation is 60% reached)
        UpdateTime          => 180, # (optional)
        UpdateNotify        => 80,  # (optional, notify agent if update escalation is 80% reached)
        SolutionTime        => 580, # (optional)
        SolutionNotify      => 80,  # (optional, notify agent if solution escalation is 80% reached)
        SystemAddressID     => 1,
        SalutationID        => 1,
        SignatureID         => 1,
        UserID              => 123,
        FollowUpID          => 1,
        Comment             => 'Some Comment2',
        DefaultSignKey      => ''
        UnlockTimeOut       => ''
        FollowUpLock        => 1,
        ParentQueueID       => '',
    );

=cut

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

    # check needed stuff
    for (
        qw(QueueID Name ValidID GroupID SystemAddressID SalutationID SignatureID UserID FollowUpID)
        )
    {
        if ( !$Param{$_} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $_!"
            );
            return;
        }
    }

    # FollowUpLock 0 | 1
    $Param{FollowUpLock} = $Param{FollowUpLock} || 0;

    # DefaultSignKey   '' || 'string'
    $Param{DefaultSignKey} = $Param{DefaultSignKey} || '';

    # Calendar string  '', '1', '2', '3', '4', '5'  default ''
    $Param{Calendar} ||= '';

    # content -> time in seconds
    for my $Time (qw( UnlockTimeout FirstResponseTime UpdateTime SolutionTime )) {

        $Param{$Time} = $Param{$Time} || 0;

        if ( $Param{$Time} !~ m{^\d+$}smx ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "$Time is not numeric!"
            );
            return;
        }
    }

    # content integer from 0 - 99
    for my $Notify (qw(FirstResponseNotify  UpdateNotify  SolutionNotify)) {

        $Param{$Notify} = $Param{$Notify} || 0;

        if ( $Param{$Notify} !~ m{^\d{1,2}}smx ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "$Notify must be an integer in the range from 0 to 99!",
            );
            return;
        }
    }

    # cleanup queue name
    $Param{Name} =~ s/(\n|\r)//g;
    $Param{Name} =~ s/\s$//g;

    # check queue name
    if ( $Param{Name} =~ /::$/i ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Invalid Queue name '$Param{Name}'!",
        );
        return;
    }

    # check if queue name exists
    my %AllQueue = $Self->QueueList( Valid => 0 );
    my %OldQueue = $Self->QueueGet( ID => $Param{QueueID} );

    # check if a queue with this name already exists
    if (
        $Self->NameExistsCheck(
            ID   => $Param{QueueID},
            Name => $Param{Name}
        )
        )
    {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "A queue with the name '$Param{Name}' already exists.",
        );
        return;
    }

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # SQL
    return if !$DBObject->Do(
        SQL => '
            UPDATE queue
            SET name = ?, comments = ?, group_id = ?, unlock_timeout = ?, first_response_time = ?,
                first_response_notify = ?, update_time = ?, update_notify = ?, solution_time = ?,
                solution_notify = ?, follow_up_id = ?, follow_up_lock = ?, system_address_id = ?,
                calendar_name = ?, default_sign_key = ?, salutation_id = ?, signature_id = ?,
                valid_id = ?, change_time = current_timestamp, change_by = ?
            WHERE id = ?',
        Bind => [
            \$Param{Name},              \$Param{Comment},             \$Param{GroupID}, \$Param{UnlockTimeout},
            \$Param{FirstResponseTime}, \$Param{FirstResponseNotify}, \$Param{UpdateTime},
            \$Param{UpdateNotify},      \$Param{SolutionTime},        \$Param{SolutionNotify},
            \$Param{FollowUpID},        \$Param{FollowUpLock},        \$Param{SystemAddressID},
            \$Param{Calendar},          \$Param{DefaultSignKey},      \$Param{SalutationID},
            \$Param{SignatureID},       \$Param{ValidID},             \$Param{UserID},
            \$Param{QueueID},
        ],
    );

    # get queue data with updated name for QueueUpdate event
    my %Queue = $Self->QueueGet( Name => $Param{Name} );

    # trigger event
    $Self->EventHandler(
        Event => 'QueueUpdate',
        Data  => {
            Queue    => \%Queue,
            OldQueue => \%OldQueue,
        },
        UserID => $Param{UserID},
    );

    # reset cache
    $Kernel::OM->Get('Kernel::System::Cache')->CleanUp(
        Type => $Self->{CacheType},
    );

    return 1 if $Param{Name} eq $OldQueue{Name};

    # updated all sub queue names
    my @ParentQueue = split( /::/, $OldQueue{Name} );

    for my $QueueID ( sort keys %AllQueue ) {

        my @SubQueue = split( /::/, $AllQueue{$QueueID} );

        if ( $#SubQueue > $#ParentQueue ) {

            if ( $AllQueue{$QueueID} =~ /^\Q$OldQueue{Name}::\E/i ) {

                my $NewQueueName = $AllQueue{$QueueID};
                $NewQueueName =~ s/\Q$OldQueue{Name}\E/$Param{Name}/;

                return if !$DBObject->Do(
                    SQL => '
                        UPDATE queue
                        SET name = ?, change_time = current_timestamp, change_by = ?
                        WHERE id = ?',
                    Bind => [ \$NewQueueName, \$Param{UserID}, \$QueueID ],
                );

                # reset cache
                $Kernel::OM->Get('Kernel::System::Cache')->CleanUp(
                    Type => $Self->{CacheType},
                );
            }
        }
    }

    my %Queues = $Self->QueueList();

    # generate chained translations automatically
    $Kernel::OM->Get('Kernel::System::Translations')->TranslateParentChildElements(
        Strings => [ values %Queues ],
    );

    return 1;
}

=head2 QueueList()

get all queues

    my %Queues = $QueueObject->QueueList();

    my %Queues = $QueueObject->QueueList( Valid => 1 );

=cut

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

    # set valid option
    my $Valid = $Param{Valid};
    if ( !defined $Valid || $Valid ) {
        $Valid = 1;
    }
    else {
        $Valid = 0;
    }

    # check cache
    my $CacheKey = 'QueueList::' . $Valid;
    my $Cache    = $Kernel::OM->Get('Kernel::System::Cache')->Get(
        Type => $Self->{CacheType},
        Key  => $CacheKey,
    );
    return %{$Cache} if $Cache;

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');

    # sql query
    if ($Valid) {
        return if !$DBObject->Prepare(
            SQL => "SELECT id, name FROM queue WHERE valid_id IN "
                . "( ${\(join ', ', $Kernel::OM->Get('Kernel::System::Valid')->ValidIDsGet())} )",
        );
    }
    else {
        return if !$DBObject->Prepare(
            SQL => 'SELECT id, name FROM queue',
        );
    }

    # fetch the result
    my %Queues;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $Queues{ $Row[0] } = $Row[1];
    }

    # set cache
    $Kernel::OM->Get('Kernel::System::Cache')->Set(
        Type  => $Self->{CacheType},
        TTL   => $Self->{CacheTTL},
        Key   => $CacheKey,
        Value => \%Queues,
    );

    return %Queues;
}

=head2 QueuePreferencesSet()

set queue preferences

    $QueueObject->QueuePreferencesSet(
        QueueID => 123,
        Key     => 'UserComment',
        Value   => 'some comment',
        UserID  => 123,
    );

=cut

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

    # delete cache
    my $Name      = $Self->QueueLookup( QueueID => $Param{QueueID} );
    my @CacheKeys = (
        'QueueGetID::' . $Param{QueueID},
        'QueueGetName::' . $Name,
    );
    for my $CacheKey (@CacheKeys) {
        $Kernel::OM->Get('Kernel::System::Cache')->Delete(
            Type => $Self->{CacheType},
            Key  => $CacheKey,
        );
    }

    return $Self->{PreferencesObject}->QueuePreferencesSet(%Param);
}

=head2 QueuePreferencesGet()

get queue preferences

    my %Preferences = $QueueObject->QueuePreferencesGet(
        QueueID => 123,
        UserID  => 123,
    );

=cut

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

    return $Self->{PreferencesObject}->QueuePreferencesGet(%Param);
}

sub DESTROY {
    my $Self = shift;

    # execute all transaction events
    $Self->EventHandlerTransaction();

    return 1;
}

=head2 NameExistsCheck()

return 1 if another queue with this name already exists

    $Exist = $QueueObject->NameExistsCheck(
        Name => 'Some::Queue',
        ID => 1, # optional
    );

=cut

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

    # get database object
    my $DBObject = $Kernel::OM->Get('Kernel::System::DB');
    return if !$DBObject->Prepare(
        SQL  => 'SELECT id FROM queue WHERE name = ?',
        Bind => [ \$Param{Name} ],
    );

    # fetch the result
    my $Flag;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        if ( !$Param{ID} || $Param{ID} ne $Row[0] ) {
            $Flag = 1;
        }
    }

    if ($Flag) {
        return 1;
    }

    return 0;
}

=for stopwords ro rw

=head2 QueueListPermission()

Get the permission for a list of queues.
Returns nothing if the user has no 'ro' on any queue, 'ro' if the user has no 'rw' on at least one queue
and 'rw' if the user has full permission on all queues.

    my $Permission = $QueueObject->QueueListPermission(
        QueueIDs => \@QueueIDs,      # optional
        UserID   => $Param{UserID},
        Default  => 'rw',            # (optional) default 'ro' (ro|rw) fallback permission if no queues given
    );

=cut

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

    # Check needed stuff.
    if ( !$Param{UserID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need UserID!',
        );
        return;
    }

    my %RoQueues = $Self->GetAllQueues( UserID => $Param{UserID} );
    my %RwQueues = $Self->GetAllQueues(
        UserID => $Param{UserID},
        Type   => 'rw',
    );

    # 'ro' is the default permission if no queue is given and parameter 'Default' is not set.
    my $DefaultPermission = $Param{Default} || 'ro';

    return $DefaultPermission if !IsArrayRefWithData( $Param{QueueIDs} );

    # final permission is rw or '' if all are of that kind, else ro
    my $Permission;
    QUEUE:
    for my $QueueID ( @{ $Param{QueueIDs} } ) {
        if ( !defined $Permission ) {
            if ( $RwQueues{$QueueID} ) {
                $Permission = 'rw';
            }
            elsif ( $RoQueues{$QueueID} ) {
                $Permission = 'ro';
                last QUEUE;
            }
            else {
                $Permission = '';
            }
        }

        elsif ( $Permission eq '' ) {
            if ( $RwQueues{$QueueID} || $RwQueues{$QueueID} ) {
                $Permission = 'ro';
                last QUEUE;
            }
        }

        elsif ( !$RwQueues{$QueueID} ) {
            $Permission = 'ro';
            last QUEUE;
        }
    }

    return $Permission;
}

# Rother OSS / LightAdmin-AutoRepliesAndSignatures

=head2 QueueSignatureMemberList()

get queues associated to a signature

    my %Queues = $QueueObject->QueueSignatureMemberList( SignatureID => 123 );

Returns:
    %Queues = (
        1 => 'Some Name',
        2 => 'Some Name',
    );

=cut

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

    # check needed stuff
    if ( !$Param{SignatureID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Got no SignatureID!',
        );
        return;
    }

    # get needed objects
    my $ValidObject = $Kernel::OM->Get('Kernel::System::Valid');
    my $DBObject    = $Kernel::OM->Get('Kernel::System::DB');

    my $CacheKey;

    # check if this result is present (in cache)
    $CacheKey = "QueuesSignatures::$Param{SignatureID}";
    my $Cache = $Kernel::OM->Get('Kernel::System::Cache')->Get(
        Type => $Self->{CacheType},
        Key  => $CacheKey,
    );
    return %{$Cache} if ref $Cache eq 'HASH';

    # get queues
    my $SQL = "SELECT id, name FROM queue WHERE signature_id = ? AND "
        . " valid_id IN ( ${\(join ', ', $ValidObject->ValidIDsGet())} )"
        . " ORDER BY name";

    return if !$DBObject->Prepare(
        SQL => $SQL,
        Bind  => [ \$Param{SignatureID} ]
    );

    # fetch the result
    my %Queues;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $Queues{ $Row[0] } = $Row[1];
    }

    # store queues (in cache)
    $Kernel::OM->Get('Kernel::System::Cache')->Set(
        Type  => $Self->{CacheType},
        TTL   => $Self->{CacheTTL},
        Key   => $CacheKey,
        Value => \%Queues,
    );

    return %Queues;
}

=head2 QueueAutoResponseMemberList()

get queues associated to an auto response

    my %Queues = $QueueObject->QueueAutoResponseMemberList( AutoResponseID => 123 );

Returns:
    %Queues = (
        1 => 'Some Name',
        2 => 'Some Name',
    );

=cut

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

    # check needed stuff
    if ( !$Param{AutoResponseID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Got no AutoResponseID!',
        );
        return;
    }

    # get needed objects
    my $ValidObject = $Kernel::OM->Get('Kernel::System::Valid');
    my $DBObject    = $Kernel::OM->Get('Kernel::System::DB');

    # get queues
    my $SQL = "SELECT q.id, q.name "
        . " FROM queue q, queue_auto_response qar WHERE "
        . " qar.auto_response_id = ? AND "
        . " qar.queue_id = q.id AND "
        . " q.valid_id IN ( ${\(join ', ', $ValidObject->ValidIDsGet())} )"
        . " ORDER BY q.name";

    return if !$DBObject->Prepare(
        SQL => $SQL,
        Bind  => [ \$Param{AutoResponseID} ]
    );

    # fetch the result
    my %Queues;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $Queues{ $Row[0] } = $Row[1];
    }

    return %Queues;
}

# EO LightAdmin-AutoRepliesAndSignatures
1;
 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