OneTimeAuthentificationLink 11.0.4 Rother OSS GmbH https://otobo.io/ GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Updated to OTOBO 11.0.17. Update to OTOBO 11.0.8. Updated to OTOBO 11.0.6. Initial Release on OTOBO 11. Automatically creates customer users and gives them access via one time authentification tokens. 11.0.x 8df0d920482cb3b3dc1eeec75dd694dc886e5de4 2026-07-22 09:40:41 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 - ff9e297baf287e16071d3ac6ad7f6c13f11ac7fa - Kernel/System/CustomerAuth.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::CustomerAuth;

use strict;
use warnings;

use Kernel::Language qw(Translatable);

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::System::CustomerUser',
    'Kernel::System::DateTime',
    'Kernel::System::Log',
    'Kernel::System::Main',
    'Kernel::System::SystemMaintenance',
);

=head1 NAME

Kernel::System::CustomerAuth - customer authentication module.

=head1 DESCRIPTION

The authentication module for the customer interface.

=head1 PUBLIC INTERFACE

=head2 new()

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

    my $CustomerAuthObject = $Kernel::OM->Get('Kernel::System::CustomerAuth');

=cut

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

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

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

    # load auth modules
    COUNT:
    for my $Count ( '', 1 .. 10 ) {

        my $GenericModule = $ConfigObject->Get("Customer::AuthModule$Count");

        next COUNT if !$GenericModule;

        if ( !$MainObject->Require($GenericModule) ) {
            $MainObject->Die("Can't load backend module $GenericModule! $@");
        }

        $Self->{"AuthBackend$Count"} = $GenericModule->new( %{$Self}, Count => $Count );
    }

    # load 2factor auth modules
    COUNT:
    for my $Count ( '', 1 .. 10 ) {

        my $GenericModule = $ConfigObject->Get("Customer::AuthTwoFactorModule$Count");

        next COUNT if !$GenericModule;

        if ( !$MainObject->Require($GenericModule) ) {
            $MainObject->Die("Can't load backend module $GenericModule! $@");
        }

        $Self->{"AuthTwoFactorBackend$Count"} = $GenericModule->new( %{$Self}, Count => $Count );
    }

    # Initialize last error message
    $Self->{LastErrorMessage} = '';

    return $Self;
}

=head2 GetOption()

Get module options. Currently there is just one option, "PreAuth".

    if ( $AuthObject->GetOption( What => 'PreAuth' ) ) {
        print "No login screen is needed. Authentication is based on some other options. E. g. $ENV{REMOTE_USER}\n";
    }

=cut

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

    return $Self->{AuthBackend}->GetOption(%Param);
}

# Rother OSS / OneTimeAuthenticationLink

=for stopwords authentification

=head2 ExtendedParamNames()

Get names of extended params which provide authentification information

    my @ParamNames = $AuthObject->ExtendedParamNames();

=cut

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

    my %Names;
    COUNT:
    for ( '', 1 .. 10 ) {
        next COUNT if !$Self->{"AuthBackend$_"};
        next COUNT if !$Self->{"AuthBackend$_"}->can('ExtendedParamNames');

        for my $ExtName ( $Self->{"AuthBackend$_"}->ExtendedParamNames() ) {
            $Names{$ExtName} = 1;
        }
    }

    return ( keys %Names );
}
# EO OneTimeAuthenticationLink

=head2 Auth()

The authentication function.

    if ( $AuthObject->Auth( User => $User, Pw => $Pw ) ) {
        print "Auth ok!\n";
    }
    else {
        print "Auth invalid!\n";
    }

=cut

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

    # get customer user object
    my $CustomerUserObject = $Kernel::OM->Get('Kernel::System::CustomerUser');
    my $ConfigObject       = $Kernel::OM->Get('Kernel::Config');

    # use all 11 auth backends and return on first true
    my $User;
    COUNT:
    for my $Count ( '', 1 .. 10 ) {

        # next on no config setting
        next COUNT if !$Self->{"AuthBackend$Count"};

        # check auth backend
        $User = $Self->{"AuthBackend$Count"}->Auth(%Param);

# Rother OSS / OneTimeAuthenticationLink
        if ( ref $User && ref $User eq 'HASH' && $User->{Error} ) {
            $Self->{LastErrorMessage} = $User->{Error};
            return;
        }
# EO OneTimeAuthenticationLink

        # next on no success
        if ( !$User ) {

            # get error message of auth backend if present
            if ( $Self->{"AuthBackend$Count"}->{AuthError} ) {
                $Self->{LastErrorMessage} = $Self->{"AuthBackend$Count"}->{AuthError};
            }

            next COUNT;
        }

        # check 2factor auth backends
        my $TwoFactorAuth;
        TWOFACTORSOURCE:
        for my $Count ( '', 1 .. 10 ) {

            # return on no config setting
            next TWOFACTORSOURCE if !$Self->{"AuthTwoFactorBackend$Count"};

            # 2factor backend
            my $AuthOk = $Self->{"AuthTwoFactorBackend$Count"}->Auth(
                TwoFactorToken => $Param{TwoFactorToken},
                User           => $User,
            );
            $TwoFactorAuth = $AuthOk ? 'passed' : 'failed';

            last TWOFACTORSOURCE if $AuthOk;
        }

        # if at least one 2factor auth backend was checked but none was successful,
        # it counts as a failed login
        if ( $TwoFactorAuth && $TwoFactorAuth ne 'passed' ) {
            $User = undef;
            last COUNT;
        }

        # remember auth backend
        if ($User) {
            $CustomerUserObject->SetPreferences(
                Key    => 'UserAuthBackend',
                Value  => $Count,
                UserID => $User,
            );

            last COUNT;
        }
    }

    # check if record exists
    if ( !$User ) {
        my %CustomerData = $CustomerUserObject->CustomerUserDataGet( User => $Param{User} );
        if (%CustomerData) {
            my $Count = $CustomerData{UserLoginFailed} || 0;
            $Count++;
            $CustomerUserObject->SetPreferences(
                Key    => 'UserLoginFailed',
                Value  => $Count,
                UserID => $CustomerData{UserLogin},
            );
        }
        return;
    }

    # check if user is valid
    my %CustomerData = $CustomerUserObject->CustomerUserDataGet( User => $User );
    if ( defined $CustomerData{ValidID} && $CustomerData{ValidID} ne 1 ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'notice',
            Message  => "CustomerUser: '$User' is set to invalid, can't login!",
        );
        return;
    }

    return $User if !%CustomerData;

    # reset failed logins
    $CustomerUserObject->SetPreferences(
        Key    => 'UserLoginFailed',
        Value  => 0,
        UserID => $CustomerData{UserLogin},
    );

    # on system maintenance customers
    # shouldn't be allowed get into the system
    my $ActiveMaintenance = $Kernel::OM->Get('Kernel::System::SystemMaintenance')->SystemMaintenanceIsActive();

    # check if system maintenance is active
    if ($ActiveMaintenance) {

        $Self->{LastErrorMessage} =
            $ConfigObject->Get('SystemMaintenance::IsActiveDefaultLoginErrorMessage')
            || Translatable("It is currently not possible to login due to a scheduled system maintenance.");

        return;
    }

    # last login preferences update
    my $DateTimeObject = $Kernel::OM->Create('Kernel::System::DateTime');

    $CustomerUserObject->SetPreferences(
        Key    => 'UserLastLogin',
        Value  => $DateTimeObject->ToEpoch(),
        UserID => $CustomerData{UserLogin},
    );

    return $User;
}

=head2 PreAuth()

Call the PreAuth method of the AuthBackend

    my $PreAuthInfo = $AuthObject->PreAuth(
        RequestedURL => $RequestedURL,
    );

=cut

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

    return if !$Self->{AuthBackend}->can('PreAuth');

    return $Self->{AuthBackend}->PreAuth(%Param);
}

=head2 PostAuth()

Call the PostAuth method of the AuthBackend

    my $PostAuthInfo = $AuthObject->PostAuth();

=cut

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

    return if !$Self->{AuthBackend}->can('PostAuth');

    return $Self->{AuthBackend}->PostAuth(%Param);
}

=head2 Logout()

Call the Logout method of the AuthBackend

    my $LogoutInfo = $AuthObject->Logout();

=cut

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

    return if !$Self->{AuthBackend}->can('Logout');

    return $Self->{AuthBackend}->Logout(%Param);
}

=head2 GetLastErrorMessage()

Retrieve $Self->{LastErrorMessage} content.

    my $AuthErrorMessage = $AuthObject->GetLastErrorMessage();

    Result:

        $AuthErrorMessage = "An error string message.";

=cut

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

    return $Self->{LastErrorMessage};
}

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 - 8c7dfc2c7640699c8e02c0bab72813a4a7b8345a - Kernel/System/TemplateGenerator.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::TemplateGenerator;

## nofilter(TidyAll::Plugin::OTOBO::Perl::LayoutObject)

use v5.24;
use strict;
use warnings;

# core modules

# CPAN modules
use URI::Escape qw(uri_escape_utf8 uri_unescape);    ## no perlimports, methods are used in a substitution

# OTOBO modules
use Kernel::Language              ();
use Kernel::System::VariableCheck qw(:all);

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::System::AutoResponse',
    'Kernel::System::CommunicationChannel',
    'Kernel::System::CustomerUser',
# Rother OSS / OneTimeAuthenticationLink
    'Kernel::System::CustomerAuth::OneTimeAuthLink',
# EO OneTimeAuthenticationLink
    'Kernel::System::DynamicField',
    'Kernel::System::DynamicField::Backend',
    'Kernel::System::Encode',
    'Kernel::System::HTMLUtils',
    'Kernel::System::Log',
    'Kernel::System::Queue',
    'Kernel::System::Salutation',
    'Kernel::System::Signature',
    'Kernel::System::StandardTemplate',
    'Kernel::System::SystemAddress',
    'Kernel::System::Ticket',
    'Kernel::System::Ticket::Article',
    'Kernel::System::User',
    'Kernel::Output::HTML::Layout',
    'Kernel::System::DateTime',
);

=head1 NAME

Kernel::System::TemplateGenerator - template generator lib

=head1 DESCRIPTION

All template generator functions.

=head1 PUBLIC INTERFACE

=head2 new()

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

    my $TemplateGeneratorObject = $Kernel::OM->Get('Kernel::System::TemplateGenerator');

=cut

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

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

    $Self->{RichText} = $Kernel::OM->Get('Kernel::Config')->Get('Frontend::RichText');

    return $Self;
}

=head2 Salutation()

generate salutation

    my $Salutation = $TemplateGeneratorObject->Salutation(
        TicketID => 123,
        UserID   => 123,
        Data     => $ArticleHashRef,
    );

returns
    Text
    ContentType

=cut

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

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

    # Get ticket.
    my %Ticket = $Kernel::OM->Get('Kernel::System::Ticket')->TicketGet(
        TicketID      => $Param{TicketID},
        DynamicFields => 1,
    );

    # Get queue.
    my %Queue = $Kernel::OM->Get('Kernel::System::Queue')->QueueGet(
        ID => $Ticket{QueueID},
    );

    # Get salutation.
    my %Salutation = $Kernel::OM->Get('Kernel::System::Salutation')->SalutationGet(
        ID => $Queue{SalutationID},
    );

    # do text/plain to text/html convert
    if ( $Self->{RichText} && $Salutation{ContentType} =~ /text\/plain/i ) {
        $Salutation{ContentType} = 'text/html';
        $Salutation{Text}        = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML(
            String => $Salutation{Text},
        );
    }

    # do text/html to text/plain convert
    if ( !$Self->{RichText} && $Salutation{ContentType} =~ /text\/html/i ) {
        $Salutation{ContentType} = 'text/plain';
        $Salutation{Text}        = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToAscii(
            String => $Salutation{Text},
        );
    }

    # get list unsupported tags for standard template
    my @ListOfUnSupportedTag = qw(OTOBO_AGENT_SUBJECT OTOBO_AGENT_BODY OTOBO_CUSTOMER_BODY OTOBO_CUSTOMER_SUBJECT);

    my $SalutationText = $Self->_RemoveUnSupportedTag(
        Text                 => $Salutation{Text} || '',
        ListOfUnSupportedTag => \@ListOfUnSupportedTag,
    );

    # replace place holder stuff
    $SalutationText = $Self->_Replace(
        RichText   => $Self->{RichText},
        Text       => $SalutationText,
        TicketData => \%Ticket,
        Data       => $Param{Data},
        UserID     => $Param{UserID},
    );

    # add urls
    if ( $Self->{RichText} ) {
        $SalutationText = $Kernel::OM->Get('Kernel::System::HTMLUtils')->LinkQuote(
            String => $SalutationText,
        );
    }

    return $SalutationText;
}

=head2 Signature()

generate salutation

    my $Signature = $TemplateGeneratorObject->Signature(
        TicketID => 123,
        UserID   => 123,
        Data     => $ArticleHashRef,
    );

or

    my $Signature = $TemplateGeneratorObject->Signature(
        QueueID => 123,
        UserID  => 123,
        Data    => $ArticleHashRef,
    );

returns
    Text
    ContentType

=cut

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

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

            return;
        }
    }

    # need ticket id or queue id
    if ( !$Param{TicketID} && !$Param{QueueID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need TicketID or QueueID!'
        );
        return;
    }

    # Get ticket data.
    my %Ticket;
    if ( $Param{TicketID} ) {
        %Ticket = $Kernel::OM->Get('Kernel::System::Ticket')->TicketGet(
            TicketID      => $Param{TicketID},
            DynamicFields => 1,
        );
    }

    # Get queue.
    my %Queue = $Kernel::OM->Get('Kernel::System::Queue')->QueueGet(
        ID => $Ticket{QueueID} || $Param{QueueID},
    );

    # Get signature.
    my %Signature = $Kernel::OM->Get('Kernel::System::Signature')->SignatureGet(
        ID => $Queue{SignatureID},
    );

    # do text/plain to text/html convert
    if ( $Self->{RichText} && $Signature{ContentType} =~ /text\/plain/i ) {
        $Signature{ContentType} = 'text/html';
        $Signature{Text}        = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML(
            String => $Signature{Text},
        );
    }

    # do text/html to text/plain convert
    if ( !$Self->{RichText} && $Signature{ContentType} =~ /text\/html/i ) {
        $Signature{ContentType} = 'text/plain';
        $Signature{Text}        = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToAscii(
            String => $Signature{Text},
        );
    }

    # get list unsupported tags for standard template
    my @ListOfUnSupportedTag = qw(OTOBO_AGENT_SUBJECT OTOBO_AGENT_BODY OTOBO_CUSTOMER_BODY OTOBO_CUSTOMER_SUBJECT);

    my $SignatureText = $Self->_RemoveUnSupportedTag(
        Text                 => $Signature{Text} || '',
        ListOfUnSupportedTag => \@ListOfUnSupportedTag,
    );

    # replace place holder stuff
    $SignatureText = $Self->_Replace(
        RichText   => $Self->{RichText},
        Text       => $SignatureText,
        TicketData => \%Ticket,
        Data       => $Param{Data},
        QueueID    => $Param{QueueID},
        UserID     => $Param{UserID},
    );

    # add urls
    if ( $Self->{RichText} ) {
        $SignatureText = $Kernel::OM->Get('Kernel::System::HTMLUtils')->LinkQuote(
            String => $SignatureText,
        );
    }

    return $SignatureText;
}

=head2 Sender()

generate sender address (FROM string) for emails

    my $Sender = $TemplateGeneratorObject->Sender(
        QueueID => 123,
        UserID  => 123,
    );

returns:

    John Doe at Super Support <service@example.com>

and it returns the quoted real name if necessary

    "John Doe, Support" <service@example.tld>

=cut

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

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

            return;
        }
    }

    # get sender attributes
    my %Address = $Kernel::OM->Get('Kernel::System::Queue')->GetSystemAddress(
        QueueID => $Param{QueueID},
    );

    # get config object
    my $ConfigObject = $Kernel::OM->Get('Kernel::Config');

    # check config for agent real name
    my $UseAgentRealName = $ConfigObject->Get('Ticket::DefineEmailFrom');
    if ( $UseAgentRealName && $UseAgentRealName =~ /^(AgentName|AgentNameSystemAddressName)$/ ) {

        # get data from current agent
        my %UserData = $Kernel::OM->Get('Kernel::System::User')->GetUserData(
            UserID        => $Param{UserID},
            NoOutOfOffice => 1,
        );

        # set real name with user name
        if ( $UseAgentRealName eq 'AgentName' ) {

            # check for user data
            if ( $UserData{UserFullname} ) {

                # rewrite RealName
                $Address{RealName} = "$UserData{UserFullname}";
            }
        }

        # set real name with user name
        if ( $UseAgentRealName eq 'AgentNameSystemAddressName' ) {

            # check for user data
            if ( $UserData{UserFullname} ) {

                # rewrite RealName
                my $Separator = ' ' . $ConfigObject->Get('Ticket::DefineEmailFromSeparator')
                    || '';
                $Address{RealName} = $UserData{UserFullname} . $Separator . ' ' . $Address{RealName};
            }
        }
    }

    # Format sender real name and address compliant to RFC 5322. This is relevant when the real name contain commas
    # or other special symbols.
    return Mail::Address->new( $Address{RealName}, $Address{Email} )->format();
}

=head2 Template()

generate template

    my $Template = $TemplateGeneratorObject->Template(
        TemplateID => 123,
        TicketID   => 123,                  # Optional
        Data       => $ArticleHashRef,      # Optional
        UserID     => 123,
    );

Returns:

    $Template = 'Some text';

=cut

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

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

            return;
        }
    }

    my $StandardTemplateObject = $Kernel::OM->Get('Kernel::System::StandardTemplate');

    my %Template = $StandardTemplateObject->StandardTemplateGet(
        ID => $Param{TemplateID},
    );

    # do text/plain to text/html convert
    if (
        $Self->{RichText}
        && $Template{ContentType} =~ /text\/plain/i
        && $Template{Template}
        )
    {
        $Template{ContentType} = 'text/html';
        $Template{Template}    = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML(
            String => $Template{Template},
        );
    }

    # do text/html to text/plain convert
    if (
        !$Self->{RichText}
        && $Template{ContentType} =~ /text\/html/i
        && $Template{Template}
        )
    {
        $Template{ContentType} = 'text/plain';
        $Template{Template}    = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToAscii(
            String => $Template{Template},
        );
    }

    # Get user language.
    my $Language;
    my %Ticket;
    if ( defined $Param{TicketID} ) {

        # Get ticket data.
        %Ticket = $Kernel::OM->Get('Kernel::System::Ticket')->TicketGet(
            TicketID      => $Param{TicketID},
            DynamicFields => 1,
        );

        # Get recipient.
        my %User = $Kernel::OM->Get('Kernel::System::CustomerUser')->CustomerUserDataGet(
            User => $Ticket{CustomerUserID},
        );
        $Language = $User{UserLanguage};
    }

    # If template type is 'Create' and there is customer user information, treat it as a ticket param in order to
    # correctly replace customer user tags. See bug#14455.
    if ( $Template{TemplateType} eq 'Create' && $Param{CustomerUserID} ) {
        $Ticket{CustomerUserID} = $Param{CustomerUserID};
    }

    # if customer language is not defined, set default language
    $Language //= $Kernel::OM->Get('Kernel::Config')->Get('DefaultLanguage') || 'en';

    # get list unsupported tags for standard template
    my @ListOfUnSupportedTag = qw(OTOBO_AGENT_SUBJECT OTOBO_AGENT_BODY OTOBO_CUSTOMER_BODY OTOBO_CUSTOMER_SUBJECT);

    my %SupportedTypes = (
        Answer  => 1,
        Forward => 1,
        Note    => 1,
    );

    my $TemplateText = $Template{Template} || '';
    my $TemplateType = $Template{TemplateType};

    # Remove unsupported tags only for some template types.
    if ( !$SupportedTypes{ $Template{TemplateType} } ) {
        $TemplateText = $Self->_RemoveUnSupportedTag(
            Text                 => $Template{Template} || '',
            ListOfUnSupportedTag => \@ListOfUnSupportedTag,
        );

        # Reset template type for unsupported tag.
        $TemplateType = '';
    }

    # replace place holder stuff
    $TemplateText = $Self->_Replace(
        RichText   => $Self->{RichText},
        Text       => $TemplateText || '',
        TicketData => \%Ticket,
        Data       => $Param{Data} || {},
        UserID     => $Param{UserID},
        Language   => $Language,
        Template   => $TemplateType,
    );

    if ( $Self->{RichText} ) {
        $TemplateText =~ s/&lt;/</g;
        $TemplateText =~ s/&gt;/>/g;
        $TemplateText =~ s/&quot;/"/g;
        $TemplateText =~ s/&apos;/'/g;
        $TemplateText =~ s/&nbsp;/ /g;
    }

    return $TemplateText;
}

=head2 GenericAgentArticle()

generate internal or external notes

    my $GenericAgentArticle = $TemplateGeneratorObject->GenericAgentArticle(
        Notification => $NotificationDataHashRef,
        TicketID     => 123,
        UserID       => 123,
        Data         => $ArticleHashRef,             # Optional
    );

=cut

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

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

    my %Template = %{ $Param{Notification} };

    # get ticket object
    my $TicketObject = $Kernel::OM->Get('Kernel::System::Ticket');

    # Get ticket data.
    my %Ticket = $TicketObject->TicketGet(
        TicketID      => $Param{TicketID},
        DynamicFields => 1,
    );

    # do text/plain to text/html convert
    if (
        $Self->{RichText}
        && $Template{ContentType} =~ /text\/plain/i
        && $Template{Body}
        )
    {
        $Template{ContentType} = 'text/html';
        $Template{Body}        = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML(
            String => $Template{Body},
        );
    }

    # do text/html to text/plain convert
    if (
        !$Self->{RichText}
        && $Template{ContentType} =~ /text\/html/i
        && $Template{Body}
        )
    {
        $Template{ContentType} = 'text/plain';
        $Template{Body}        = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToAscii(
            String => $Template{Body},
        );
    }

    # replace place holder stuff
    $Template{Body} = $Self->_Replace(
        RichText   => $Self->{RichText},
        Text       => $Template{Body},
        Recipient  => $Param{Recipient},
        Data       => $Param{Data} || {},
        TicketData => \%Ticket,
        UserID     => $Param{UserID},
    );
    $Template{Subject} = $Self->_Replace(
        RichText   => 0,
        Text       => $Template{Subject},
        Recipient  => $Param{Recipient},
        Data       => $Param{Data} || {},
        TicketData => \%Ticket,
        UserID     => $Param{UserID},
    );

    $Template{Subject} = $TicketObject->TicketSubjectBuild(
        TicketNumber => $Ticket{TicketNumber},
        Subject      => $Template{Subject} || '',
        Type         => 'New',
    );

    # add URLs and verify to be full HTML document
    if ( $Self->{RichText} ) {

        $Template{Body} = $Kernel::OM->Get('Kernel::System::HTMLUtils')->LinkQuote(
            String => $Template{Body},
        );
    }

    return %Template;
}

=head2 Attributes()

modifies inplace the passed in C<Data> hash reference and returns the enriched data.

    my %Data = (
        Subject => 'What do you want to talk about?'
    );

    my %EnrichedData = $TemplateGeneratoObject->Attributes(
        TicketID   => 123,
        Data       => \%Data,    # $Data{Subject} is used as input for finding the new subject
        UserID     => 123,
        Action     => 'Forward', # Relevant for the subject.
                                 # Possible values are 'Reply' and 'Forward', 'Reply' is eventually the default.
    );

Returns the modified hash reference as key value pairs. The potentially added or changed item are:

=over 4

=item Subject

=item From

=back

=cut

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

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

            return;
        }
    }

    # get ticket object
    my $TicketObject = $Kernel::OM->Get('Kernel::System::Ticket');

    # get ticket data, including the queue id
    my %Ticket = $TicketObject->TicketGet(
        TicketID      => $Param{TicketID},
        DynamicFields => 0,
    );

    # prepare subject ...
    $Param{Data}->{Subject} = $TicketObject->TicketSubjectBuild(
        TicketNumber => $Ticket{TicketNumber},
        Subject      => $Param{Data}->{Subject} || '',
        Action       => $Param{Action}          || '',    # TicketSubjectBuild() falls back to the default 'Reply'
    );

    # get sender address
    $Param{Data}->{From} = $Self->Sender(
        QueueID => $Ticket{QueueID},
        UserID  => $Param{UserID},
    );

    return $Param{Data}->%*;
}

=head2 AutoResponse()

generate response

AutoResponse
    TicketID
        Owner
        Responsible
        CUSTOMER_DATA
    ArticleID
        CUSTOMER_SUBJECT
        CUSTOMER_EMAIL
    UserID

    To
    Cc
    Bcc
    Subject
    Body
    ContentType

    my %AutoResponse = $TemplateGeneratorObject->AutoResponse(
        TicketID         => 123,
        OrigHeader       => {},
        AutoResponseType => 'auto reply',
        UserID           => 123,
    );

=cut

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

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

            return;
        }
    }

    # get ticket object
    my $TicketObject = $Kernel::OM->Get('Kernel::System::Ticket');

    # Get ticket data.
    my %Ticket = $TicketObject->TicketGet(
        TicketID      => $Param{TicketID},
        DynamicFields => 1,
    );

    # get auto default responses
    my %AutoResponse = $Kernel::OM->Get('Kernel::System::AutoResponse')->AutoResponseGetByTypeQueueID(
        QueueID => $Ticket{QueueID},
        Type    => $Param{AutoResponseType},
    );

    return if !%AutoResponse;

    # get old article for quoting
    my $ArticleObject = $Kernel::OM->Get('Kernel::System::Ticket::Article');
    my @ArticleList   = $ArticleObject->ArticleList(
        TicketID   => $Param{TicketID},
        SenderType => 'customer',
        OnlyLast   => 1,
    );

    if ( !@ArticleList ) {
        @ArticleList = $ArticleObject->ArticleList(
            TicketID             => $Param{TicketID},
            IsVisibleForCustomer => 1,
            OnlyLast             => 1,
        );
    }

    if (@ArticleList) {
        my %Article = $ArticleObject->BackendForArticle( %{ $ArticleList[0] } )->ArticleGet( %{ $ArticleList[0] } );

        for my $Key (qw(From To Cc Subject Body)) {
            if ( !$Param{OrigHeader}->{$Key} ) {
                $Param{OrigHeader}->{$Key} = $Article{$Key} || '';
            }
            chomp $Param{OrigHeader}->{$Key};
        }
    }

    # format body (only if longer than 86 chars)
    if ( $Param{OrigHeader}->{Body} ) {
        if ( length $Param{OrigHeader}->{Body} > 86 ) {
            my @Lines = split /\n/, $Param{OrigHeader}->{Body};
            LINE:
            for my $Line (@Lines) {
                my $LineWrapped = $Line =~ s/(^>.+|.{4,86})(?:\s|\z)/$1\n/gm;

                next LINE if $LineWrapped;

                # if the regex does not match then we need
                # to add the missing new line of the split
                # else we will lose e.g. empty lines of the body.
                # (bug#10679)
                $Line .= "\n";
            }
            $Param{OrigHeader}->{Body} = join '', @Lines;
        }
    }

    # fill up required attributes
    for my $Key (qw(Subject Body)) {
        if ( !$Param{OrigHeader}->{$Key} ) {
            $Param{OrigHeader}->{$Key} = "No $Key";
        }
    }

    # get recipient
    my %User = $Kernel::OM->Get('Kernel::System::CustomerUser')->CustomerUserDataGet(
        User => $Ticket{CustomerUserID},
    );

    # get user language
    my $Language = $User{UserLanguage} || $Kernel::OM->Get('Kernel::Config')->Get('DefaultLanguage') || 'en';

    # do text/plain to text/html convert
    if ( $Self->{RichText} && $AutoResponse{ContentType} =~ /text\/plain/i ) {
        $AutoResponse{ContentType} = 'text/html';
        $AutoResponse{Text}        = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML(
            String => $AutoResponse{Text},
        );
    }

    # do text/html to text/plain convert
    if ( !$Self->{RichText} && $AutoResponse{ContentType} =~ /text\/html/i ) {
        $AutoResponse{ContentType} = 'text/plain';
        $AutoResponse{Text}        = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToAscii(
            String => $AutoResponse{Text},
        );
    }

    # replace place holder stuff
    $AutoResponse{Text} = $Self->_Replace(
        RichText => $Self->{RichText},
        Text     => $AutoResponse{Text},
        Data     => {
            %{ $Param{OrigHeader} },
            From => $Param{OrigHeader}->{To},
            To   => $Param{OrigHeader}->{From},
        },
        TicketData      => \%Ticket,
        UserID          => $Param{UserID},
        Language        => $Language,
        AddTimezoneInfo => {
            AutoResponse => 1,
        },
    );
    $AutoResponse{Subject} = $Self->_Replace(
        RichText => 0,
        Text     => $AutoResponse{Subject},
        Data     => {
            %{ $Param{OrigHeader} },
            From => $Param{OrigHeader}->{To},
            To   => $Param{OrigHeader}->{From},
        },
        TicketData      => \%Ticket,
        UserID          => $Param{UserID},
        Language        => $Language,
        AddTimezoneInfo => {
            AutoResponse => 1,
        },
    );

    $AutoResponse{Subject} = $TicketObject->TicketSubjectBuild(
        TicketNumber => $Ticket{TicketNumber},
        Subject      => $AutoResponse{Subject},
        Type         => 'New',
        NoCleanup    => 1,
    );

    # get sender attributes based on auto response type
    if ( $AutoResponse{SystemAddressID} ) {

        my %Address = $Kernel::OM->Get('Kernel::System::SystemAddress')->SystemAddressGet(
            ID => $AutoResponse{SystemAddressID},
        );

        $AutoResponse{SenderAddress}  = $Address{Name};
        $AutoResponse{SenderRealname} = $Address{Realname};    # note that SystemAddress() does not capitalize the 'n'
    }

    # get sender attributes based on queue
    else {

        my %Address = $Kernel::OM->Get('Kernel::System::Queue')->GetSystemAddress(
            QueueID => $Ticket{QueueID},
        );

        $AutoResponse{SenderAddress}  = $Address{Email};
        $AutoResponse{SenderRealname} = $Address{RealName};
    }

    # add urls and verify to be full html document
    if ( $Self->{RichText} ) {

        $AutoResponse{Text} = $Kernel::OM->Get('Kernel::System::HTMLUtils')->LinkQuote(
            String => $AutoResponse{Text},
        );

        $AutoResponse{Text} = $Kernel::OM->Get('Kernel::System::HTMLUtils')->DocumentComplete(
            String => $AutoResponse{Text},
        );
    }

    return %AutoResponse;
}

=head2 NotificationEvent()

replace all OTOBO smart tags in the notification body and subject

    my %NotificationEvent = $TemplateGeneratorObject->NotificationEvent(
        TicketData            => $TicketDataHashRef,
        Recipient             => $UserDataHashRef,          # Agent or Customer data get result
        Notification          => $NotificationDataHashRef,
        CustomerMessageParams => $ArticleHashRef,           # optional
        UserID                => 123,
    );

=cut

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

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

    if ( !IsHashRefWithData( $Param{Notification} ) ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Notification is invalid!",
        );
        return;
    }

    my %Notification = %{ $Param{Notification} };

    # exchanging original reference prevent it to grow up
    if ( ref $Param{CustomerMessageParams} && ref $Param{CustomerMessageParams} eq 'HASH' ) {
        my %LocalCustomerMessageParams = %{ $Param{CustomerMessageParams} };
        $Param{CustomerMessageParams} = \%LocalCustomerMessageParams;
    }

    my $ArticleObject = $Kernel::OM->Get('Kernel::System::Ticket::Article');

    # Get last article from customer.
    my @CustomerArticles = $ArticleObject->ArticleList(
        TicketID   => $Param{TicketData}->{TicketID},
        SenderType => 'customer',
        OnlyLast   => 1,
    );

    my %CustomerArticle;

    ARTICLE:
    for my $Article (@CustomerArticles) {
        next ARTICLE if !$Article->{ArticleID};

        %CustomerArticle = $ArticleObject->BackendForArticle( %{$Article} )->ArticleGet(
            %{$Article},
            DynamicFields => 0,
        );
    }

    # Get last article from agent.
    my @AgentArticles = $ArticleObject->ArticleList(
        TicketID   => $Param{TicketData}->{TicketID},
        SenderType => 'agent',
        OnlyLast   => 1,
    );

    my %AgentArticle;

    AGENTARTICLE:
    for my $Article (@AgentArticles) {
        next AGENTARTICLE if !$Article->{ArticleID};

        %AgentArticle = $ArticleObject->BackendForArticle( %{$Article} )->ArticleGet(
            %{$Article},
            DynamicFields => 0,
        );

        # Include the transmission status, if article is an email.
        my %CommunicationChannel = $Kernel::OM->Get('Kernel::System::CommunicationChannel')->ChannelGet(
            ChannelID => $Article->{CommunicationChannelID},
        );
        if ( $CommunicationChannel{ChannelName} eq 'Email' ) {
            my $TransmissionStatus = $ArticleObject->BackendForArticle( %{$Article} )->ArticleTransmissionStatus(
                ArticleID => $Article->{ArticleID},
            );
            if ( $TransmissionStatus && $TransmissionStatus->{Message} ) {
                $AgentArticle{TransmissionStatusMessage} = $TransmissionStatus->{Message};
            }
        }
    }

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

    ARTICLE:
    for my $ArticleData ( \%CustomerArticle, \%AgentArticle ) {
        next ARTICLE if !$ArticleData->{TicketID};
        next ARTICLE if !$ArticleData->{ArticleID};

        # Get article preview in plain text and store it as Body key.
        $ArticleData->{Body} = $LayoutObject->ArticlePreview(
            TicketID   => $ArticleData->{TicketID},
            ArticleID  => $ArticleData->{ArticleID},
            ResultType => 'plain',
            UserID     => $Param{UserID},
        );

        # get accounted time
        my $AccountedTime = $ArticleObject->ArticleAccountedTimeGet(
            ArticleID => $ArticleData->{ArticleID},
        );

        # set the accounted time as part of the articles information
        $ArticleData->{TimeUnit} = $AccountedTime;
    }

    # Populate the hash 'CustomerMessageParams' with all the customer-article data
    # and overwrite it with 'CustomerMessageParams' passed in the Params (bug #13325).
    $Param{CustomerMessageParams} = {
        %CustomerArticle,
        %{ $Param{CustomerMessageParams} || {} },
    };

    # get system default language
    my $DefaultLanguage = $Kernel::OM->Get('Kernel::Config')->Get('DefaultLanguage') || 'en';

    my $Languages = [ $Param{Recipient}->{UserLanguage}, $DefaultLanguage, 'en' ];

    my $Language;
    LANGUAGE:
    for my $Item ( @{$Languages} ) {
        next LANGUAGE if !$Item;
        next LANGUAGE if !$Notification{Message}->{$Item};

        # set language
        $Language = $Item;
        last LANGUAGE;
    }

    # if no language, then take the first one available
    if ( !$Language ) {
        my @NotificationLanguages = sort keys %{ $Notification{Message} };
        $Language = $NotificationLanguages[0];
    }

    # copy the correct language message attributes to a flat structure
    for my $Attribute (qw(Subject Body ContentType)) {
        $Notification{$Attribute} = $Notification{Message}->{$Language}->{$Attribute};
    }

    # Get customer article fields.
    my %CustomerArticleFields;

    if (%CustomerArticle) {
        %CustomerArticleFields = $LayoutObject->ArticleFields(
            TicketID  => $CustomerArticle{TicketID},
            ArticleID => $CustomerArticle{ArticleID},
            UserID    => $Param{UserID},
        );
    }

    ARTICLE_FIELD:
    for my $ArticleField ( sort keys %CustomerArticleFields ) {
        next ARTICLE_FIELD if !defined $CustomerArticleFields{$ArticleField}->{Value};

        if ( !defined $Param{CustomerMessageParams}->{$ArticleField} ) {
            $Param{CustomerMessageParams}->{$ArticleField} = $CustomerArticleFields{$ArticleField}->{Value};
        }
        chomp $Param{CustomerMessageParams}->{$ArticleField};
    }

    # format body (only if longer the 86 chars)
    if ( $Param{CustomerMessageParams}->{Body} ) {
        if ( length $Param{CustomerMessageParams}->{Body} > 86 ) {
            my @Lines = split /\n/, $Param{CustomerMessageParams}->{Body};
            LINE:
            for my $Line (@Lines) {
                my $LineWrapped = $Line =~ s/(^>.+|.{4,86})(?:\s|\z)/$1\n/gm;

                next LINE if $LineWrapped;

                # if the regex does not match then we need
                # to add the missing new line of the split
                # else we will lose e.g. empty lines of the body.
                # (bug#10679)
                $Line .= "\n";
            }
            $Param{CustomerMessageParams}->{Body} = join '', @Lines;
        }
    }

    # fill up required attributes
    for my $Text (qw(Subject Body)) {
        if ( !$Param{CustomerMessageParams}->{$Text} ) {

            # Set to last customer article attribute if it is empty string.
            # For example, if Body is empty string (not undef!), it is maybe sent from NotificationOwnerUpdate event
            # and overrides last customer article body (in %CustomerArticle) above - see bug#14678.
            $Param{CustomerMessageParams}->{$Text} = $CustomerArticle{$Text} || "No $Text";
        }
    }

    my $Start = '<';
    my $End   = '>';
    if ( $Notification{ContentType} =~ m{text\/html} ) {
        $Start = '&lt;';
        $End   = '&gt;';
    }

    # replace <OTOBO_CUSTOMER_DATA_*> tags early from CustomerMessageParams, the rests will be replaced
    # by ticket customer user
    KEY:
    for my $Key ( sort keys %{ $Param{CustomerMessageParams} || {} } ) {

        next KEY if !$Param{CustomerMessageParams}->{$Key};

        $Notification{Body}    =~ s/${Start}OTOBO_CUSTOMER_DATA_$Key${End}/$Param{CustomerMessageParams}->{$Key}/gi;
        $Notification{Subject} =~ s/<OTOBO_CUSTOMER_DATA_$Key>/$Param{CustomerMessageParams}->{$Key}{$Key}/gi;
    }

    # do text/plain to text/html convert
    if ( $Self->{RichText} && $Notification{ContentType} =~ /text\/plain/i ) {
        $Notification{ContentType} = 'text/html';
        $Notification{Body}        = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML(
            String => $Notification{Body},
        );
    }

    # do text/html to text/plain convert
    if ( !$Self->{RichText} && $Notification{ContentType} =~ /text\/html/i ) {
        $Notification{ContentType} = 'text/plain';
        $Notification{Body}        = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToAscii(
            String => $Notification{Body},
        );
    }

    # get notify texts
    for my $Text (qw(Subject Body)) {
        if ( !$Notification{$Text} ) {
            $Notification{$Text} = "No Notification $Text for $Param{Type} found!";
        }
    }

    # replace place holder stuff
    $Notification{Body} = $Self->_Replace(
        RichText        => $Self->{RichText},
        Text            => $Notification{Body},
        Recipient       => $Param{Recipient},
        Data            => $Param{CustomerMessageParams},
        DataAgent       => \%AgentArticle,
        TicketData      => $Param{TicketData},
        UserID          => $Param{UserID},
        Language        => $Language,
        AddTimezoneInfo => {
            NotificationEvent => 1,
        },
    );

    $Notification{Subject} = $Self->_Replace(
        RichText        => 0,
        Text            => $Notification{Subject},
        Recipient       => $Param{Recipient},
        Data            => $Param{CustomerMessageParams},
        DataAgent       => \%AgentArticle,
        TicketData      => $Param{TicketData},
        UserID          => $Param{UserID},
        Language        => $Language,
        AddTimezoneInfo => {
            NotificationEvent => 1,
        },
    );

    # Keep the "original" (unmodified) subject and body for later use.
    $Notification{OriginalSubject} = $Notification{Subject};
    $Notification{OriginalBody}    = $Notification{Body};

    $Notification{Subject} = $Kernel::OM->Get('Kernel::System::Ticket')->TicketSubjectBuild(
        TicketNumber => $Param{TicketData}->{TicketNumber},
        Subject      => $Notification{Subject} || '',
        Type         => 'New',
    );

    # add URLs and verify to be full HTML document
    if ( $Self->{RichText} ) {

        $Notification{Body} = $Kernel::OM->Get('Kernel::System::HTMLUtils')->LinkQuote(
            String => $Notification{Body},
        );
    }

    return %Notification;
}

=begin Internal:

=head2 _Replace()

replace the placeholders in the text

=cut

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

    # check needed stuff
    for (qw(Text RichText Data UserID)) {
        if ( !defined $Param{$_} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $_!"
            );

            return;
        }
    }

    # check for mailto links
    # since the subject and body of those mailto links are
    # uri escaped we have to uri unescape them, replace
    # possible placeholders and then re-uri escape them
    $Param{Text} =~ s{
        (href="mailto:[^\?]+\?)([^"]+")
    }
    {
        my $MailToHref        = $1;
        my $MailToHrefContent = $2;

        # Nested s///egx!
        $MailToHrefContent =~ s{
            ((?:subject|body)=)(.+?)("|&)
        }
        {
            my $SubjectOrBodyPrefix  = $1;
            my $SubjectOrBodyContent = $2;
            my $SubjectOrBodySuffix  = $3;

            my $SubjectOrBodyContentUnescaped = uri_unescape($SubjectOrBodyContent);

            my $SubjectOrBodyContentReplaced = $Self->_Replace(
                %Param,
                Text     => $SubjectOrBodyContentUnescaped,
                RichText => 0,
            );

            my $SubjectOrBodyContentEscaped = uri_escape_utf8($SubjectOrBodyContentReplaced);

            $SubjectOrBodyPrefix . $SubjectOrBodyContentEscaped . $SubjectOrBodySuffix;
        }egx;

        $MailToHref . $MailToHrefContent;
    }egx;

    my ( $Start, $End ) = ( '<', '>' );
    if ( $Param{RichText} ) {
        ( $Start, $End ) = ( '&lt;', '&gt;' );
        $Param{Text} =~ s/(\n|\r)//g;
    }

    my %Ticket;
    if ( $Param{TicketData} ) {
        %Ticket = $Param{TicketData}->%*;
    }

    my $CustomerUserObject = $Kernel::OM->Get('Kernel::System::CustomerUser');

    # Determine recipient's timezone if needed.
    my $RecipientTimeZone;
    if ( $Param{AddTimezoneInfo} ) {
        $RecipientTimeZone = $Kernel::OM->Create('Kernel::System::DateTime')->OTOBOTimeZoneGet();

        my %CustomerUser;
        if ( IsHashRefWithData( \%Ticket ) && $Ticket{CustomerUserID} ) {
            %CustomerUser = $CustomerUserObject->CustomerUserDataGet( User => $Ticket{CustomerUserID} );
        }

        my %UserPreferences;

        if ( $Param{AddTimezoneInfo}->{NotificationEvent} && $Param{Recipient}->{Type} eq 'Agent' ) {
            %UserPreferences = $Kernel::OM->Get('Kernel::System::User')->GetPreferences(
                UserID => $Param{Recipient}->{UserID},
            );
        }
        elsif (
            $Param{AddTimezoneInfo}->{NotificationEvent}
            && $Param{Recipient}->{Type} eq 'Customer'
            && $Param{Recipient}->{UserID}
            )
        {
            %UserPreferences = $CustomerUserObject->GetPreferences(
                UserID => $Param{Recipient}->{UserID},
            );
        }
        elsif (
            $Param{AddTimezoneInfo}->{AutoResponse}
            && $Ticket{CustomerUserID}
            && IsHashRefWithData( \%CustomerUser )
            )
        {
            %UserPreferences = $CustomerUserObject->GetPreferences(
                UserID => $Ticket{CustomerUserID},
            );
        }

        if ( $UserPreferences{UserTimeZone} ) {
            $RecipientTimeZone = $UserPreferences{UserTimeZone};
        }
    }

    # Replace Unix time format tags.
    # If language is defined, they will be converted into a correct format in below IF statement.
    for my $UnixFormatTime (
        qw(RealTillTimeNotUsed EscalationResponseTime EscalationUpdateTime EscalationSolutionTime)
        )
    {
        if ( $Ticket{$UnixFormatTime} ) {
            $Ticket{$UnixFormatTime} = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    Epoch => $Ticket{$UnixFormatTime},
                },
            )->ToString();
        }
    }

    # translate ticket values if needed
    if ( $Param{Language} ) {

        my $LanguageObject = Kernel::Language->new(
            UserLanguage => $Param{Language},
        );

        # Translate the different values.
        for my $Field (qw(Type State StateType Lock Priority)) {
            $Ticket{$Field} = $LanguageObject->Translate( $Ticket{$Field} );
        }

        # Transform the date values from the ticket data (but not the dynamic field values).
        ATTRIBUTE:
        for my $Attribute ( sort keys %Ticket ) {
            next ATTRIBUTE if $Attribute =~ m{ \A DynamicField_ }xms;
            next ATTRIBUTE if !$Ticket{$Attribute};

            if ( $Ticket{$Attribute} =~ m{\A(\d\d\d\d)-(\d\d)-(\d\d)\s(\d\d):(\d\d):(\d\d)\z}xi ) {

                # Change time to recipient's timezone if needed
                # and later append timezone information.
                # For more information,
                # see bug#13865 (https://bugs.otrs.org/show_bug.cgi?id=13865)
                # and bug#14270 (https://bugs.otrs.org/show_bug.cgi?id=14270).
                if ($RecipientTimeZone) {
                    my $DateTimeObject = $Kernel::OM->Create(
                        'Kernel::System::DateTime',
                        ObjectParams => {
                            String => $Ticket{$Attribute},
                        },
                    );
                    $DateTimeObject->ToTimeZone( TimeZone => $RecipientTimeZone );
                    $Ticket{$Attribute} = $DateTimeObject->ToString();
                }

                $Ticket{$Attribute} = $LanguageObject->FormatTimeString(
                    $Ticket{$Attribute},
                    'DateFormat',
                    'NoSeconds',
                );

                # Append timezone information if needed.
                if ($RecipientTimeZone) {
                    $Ticket{$Attribute} .= " ($RecipientTimeZone)";
                }
            }
        }

        my $LocalLayoutObject = Kernel::Output::HTML::Layout->new(
            Lang => $Param{Language},
        );

        # Convert tags in seconds to more readable appropriate format if language is defined.
        for my $TimeInSeconds (
            qw(UntilTime EscalationTimeWorkingTime EscalationTime FirstResponseTimeWorkingTime FirstResponseTime UpdateTimeWorkingTime
            UpdateTime SolutionTimeWorkingTime SolutionTime)
            )
        {
            if ( $Ticket{$TimeInSeconds} ) {
                $Ticket{$TimeInSeconds} = $LocalLayoutObject->CustomerAge(
                    Age   => $Ticket{$TimeInSeconds},
                    Space => ' '
                );
            }
        }
    }

    my %Queue;
    if ( $Param{QueueID} ) {
        %Queue = $Kernel::OM->Get('Kernel::System::Queue')->QueueGet(
            ID => $Param{QueueID},
        );
    }

    my $ConfigObject = $Kernel::OM->Get('Kernel::Config');

    # Replace config options.
    my $Tag = $Start . 'OTOBO_CONFIG_';
    $Param{Text} =~ s{
        $Tag
            # the key for the config
            (?<key>.+?)
        $End
    }
    {
        my $Key   = $+{key};
        my $Value = $ConfigObject->Get($Key) // '';

        # Mask sensitive config options.
        my $Replace = $Self->_MaskSensitiveValue(
            Key      => $Key,
            Value    => $Value,
            IsConfig => 1,
        );

        $Replace;
    }egx;

    # cleanup
    $Param{Text} =~ s/$Tag.+?$End/-/gi;

    my %Recipient = %{ $Param{Recipient} || {} };

    # get user object
    my $UserObject = $Kernel::OM->Get('Kernel::System::User');

    if ( !%Recipient && $Param{RecipientID} ) {

        %Recipient = $UserObject->GetUserData(
            UserID        => $Param{RecipientID},
            NoOutOfOffice => 1,
        );
    }

    # modify $Param{Text}
    my $HashGlobalReplace = sub {
        my ( $Tag, %H ) = @_;

        # Generate one single matching string for all keys to save performance.
        my $Keys = join '|', map {quotemeta} grep { defined $H{$_} } keys %H;

        # Set all keys as lowercase to be able to match case insensitive,
        #   e. g. <OTOBO_CUSTOMER_From> and <OTOBO_CUSTOMER_FROM>.
        #   Also mask any values containing sensitive data.
        %H = map {
            lc $_ => $Self->_MaskSensitiveValue(
                Key   => $_,
                Value => $H{$_},
            )
        } sort keys %H;

        # If tag is 'OTOBO_CUSTOMER_' add the body alias 'email/note' to be replaced.
        if ( $Tag =~ m/OTOBO_(CUSTOMER|AGENT)_/ ) {
            KEY:
            for my $Key (qw( email note )) {
                my $Value = $H{$Key};

                next KEY if defined($Value);

                $H{$Key} = $H{'body'};
                $Keys .= '|' . ucfirst $Key;
            }
        }

        $Param{Text} =~ s{
            # grouping required here, as we might have alternations
            (?:$Tag)
                # case insensitiv keys
                (?<key>$Keys)
            $End
        }
        {
            my $Key = $+{key};
            $H{ lc $Key }
        }xieg;
    };

    # get recipient data and replace it with <OTOBO_...
    $Tag = $Start . 'OTOBO_';

    # include more readable tag <OTOBO_NOTIFICATION_RECIPIENT
    my $RecipientTag = $Start . 'OTOBO_NOTIFICATION_RECIPIENT_';

    if (%Recipient) {

        # HTML quoting of content
        if ( $Param{RichText} ) {
            ATTRIBUTE:
            for my $Attribute ( sort keys %Recipient ) {
                next ATTRIBUTE if !$Recipient{$Attribute};
                $Recipient{$Attribute} = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML(
                    String => $Recipient{$Attribute},
                );
            }
        }

        $HashGlobalReplace->( "$Tag|$RecipientTag", %Recipient );
    }

    # cleanup
    $Param{Text} =~ s/$RecipientTag.+?$End/-/gi;

    # get owner data and replace it with <OTOBO_OWNER_...
    $Tag = $Start . 'OTOBO_OWNER_';

    # include more readable version <OTOBO_TICKET_OWNER
    my $OwnerTag = $Start . 'OTOBO_TICKET_OWNER_';

    if ( $Ticket{OwnerID} ) {

        my %Owner = $UserObject->GetUserData(
            UserID        => $Ticket{OwnerID},
            NoOutOfOffice => 1,
        );

        # html quoting of content
        if ( $Param{RichText} ) {

            ATTRIBUTE:
            for my $Attribute ( sort keys %Owner ) {
                next ATTRIBUTE if !$Owner{$Attribute};
                $Owner{$Attribute} = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML(
                    String => $Owner{$Attribute},
                );
            }
        }

        $HashGlobalReplace->( "$Tag|$OwnerTag", %Owner );
    }

    # cleanup
    $Param{Text} =~ s/$Tag.+?$End/-/gi;
    $Param{Text} =~ s/$OwnerTag.+?$End/-/gi;

    # get owner data and replace it with <OTOBO_RESPONSIBLE_...
    $Tag = $Start . 'OTOBO_RESPONSIBLE_';

    # include more readable version <OTOBO_TICKET_RESPONSIBLE
    my $ResponsibleTag = $Start . 'OTOBO_TICKET_RESPONSIBLE_';

    if ( $Ticket{ResponsibleID} ) {
        my %Responsible = $UserObject->GetUserData(
            UserID        => $Ticket{ResponsibleID},
            NoOutOfOffice => 1,
        );

        # HTML quoting of content
        if ( $Param{RichText} ) {

            ATTRIBUTE:
            for my $Attribute ( sort keys %Responsible ) {
                next ATTRIBUTE if !$Responsible{$Attribute};
                $Responsible{$Attribute} = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML(
                    String => $Responsible{$Attribute},
                );
            }
        }

        $HashGlobalReplace->( "$Tag|$ResponsibleTag", %Responsible );
    }

    # cleanup
    $Param{Text} =~ s/$Tag.+?$End/-/gi;
    $Param{Text} =~ s/$ResponsibleTag.+?$End/-/gi;

    $Tag = $Start . 'OTOBO_Agent_';
    my $Tag2        = $Start . 'OTOBO_CURRENT_';
    my %CurrentUser = $UserObject->GetUserData(
        UserID        => $Param{UserID},
        NoOutOfOffice => 1,
    );

    # HTML quoting of content
    if ( $Param{RichText} ) {

        ATTRIBUTE:
        for my $Attribute ( sort keys %CurrentUser ) {
            next ATTRIBUTE if !$CurrentUser{$Attribute};
            $CurrentUser{$Attribute} = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML(
                String => $CurrentUser{$Attribute},
            );
        }
    }

    $HashGlobalReplace->( "$Tag|$Tag2", %CurrentUser );

    # replace other needed stuff
    $Param{Text} =~ s/$Start OTOBO_FIRST_NAME $End/$CurrentUser{UserFirstname}/gxms;
    $Param{Text} =~ s/$Start OTOBO_LAST_NAME $End/$CurrentUser{UserLastname}/gxms;

    # cleanup
    $Param{Text} =~ s/$Tag2.+?$End/-/gi;

# Rother OSS / OneTimeAuthenticationLink
    # Replace config options.
    $Tag = $Start . 'OTOBO_OTACustomerTicketLink';
    $Param{Text} =~ s{$Tag$End}{
        my $Replace = $Kernel::OM->Get('Kernel::System::CustomerAuth::OneTimeAuthLink')->TicketLink(
            TicketNumber => $Ticket{TicketNumber},
            User         => $Ticket{CustomerUserID},
        );

        $Replace;
    }egx;
# EO OneTimeAuthenticationLink

    # ticket data
    $Tag = $Start . 'OTOBO_TICKET_';

    # html quoting of content
    if ( $Param{RichText} ) {

        ATTRIBUTE:
        for my $Attribute ( sort keys %Ticket ) {
            next ATTRIBUTE if !$Ticket{$Attribute};
            $Ticket{$Attribute} = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML(
                String => $Ticket{$Attribute},
            );
        }
    }

    # Dropdown, Checkbox and MultiSelect DynamicFields, can store values (keys) that are
    # different from the values to display
    # <OTOBO_TICKET_DynamicField_NameX> returns the stored key
    # <OTOBO_TICKET_DynamicField_NameX_Value> returns the display value

    my %DynamicFields;

    # For systems with many Dynamic fields we do not want to load them all unless needed
    # Find what Dynamic Field Values are requested
    while ( $Param{Text} =~ m/$Tag DynamicField_(\S+?)(_Value)? $End/gixms ) {
        $DynamicFields{$1} = 1;
    }

    # to store all the required DynamicField display values
    my %DynamicFieldDisplayValues;

    # get dynamic field objects
    my $DynamicFieldObject        = $Kernel::OM->Get('Kernel::System::DynamicField');
    my $DynamicFieldBackendObject = $Kernel::OM->Get('Kernel::System::DynamicField::Backend');

    # get the dynamic fields for ticket object
    my $DynamicFieldList = $DynamicFieldObject->DynamicFieldListGet(
        Valid      => 1,
        ObjectType => ['Ticket'],
    ) || [];

    # cycle through the activated Dynamic Fields for this screen
    DYNAMICFIELD:
    for my $DynamicFieldConfig ( @{$DynamicFieldList} ) {

        next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);

        # we only load the ones requested
        next DYNAMICFIELD if !$DynamicFields{ $DynamicFieldConfig->{Name} };

        my $LanguageObject;

        # translate values if needed
        if ( $Param{Language} ) {
            $LanguageObject = Kernel::Language->new(
                UserLanguage => $Param{Language},
            );
        }

        my $DateTimeObject;

        # Change DateTime DF value for ticket if needed.
        if (
            defined $Ticket{ 'DynamicField_' . $DynamicFieldConfig->{Name} }
            && $DynamicFieldConfig->{FieldType} eq 'DateTime'
            && $RecipientTimeZone
            )
        {
            $DateTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $Ticket{ 'DynamicField_' . $DynamicFieldConfig->{Name} },
                },
            );
            $DateTimeObject->ToTimeZone( TimeZone => $RecipientTimeZone );
            $Ticket{ 'DynamicField_' . $DynamicFieldConfig->{Name} } = $DateTimeObject->ToString();
        }

        # get the display value for each dynamic field
        my $DisplayValue = $DynamicFieldBackendObject->ValueLookup(
            DynamicFieldConfig => $DynamicFieldConfig,
            Key                => $Ticket{ 'DynamicField_' . $DynamicFieldConfig->{Name} },
            LanguageObject     => $LanguageObject,
        );

        # get the readable value (value) for each dynamic field
        my $DisplayValueStrg = $DynamicFieldBackendObject->ReadableValueRender(
            DynamicFieldConfig => $DynamicFieldConfig,
            Value              => $DisplayValue,
        );

        # fill the DynamicFieldDisplayValues
        if ($DisplayValueStrg) {
            $DynamicFieldDisplayValues{ 'DynamicField_' . $DynamicFieldConfig->{Name} . '_Value' } = $DisplayValueStrg->{Value};

            # Add timezone info if needed.
            if (
                defined $Ticket{ 'DynamicField_' . $DynamicFieldConfig->{Name} }
                && length $Ticket{ 'DynamicField_' . $DynamicFieldConfig->{Name} }
                && $DynamicFieldConfig->{FieldType} eq 'DateTime'
                && $RecipientTimeZone
                )
            {
                $DynamicFieldDisplayValues{ 'DynamicField_' . $DynamicFieldConfig->{Name} . '_Value' }
                    .= " ($RecipientTimeZone)";
            }
        }

        # get the readable value (key) for each dynamic field
        my $ValueStrg = $DynamicFieldBackendObject->ReadableValueRender(
            DynamicFieldConfig => $DynamicFieldConfig,
            Value              => $Ticket{ 'DynamicField_' . $DynamicFieldConfig->{Name} },
        );

        # replace ticket content with the value from ReadableValueRender (if any)
        if ( IsHashRefWithData($ValueStrg) ) {
            $Ticket{ 'DynamicField_' . $DynamicFieldConfig->{Name} } = $ValueStrg->{Value};

            # Add timezone info if needed.
            if (
                defined $Ticket{ 'DynamicField_' . $DynamicFieldConfig->{Name} }
                && length $Ticket{ 'DynamicField_' . $DynamicFieldConfig->{Name} }
                && $DynamicFieldConfig->{FieldType} eq 'DateTime'
                && $RecipientTimeZone
                )
            {
                $Ticket{ 'DynamicField_' . $DynamicFieldConfig->{Name} } .= " ($RecipientTimeZone)";
            }
        }
    }

    # replace it
    $HashGlobalReplace->( $Tag, %Ticket, %DynamicFieldDisplayValues );

    # COMPAT
    $Param{Text} =~ s/$Start OTOBO_TICKET_ID $End/$Ticket{TicketID}/gixms;
    $Param{Text} =~ s/$Start OTOBO_TICKET_NUMBER $End/$Ticket{TicketNumber}/gixms;
    if ( $Ticket{TicketID} ) {
        $Param{Text} =~ s/$Start OTOBO_QUEUE $End/$Ticket{Queue}/gixms;
    }
    if ( $Param{QueueID} ) {
        $Param{Text} =~ s/$Start OTOBO_TICKET_QUEUE $End/$Queue{Name}/gixms;
    }

    # cleanup
    $Param{Text} =~ s/$Tag.+?$End/-/gi;

    # Follow-up for bug#10825.
    # Set data for replacing of specific tags in Templates:
    # - OTOBO_AGENT_SUBJECT, OTOBO_AGENT_BODY - subject/body of the CURRENT/LATEST agent article
    # - OTOBO_CUSTOMER_SUBJECT, OTOBO_CUSTOMER_BODY - subject/body of the CURRENT/LATEST customer article
    # - OTOBO_AGENT_SUBJECT[n]    - first n characters of the subject of the CURRENT/LATEST agent article
    # - OTOBO_AGENT_BODY[n]       - first n lines of the body of the CURRENT/LATEST agent article
    # - OTOBO_CUSTOMER_SUBJECT[n] - first n characters of the subject of the CURRENT/LATEST customer article
    # - OTOBO_CUSTOMER_BODY[n]    - first n lines of the body of the CURRENT/LATEST customer article
    #
    # For Note template we need the last article.
    # For Answer, $Param{Data} has selected or last article data, depends whether ArticleID is sent or not.
    # For Forward, $Param{Data} has the following article data:
    # - if ArticleID is sent, data is from selected article.
    # - if ArticleID is not sent, data is from last customer/agent/any article.
    if ( $Param{Template} && $Ticket{TicketID} ) {
        my $ArticleObject = $Kernel::OM->Get('Kernel::System::Ticket::Article');

        if ( $Param{Template} eq 'Note' ) {

            # Get last article from agent.
            my @AgentArticles = $ArticleObject->ArticleList(
                TicketID   => $Param{TicketData}->{TicketID},
                SenderType => 'agent',
                OnlyLast   => 1,
            );

            if (@AgentArticles) {
                my %AgentArticle = $ArticleObject->BackendForArticle( %{ $AgentArticles[0] } )->ArticleGet(
                    %{ $AgentArticles[0] },
                    DynamicFields => 0,
                );

                $Param{DataAgent}->{Subject} = $AgentArticle{Subject};
                $Param{DataAgent}->{Body}    = $AgentArticle{Body};
            }

            # Get last article from customer.
            my @CustomerArticles = $ArticleObject->ArticleList(
                TicketID   => $Param{TicketData}->{TicketID},
                SenderType => 'customer',
                OnlyLast   => 1,
            );

            if (@CustomerArticles) {
                my %CustomerArticle = $ArticleObject->BackendForArticle( %{ $CustomerArticles[0] } )->ArticleGet(
                    %{ $CustomerArticles[0] },
                    DynamicFields => 0,
                );

                $Param{Data}->{Subject} = $CustomerArticle{Subject};
                $Param{Data}->{Body}    = $CustomerArticle{Body};
            }
        }
        elsif ( $Param{Template} eq 'Answer' || $Param{Template} eq 'Forward' ) {

            # If $Param{Data} has agent article data, we will set subject and body in $Param{DataAgent}
            # to values from $Param{Data} in order to right replacing of OTOBO_AGENT_SUBJECT/BODY tags.
            if ( $Param{Data}->{SenderType} && $Param{Data}->{SenderType} eq 'agent' ) {
                $Param{DataAgent}->{Subject} = $Param{Data}->{Subject};
                $Param{DataAgent}->{Body}    = $Param{Data}->{Body};
            }
        }
    }

    # get customer and agent params and replace it with <OTOBO_CUSTOMER_... or <OTOBO_AGENT_...
    my %ArticleData = (
        'OTOBO_CUSTOMER_' => $Param{Data}      || {},
        'OTOBO_AGENT_'    => $Param{DataAgent} || {},
    );

    # use a list to get customer first
    for my $DataType (qw(OTOBO_CUSTOMER_ OTOBO_AGENT_)) {
        my %Data = %{ $ArticleData{$DataType} };

        # HTML quoting of content
        if ( $Param{RichText} ) {

            ATTRIBUTE:
            for my $Attribute ( sort keys %Data ) {
                next ATTRIBUTE unless $Data{$Attribute};

                $Data{$Attribute} = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML(
                    String => $Data{$Attribute},
                );
            }
        }

        if (%Data) {

            # replace <OTOBO_CUSTOMER_*> and <OTOBO_AGENT_*> tags
            $Tag = $Start . $DataType;
            $HashGlobalReplace->( $Tag, %Data );

            # prepare body (insert old email) <OTOBO_CUSTOMER_EMAIL[n]>, <OTOBO_CUSTOMER_NOTE[n]>
            #   <OTOBO_CUSTOMER_BODY[n]>, <OTOBO_AGENT_EMAIL[n]>..., <OTOBO_COMMENT>

            # Handle the case where the number of included lines can be specified.
            # The same key can occur multiple times, possibly with a different number of lines.
            # The last customer mail is used for <OTOBO_COMMENT> or <OTOBO_COMMENT[123]>
            # as the loop replaces the customer mail first.
            $Param{Text} =~ s{
                $Start
                    (?:
                        # e.g. OTOBO_COMMENT[13], OTOBO_AGENT_BODY[3], OTOBO_CUSTOMER_BODY[0]
                        (?:
                            (?:
                                OTOBO_COMMENT
                                |
                                ${DataType}(?:EMAIL|NOTE|BODY)
                            )
                            \[(?<cnt>.+?)\]
                        )
                        |
                        # a special case as OTOBO_COMMENT without quantifier is handled nowhere else
                        OTOBO_COMMENT
                    )
                $End
            }
            {
                # for <OTOBO_COMMENT> truncate per default a long mail at 2500
                # <OTOBO_CUSTOMER_BODY[0] would also yield 2500 lines
                my $NumHeadLines = $+{cnt} || 2500;

                my $NewOldBody   = '';
                my @Body         = split /\n/, $Data{Body};
                my $NumBodyLines = scalar @Body;

                COUNTER:
                for my $Counter ( 0 .. $NumHeadLines - 1 ) {

                    # do not go beyond the complete body
                    last COUNTER if $Counter >= $NumBodyLines;

                    # add no quote char, do it later by using DocumentCleanup()
                    if ( $Param{RichText} ) {
                        $NewOldBody .= $Body[$Counter];
                    }

                    # add "> " as quote char
                    else {
                        $NewOldBody .= "> $Body[$Counter]";
                    }

                    # add new line, unless we are at the last included line
                    # not sure why the last line has a newline when the
                    # the body has less lines than the specified line count
                    if ( $Counter < ( $NumHeadLines - 1 ) ) {
                        $NewOldBody .= "\n";
                    }
                }

                chomp $NewOldBody;

                # HTML quoting of content
                if ( $Param{RichText} && $NewOldBody ) {

                    # remove trailing new lines
                    for ( 1 .. 10 ) {
                        $NewOldBody =~ s/(<br\/>)\s{0,20}$//gs;
                    }

                    # add quote
                    $NewOldBody = "<blockquote type=\"cite\">$NewOldBody</blockquote>";
                    $NewOldBody = $Kernel::OM->Get('Kernel::System::HTMLUtils')->DocumentCleanup(
                        String => $NewOldBody,
                    );
                }

                # the replacement
                $NewOldBody
            }xeg;    # a single pass over the macros in $Param{Text}

            # replace <OTOBO_CUSTOMER_SUBJECT[]>  and  <OTOBO_AGENT_SUBJECT[]> tags
            $Tag = "$Start$DataType" . 'SUBJECT';
            if ( $Param{Text} =~ /$Tag\[(.+?)\]$End/g ) {

                my $SubjectChar = $1;
                my $Subject     = $Kernel::OM->Get('Kernel::System::Ticket')->TicketSubjectClean(
                    TicketNumber => $Ticket{TicketNumber},
                    Subject      => $Data{Subject},
                );

                $Subject =~ s/^(.{$SubjectChar}).*$/$1 [...]/;
                $Param{Text} =~ s/$Tag\[.+?\]$End/$Subject/g;
            }

            if ( $DataType eq 'OTOBO_CUSTOMER_' ) {

                # Get <OTOBO_EMAIL_DATE[]> from body and replace with received date.
                # TODO: Clarify, as it rather looks like the current date is used.
                # This tag will be able to use with supported OTOBO time zones
                #   ( e.g. <OTOBO_EMAIL_DATE[Europe/Berlin]>, <OTOBO_EMAIL_DATE[Asia/Tokyo]>,
                #   <OTOBO_EMAIL_DATE[America/Denver]> , ...).
                # If you use tag without time in simple format as <OTOBO_EMAIL_DATE>,
                #  time will be transformed into OTOBO SystemTimeZone.
                $Tag = $Start . 'OTOBO_EMAIL_DATE';

                my $DateTimeObject = $Kernel::OM->Create('Kernel::System::DateTime');
                my $SystemTimeZone = $DateTimeObject->OTOBOTimeZoneGet();

                $Param{Text} =~ s{
                    $Start
                        OTOBO_EMAIL_DATE
                        # the time zone is optional
                        (?:
                            \[(?<tz>.+?)\]
                        )?
                    $End
                }
                {
                    my $TimeZone = $+{tz};

                    if ( $TimeZone ) {
                        my $TimeZoneValid = $DateTimeObject->IsTimeZoneValid( TimeZone => $TimeZone );
                        if ($TimeZoneValid) {
                            $DateTimeObject->ToTimeZone( TimeZone => $TimeZone );
                        }
                        else {

                            # stay at the system time zone
                            $TimeZone = $SystemTimeZone;
                        }

                    }
                    else {
                        $TimeZone = $SystemTimeZone;
                        $DateTimeObject->ToTimeZone( TimeZone => $TimeZone );
                    }

                    # construct the replacement
                    my $EmailDate = $DateTimeObject->Format( Format => '%A, %B %e, %Y at %T ' );
                    $EmailDate .= "($TimeZone)";

                    # the replacement
                    $EmailDate;
                }xeg;    # a single pass over the macros in $Param{Text}
            }
        }

        if ( $DataType eq 'OTOBO_CUSTOMER_' ) {

            # get and prepare real name
            $Tag = $Start . 'OTOBO_CUSTOMER_REALNAME';
            if ( $Param{Text} =~ /$Tag$End/i ) {

                my $From;

                if ( $Ticket{CustomerUserID} ) {

                    $From = $CustomerUserObject->CustomerName(
                        UserLogin => $Ticket{CustomerUserID}
                    );
                }

                # try to get the real name directly from the data
                $From //= $Recipient{Realname};

                # get real name based on reply-to
                if ( !$From && $Data{ReplyTo} ) {

                    $From = $Data{ReplyTo};

                    # remove email addresses
                    $From =~ s/&lt;.*&gt;|<.*>|\(.*\)|\"|&quot;|;|,//g;

                    # remove leading/trailing spaces
                    $From =~ s/^\s+//g;
                    $From =~ s/\s+$//g;
                }

                # generate real name based on sender line
                if ( !$From ) {
                    $From = $Data{To} || '';

                    # remove email addresses
                    $From =~ s/&lt;.*&gt;|<.*>|\(.*\)|\"|&quot;|;|,//g;

                    # remove leading/trailing spaces
                    $From =~ s/^\s+//g;
                    $From =~ s/\s+$//g;
                }

                # replace <OTOBO_CUSTOMER_REALNAME> with from
                $Param{Text} =~ s/$Tag$End/$From/g;
            }
        }
    }

    # get customer data and replace it with <OTOBO_CUSTOMER_DATA_...
    $Tag  = $Start . 'OTOBO_CUSTOMER_';
    $Tag2 = $Start . 'OTOBO_CUSTOMER_DATA_';

    if ( $Ticket{CustomerUserID} || $Param{Data}->{CustomerUserID} ) {

        my $CustomerUserID = $Param{Data}->{CustomerUserID} || $Ticket{CustomerUserID};

        my %CustomerUser = $CustomerUserObject->CustomerUserDataGet(
            User => $CustomerUserID,
        );

        # HTML quoting of content
        if ( $Param{RichText} ) {

            ATTRIBUTE:
            for my $Attribute ( sort keys %CustomerUser ) {
                next ATTRIBUTE if !$CustomerUser{$Attribute};
                $CustomerUser{$Attribute} = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML(
                    String => $CustomerUser{$Attribute},
                );
            }
        }

        # replace it
        $HashGlobalReplace->( "$Tag|$Tag2", %CustomerUser );
    }

    # Clean up all not needed '<OTOBO_CUSTOMER_' and '<OTOBO_CUSTOMER_DATA_' tags.
    # Note that this includes the tags which became part of the replace text
    # because they were present in the macro values.
    $Param{Text} =~ s/(?:$Tag|$Tag2).+?$End/-/gi;

    # cleanup all not needed <OTOBO_AGENT_ tags
    $Tag = $Start . 'OTOBO_AGENT_';
    $Param{Text} =~ s/$Tag.+?$End/-/gi;

    return $Param{Text};
}

=head2 _RemoveUnSupportedTag()

clean up all not supported tags. The not supported tags are replaced
with the minus character '-'.

    my $Text = $TemplateGeneratorObject->_RemoveUnSupportedTag(
        Text                 => $SomeTextWithTags,
        ListOfUnSupportedTag => \@ListOfUnSupportedTag,
    );

=cut

sub _RemoveUnSupportedTag {

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

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

    my $Start = '<';
    my $End   = '>';
    if ( $Self->{RichText} ) {
        $Start = '&lt;';
        $End   = '&gt;';
        $Param{Text} =~ s/(\n|\r)//g;
    }

    # Cleanup all not supported tags with and without number, e.g. OTOBO_CUSTOMER_BODY and OTOBO_CUSTOMER_BODY[n].
    # See https://bugs.otrs.org/show_bug.cgi?id=14369 and https://bugs.otrs.org/show_bug.cgi?id=10825.
    my $NotSupportedTag = $Start . "(?:" . join( "|", @{ $Param{ListOfUnSupportedTag} } ) . ")(\\[.*?\\])?" . $End;
    $Param{Text} =~ s/$NotSupportedTag/-/gi;

    return $Param{Text};
}

=head2 _MaskSensitiveValue()

Mask sensitive value, i.e. a password, a security token, etc.

    my $MaskedValue = $Self->_MaskSensitiveValue(
        Key      => 'DatabasePassword', # (required) Name of the field/key.
        Value    => 'secretvalue',      # (optional) Value to potentially mask.
        IsConfig => 1,                  # (optional) Whether the value is a config option, default: 0.
    );

Returns masked value in case the key is matched:

   $MaskedValue = 'xxx';

=cut

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

    return '' if !$Param{Key} || !defined $Param{Value};

    # Skip masking sensitive values for Dynamic Fields.
    return $Param{Value} if $Param{Key} =~ qr{ dynamicfield }xi;

    # Match general key names, i.e. from the user preferences.
    my $Match = qr{ config|secret|passw|userpw|auth|token }xi;

    # Match forbidden config keys.
    if ( $Param{IsConfig} ) {
        $Match = qr{ (?:password|pw) \d* $ }smxi;
    }

    return $Param{Value} if $Param{Key} !~ $Match;

    return 'xxx';
}

=end Internal:

=cut

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/System/Web/InterfaceCustomer.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::Web::InterfaceCustomer;

use v5.24;
use strict;
use warnings;
use namespace::autoclean;
use utf8;

# core modules
use Time::HiRes ();

# CPAN modules

# OTOBO modules
use Kernel::System::VariableCheck qw(IsArrayRefWithData IsHashRefWithData);
use Kernel::Language              qw(Translatable);
use Kernel::System::DateTime      ();

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::Output::HTML::Layout',
    'Kernel::System::AuthSession',
    'Kernel::System::Cache',
    'Kernel::System::CustomerAuth',
    'Kernel::System::CustomerGroup',
    'Kernel::System::CustomerUser',
    'Kernel::System::DB',
    'Kernel::System::Email',
    'Kernel::System::Log',
    'Kernel::System::Main',
    'Kernel::System::Scheduler',
    'Kernel::System::DateTime',
    'Kernel::System::Web::Request',
    'Kernel::System::Web::Response',
    'Kernel::System::Valid',
);

=head1 NAME

Kernel::System::Web::InterfaceCustomer - the customer web interface

=head1 SYNOPSIS

    use Kernel::System::Web::InterfaceCustomer;

    # a Plack request handler
    my $App = sub {
        my $Env = shift;

        my $Interface = Kernel::System::Web::InterfaceCustomer->new(
            # Debug => 1
            PSGIEnv    => $Env,
        );

        # generate content (actually headers are generated as a side effect)
        my $Content = $Interface->Content();

        # assuming all went well and HTML was generated
        return [
            '200',
            [ 'Content-Type' => 'text/html' ],
            $Content
        ];
    };

=head1 DESCRIPTION

This module generates the HTTP response for F<customer.pl>.
This class is meant to be used within a Plack request handler.
See F<bin/psgi-bin/otobo.psgi> for the real live usage.

=head1 PUBLIC INTERFACE

=head2 new()

create the web interface object for F<customer.pl>.

=cut

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

    # start with an empty hash for the new object
    my $Self = bless {}, $Type;

    # set debug level
    $Self->{Debug} = $Param{Debug} || 0;

    # performance log based on high resolution timestamps
    $Self->{PerformanceLogStart} = Time::HiRes::time();

    # register object params
    $Kernel::OM->ObjectParamAdd(
        'Kernel::System::Log' => {
            LogPrefix => $Kernel::OM->Get('Kernel::Config')->Get('CGILogPrefix') || 'Customer',
        },
        'Kernel::System::Web::Request' => {
            PSGIEnv => $Param{PSGIEnv} || 0,
        },
    );

    # debug info
    if ( $Self->{Debug} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'debug',
            Message  => 'Global handle started...',
        );
    }

    return $Self;
}

=head2 Content()

execute the object.
Set headers in Kernels::System::Web::Request singleton as side effect.

    my $Content = $Interface->Content();

=cut

sub Content {
    my $Self = shift;

    my $ConfigObject = $Kernel::OM->Get('Kernel::Config');
    my $ParamObject  = $Kernel::OM->Get('Kernel::System::Web::Request');

    # Check if https forcing is active, and redirect if needed.
    if ( $ConfigObject->Get('HTTPSForceRedirect') && !$ParamObject->HttpsIsOn ) {
        my $Host         = $ParamObject->Header('Host') || $ConfigObject->Get('FQDN');
        my $RequestURI   = $ParamObject->RequestURI();
        my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');

        $LayoutObject->Redirect( ExtURL => "https://$Host$RequestURI" );    # throw a Kernel::System::Web::Exception exception
    }

    # get common framework params
    my %Param;
    $Param{SessionName} = $ConfigObject->Get('CustomerPanelSessionName')         || 'CSID';
    $Param{SessionID}   = $ParamObject->GetParam( Param => $Param{SessionName} ) || '';

    # drop old session id (if exists)
    my $QueryString = $ParamObject->QueryString() || '';
    $QueryString =~ s/(\?|&|;|)$Param{SessionName}(=&|=;|=.+?&|=.+?$)/;/g;

    # define framework params
    {
        my %FrameworkParams = (
            Lang         => '',
            Action       => '',
            Subaction    => '',
            RequestedURL => $QueryString,
        );
        for my $Key ( sort keys %FrameworkParams ) {
            $Param{$Key} = $ParamObject->GetParam( Param => $Key ) || $FrameworkParams{$Key};
        }
    }

    # validate language
    if ( $Param{Lang} && $Param{Lang} !~ m{\A[a-z]{2}(?:_[A-Z]{2})?\z}xms ) {
        delete $Param{Lang};
    }

    # Check if the browser sends the SessionID cookie and set the SessionID-cookie
    # as SessionID! GET or POST SessionID have the lowest priority.
    if ( $ConfigObject->Get('SessionUseCookie') ) {
        $Param{SessionIDCookie} = $ParamObject->GetCookie( Key => $Param{SessionName} );
        if ( $Param{SessionIDCookie} ) {
            $Param{SessionID} = $Param{SessionIDCookie};
        }
    }

    $Kernel::OM->ObjectParamAdd(
        'Kernel::Output::HTML::Layout' => {
            Lang => $Param{Lang},
        },
        'Kernel::Language' => {
            UserLanguage => $Param{Lang}
        },
    );

    my $DBCanConnect = $Kernel::OM->Get('Kernel::System::DB')->Connect();

    if ( !$DBCanConnect || $ParamObject->Error() ) {
        my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
        if ( !$DBCanConnect ) {
            $LayoutObject->CustomerFatalError(
                Comment => Translatable('Please contact the administrator.'),
            );    # throws a Kernel::System::Web::Exception
        }
        if ( $ParamObject->Error() ) {
            $LayoutObject->CustomerFatalError(
                Message => $ParamObject->Error(),
                Comment => Translatable('Please contact the administrator.'),
            );    # throws a Kernel::System::Web::Exception
        }
    }

    # get common application and add-on application params
    my %CommonObjectParam = %{ $ConfigObject->Get('CustomerFrontend::CommonParam') };
    for my $Key ( sort keys %CommonObjectParam ) {
        $Param{$Key} = $ParamObject->GetParam( Param => $Key ) || $CommonObjectParam{$Key};
    }

    # security check Action Param (replace non-word chars)
    $Param{Action} =~ s/\W//g;

    my $SessionObject = $Kernel::OM->Get('Kernel::System::AuthSession');
    my $UserObject    = $Kernel::OM->Get('Kernel::System::CustomerUser');

    # check request type
    if ( $Param{Action} eq 'PreLogin' ) {
        my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
        $Param{RequestedURL} ||= 'Action=CustomerDashboard';

        # login screen
        return $LayoutObject->CustomerLogin(
            Title => 'Login',
            Mode  => 'PreLogin',
            %Param,
        );
    }
    elsif ( $Param{Action} eq 'Login' ) {

        # get params
        my $PostUser = $ParamObject->GetParam( Param => 'User' ) || '';

        my $PreventBruteForceConfig = $ConfigObject->Get('SimpleBruteForceProtection::GeneralSettings');

        # if simplebruteforceconfig is valid
        if ( $PreventBruteForceConfig && $PostUser ) {

            # check if the login is banned
            my $CacheObject   = $Kernel::OM->Get('Kernel::System::Cache');
            my $CheckHashUser = $CacheObject->Get(
                Type => 'BannedLoginsCustomer',
                Key  => $PostUser,
            );

            # check if Cache CheckHashUser exists
            if ($CheckHashUser) {
                my %BanStatus = $Self->_CheckAndRemoveFromBannedList(
                    PostUser                => $PostUser,
                    PreventBruteForceConfig => $PreventBruteForceConfig,
                );

                if ( $BanStatus{Banned} ) {

                    # output error message
                    my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');

                    return $LayoutObject->CustomerLogin(
                        %Param,
                        Title   => 'Login',
                        Message => $LayoutObject->{LanguageObject}->Translate(
                            'Too many failed login attempts, please retry in %s s.',
                            $BanStatus{ResidualTime}
                        ),
                        LoginFailed => 1,
                        MessageType => 'Error',
                        User        => $PostUser,
                    );
                }
            }
        }

        my $PostPw = $ParamObject->GetParam(
            Param => 'Password',
            Raw   => 1
        ) || '';
        my $PostTwoFactorToken = $ParamObject->GetParam(
            Param => 'TwoFactorToken',
            Raw   => 1
        ) || '';

        # create AuthObject
        my $AuthObject = $Kernel::OM->Get('Kernel::System::CustomerAuth');

# Rother OSS / OneTimeAuthenticationLink
        my %ExtendedAuthParams;
        for my $Name ( $AuthObject->ExtendedParamNames() ) {
            $ExtendedAuthParams{$Name} = $ParamObject->GetParam(
                Param => $Name,
                Raw   => 1
            ) || '';
        }
# EO OneTimeAuthenticationLink

        # check submitted data
        my $User = $AuthObject->Auth(
            User           => $PostUser,
            Pw             => $PostPw,
            TwoFactorToken => $PostTwoFactorToken,
# Rother OSS / OneTimeAuthenticationLink
            %ExtendedAuthParams,
# EO OneTimeAuthenticationLink
        );

        # additional tasks / info
        my $PostAuth = $AuthObject->PostAuth();

        if ($PostAuth) {
            $Param{RequestedURL} = $PostAuth->{RequestedURL} // $Param{RequestedURL};
        }

        # login is invalid
        if ( !$User ) {

            my $Expires = '+' . $ConfigObject->Get('SessionMaxTime') . 's';
            if ( !$ConfigObject->Get('SessionUseCookieAfterBrowserClose') ) {
                $Expires = '';
            }

            # tentatively set an useless cookie, for checking cookie support
            my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
            $LayoutObject->SetCookie(
                Key     => 'OTOBOBrowserHasCookie',
                Name    => 'OTOBOBrowserHasCookie',
                Value   => 1,
                Expires => $Expires,
            );

            # redirect to alternate login
            if ( $ConfigObject->Get('CustomerPanelLoginURL') ) {
                $Param{RequestedURL} = $LayoutObject->LinkEncode( $Param{RequestedURL} );

                # throw a Kernel::System::Web::Exception that redirects
                $LayoutObject->Redirect(
                    ExtURL => $ConfigObject->Get('CustomerPanelLoginURL') . "?Reason=LoginFailed&RequestedURL=$Param{RequestedURL}",
                );
            }

            if ( $PreventBruteForceConfig && $PostUser ) {

                # prevent brute force
                my $Banned = $Self->_StoreFailedLogins(
                    PostUser                => $PostUser,
                    PreventBruteForceConfig => $PreventBruteForceConfig,
                );

                if ($Banned) {
                    return $LayoutObject->CustomerLogin(
                        %Param,
                        Title   => 'Login',
                        Message => $LayoutObject->{LanguageObject}->Translate(
                            'Too many failed login attempts, please retry in %s s.',
                            $PreventBruteForceConfig->{BanDuration}
                        ),
                        LoginFailed => 1,
                        MessageType => 'Error',
                        User        => $PostUser,
                    );
                }
            }

            # show normal login
            return $LayoutObject->CustomerLogin(
                Title   => 'Login',
                Message => $AuthObject->GetLastErrorMessage()
                    || $Kernel::OM->Get('Kernel::System::Log')->GetLogEntry(
                        Type => 'Info',
                        What => 'Message',
                    )
                    || Translatable('Login failed! Your user name or password was entered incorrectly.'),
                LoginFailed => 1,
                User        => $PostUser,
                %Param,
            );
        }

        # login is successful
        my %UserData = $UserObject->CustomerUserDataGet(
            User  => $User,
            Valid => 1,
        );

        # check if the browser supports cookies
        if ( $ParamObject->GetCookie( Key => 'OTOBOBrowserHasCookie' ) ) {
            $Kernel::OM->ObjectParamAdd(
                'Kernel::Output::HTML::Layout' => {
                    BrowserHasCookie => 1,
                },
            );
        }

        # check needed data
        if ( !$UserData{UserID} || !$UserData{UserLogin} ) {

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

            # redirect to alternate login
            if ( $ConfigObject->Get('CustomerPanelLoginURL') ) {

                # throw a Kernel::System::Web::Exception that redirects
                $LayoutObject->Redirect(
                    ExtURL => $ConfigObject->Get('CustomerPanelLoginURL') . '?Reason=SystemError',
                );
            }

            # show need user data error message
            return $LayoutObject->CustomerLogin(
                Title   => 'Error',
                Message =>
                    Translatable(
                        'Authentication succeeded, but no customer record is found in the customer backend. Please contact the administrator.'
                    ),
                %Param,
            );
        }

        # create datetime object
        my $SessionDTObject = $Kernel::OM->Create('Kernel::System::DateTime');

        # Remove certain user attributes that are not needed to be stored in the session.
        #   - SMIME Certificate could be in binary format, if session backend in DB (default)
        #   it wont be possible to be saved in certain databases (see bug#14405).
        my %UserSessionData = %UserData;
        delete $UserSessionData{UserSMIMECertificate};

        # create new session id
        my $NewSessionID = $SessionObject->CreateSessionID(
            %UserSessionData,
            UserLastRequest => $SessionDTObject->ToEpoch(),
            UserType        => 'Customer',
            SessionSource   => 'CustomerInterface',
        );

        # show error message if no session id has been created
        if ( !$NewSessionID ) {

            # get error message
            my $Error = $SessionObject->SessionIDErrorMessage() || '';

            # output error message
            my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');

            return $LayoutObject->CustomerLogin(
                Title   => 'Login',
                Message => $Error,
                %Param,
            );
        }

        # execution in 20 seconds
        my $ExecutionTimeObj = $SessionDTObject->Clone();
        $ExecutionTimeObj->Add( Seconds => 20 );
        my $ExecutionTime = $ExecutionTimeObj->ToString();

        # add a asynchronous executor scheduler task to count the concurrent user
        $Kernel::OM->Get('Kernel::System::Scheduler')->TaskAdd(
            ExecutionTime            => $ExecutionTime,
            Type                     => 'AsynchronousExecutor',
            Name                     => 'PluginAsynchronous::ConcurrentUser',
            MaximumParallelInstances => 1,
            Data                     => {
                Object   => 'Kernel::System::SupportDataCollector::PluginAsynchronous::OTOBO::ConcurrentUsers',
                Function => 'RunAsynchronous',
            },
        );

        my $UserTimeZone = $Self->_UserTimeZoneGet(%UserData);

        $SessionObject->UpdateSessionID(
            SessionID => $NewSessionID,
            Key       => 'UserTimeZone',
            Value     => $UserTimeZone,
        );

        # check if the time zone offset reported by the user's browser differs from that
        # of the OTOBO user's time zone offset
        my $DateTimeObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                TimeZone => $UserTimeZone,
            },
        );
        my $OTOBOUserTimeZoneOffset = $DateTimeObject->Format( Format => '%{offset}' ) / 60;
        my $BrowserTimeZoneOffset   = ( $ParamObject->GetParam( Param => 'TimeZoneOffset' ) || 0 ) * -1;

        # TimeZoneOffsetDifference contains the difference of the time zone offset between
        # the user's OTOBO time zone setting and the one reported by the user's browser.
        # If there is a difference it can be evaluated later to e. g. show a message
        # for the user to check his OTOBO time zone setting.
        my $UserTimeZoneOffsetDifference = abs( $OTOBOUserTimeZoneOffset - $BrowserTimeZoneOffset );
        $SessionObject->UpdateSessionID(
            SessionID => $NewSessionID,
            Key       => 'UserTimeZoneOffsetDifference',
            Value     => $UserTimeZoneOffsetDifference,
        );

        # create a new LayoutObject with SessionIDCookie
        my $Expires = '+' . $ConfigObject->Get('SessionMaxTime') . 's';
        if ( !$ConfigObject->Get('SessionUseCookieAfterBrowserClose') ) {
            $Expires = '';
        }

        $Kernel::OM->ObjectParamAdd(
            'Kernel::Output::HTML::Layout' => {
                SetCookies  => {},
                SessionID   => $NewSessionID,
                SessionName => $Param{SessionName},
            },
        );

        Kernel::Output::HTML::Layout->SetCookie(
            RegisterInOM => 1,
            Key          => 'SessionIDCookie',
            Name         => $Param{SessionName},
            Value        => $NewSessionID,
            Expires      => $Expires,
        );

        # delete the OTOBOBrowserHasCookie cookie
        Kernel::Output::HTML::Layout->SetCookie(
            RegisterInOM => 1,
            Key          => 'OTOBOBrowserHasCookie',
            Name         => 'OTOBOBrowserHasCookie',
            Value        => '',
            Expires      => '-1y',
        );

        # redirect with new session id and old params
        # prepare old redirect URL -- do not redirect to Login or Logout (loop)!
        if ( $Param{RequestedURL} =~ /Action=(Logout|Login|LostPassword|PreLogin)/ ) {
            $Param{RequestedURL} = '';
        }

        # redirect with new session id
        my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');

        $LayoutObject->Redirect(
            OP    => $Param{RequestedURL},
            Login => 1,
        );    # throws a Kernel::System::Web::Exception
    }

    # logout
    elsif ( $Param{Action} eq 'Logout' ) {

        # check session id
        if ( !$SessionObject->CheckSessionID( SessionID => $Param{SessionID} ) ) {

            # new layout object
            my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');

            # redirect to alternate login
            if ( $ConfigObject->Get('CustomerPanelLoginURL') ) {
                $Param{RequestedURL} = $LayoutObject->LinkEncode( $Param{RequestedURL} );

                $LayoutObject->Redirect(
                    ExtURL => $ConfigObject->Get('CustomerPanelLoginURL')
                        . "?Reason=InvalidSessionID;RequestedURL=$Param{RequestedURL}",
                );    # throws a Kernel::System::Web::Exception
            }

            # show login screen
            return $LayoutObject->CustomerLogin(
                Title   => 'Logout',
                Message => Translatable('Session invalid. Please log in again.'),
                %Param,
            );
        }

        # get session data
        my %UserData = $SessionObject->GetSessionIDData(
            SessionID => $Param{SessionID},
        );

        $UserData{UserTimeZone} = $Self->_UserTimeZoneGet(%UserData);

        # create a new LayoutObject with '%Param' and '%UserData'
        $Kernel::OM->ObjectParamAdd(
            'Kernel::Output::HTML::Layout' => {
                SetCookies => {},
                %Param,
                %UserData,
            },
        );

        # delete the OTOBO session cookie
        Kernel::Output::HTML::Layout->SetCookie(
            RegisterInOM => 1,
            Key          => 'SessionIDCookie',
            Name         => $Param{SessionName},
            Value        => '',
            Expires      => '-1y',
        );

        $Kernel::OM->ObjectsDiscard( Objects => ['Kernel::Output::HTML::Layout'] );
        my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');

        # remove session id
        if ( !$SessionObject->RemoveSessionID( SessionID => $Param{SessionID} ) ) {
            $LayoutObject->CustomerFatalError(
                Comment => Translatable('Please contact the administrator.')
            );    # throws a Kernel::System::Web::Exception
        }

        # redirect to alternate login
        if ( $ConfigObject->Get('CustomerPanelLogoutURL') ) {
            $LayoutObject->Redirect(
                ExtURL => $ConfigObject->Get('CustomerPanelLogoutURL'),
            );    # throws a Kernel::System::Web::Exception
        }

        # try auth module specific logout
        my $LogoutInfo = $Kernel::OM->Get('Kernel::System::CustomerAuth')->Logout();
        if ( $LogoutInfo && $LogoutInfo->{LogoutURL} ) {
            $LayoutObject->Redirect(
                ExtURL => $LogoutInfo->{LogoutURL},
            );    # throws a Kernel::System::Web::Exception
        }

        # show logout screen
        return $LayoutObject->CustomerLogin(
            Title       => 'Logout',
            Message     => $LayoutObject->{LanguageObject}->Translate('Logout successful.'),
            MessageType => 'Success',
            %Param,
        );
    }

    # lost password
    elsif ( $Param{Action} eq 'CustomerLostPassword' ) {

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

        # check feature
        if ( !$ConfigObject->Get('CustomerPanelLostPassword') ) {

            # show normal login
            return $LayoutObject->CustomerLogin(
                Title   => 'Login',
                Message => Translatable('Feature not active!'),
            );
        }

        # get params
        my $User  = $ParamObject->GetParam( Param => 'User' )  || '';
        my $Token = $ParamObject->GetParam( Param => 'Token' ) || '';

        # get user login by token
        if ( !$User && $Token ) {

            # Prevent extracting password reset token character-by-character via wildcard injection
            # The wild card characters "%" and "_" could be used to match arbitrary character.
            if ( $Token !~ m{\A (?: [a-zA-Z] | \d )+ \z}xms ) {

                # Security: pretend that password reset instructions were actually sent to
                #   make sure that users cannot find out valid usernames by
                #   just trying and checking the result message.
                return $LayoutObject->Login(
                    Title       => 'Login',
                    Message     => Translatable('Sent password reset instructions. Please check your email.'),
                    MessageType => 'Success',
                    %Param,
                );
            }

            my %UserList = $UserObject->SearchPreferences(
                Key   => 'UserToken',
                Value => $Token,
            );
            USER_ID:
            for my $UserID ( sort keys %UserList ) {
                my %UserData = $UserObject->CustomerUserDataGet(
                    User  => $UserID,
                    Valid => 1,
                );
                if (%UserData) {
                    $User = $UserData{UserLogin};

                    last USER_ID;
                }
            }
        }

        # get user data
        my %UserData = $UserObject->CustomerUserDataGet(
            User => $User,
        );

        # verify customer user is valid when requesting password reset
        my @ValidIDs    = $Kernel::OM->Get('Kernel::System::Valid')->ValidIDsGet();
        my $UserIsValid = grep { $UserData{ValidID} && $UserData{ValidID} == $_ } @ValidIDs;
        if ( !$UserData{UserID} || !$UserIsValid ) {

            # Security: pretend that password reset instructions were actually sent to
            #   make sure that users cannot find out valid usernames by
            #   just trying and checking the result message.
            return $LayoutObject->CustomerLogin(
                Title       => 'Login',
                Message     => Translatable('Sent password reset instructions. Please check your email.'),
                MessageType => 'Success',
            );
        }

        # create email object
        my $EmailObject = $Kernel::OM->Get('Kernel::System::Email');

        # send password reset token
        if ( !$Token ) {

            # generate token
            $UserData{Token} = $UserObject->TokenGenerate(
                UserID => $UserData{UserID},
            );

            # send token notify email with link
            my $Body = $ConfigObject->Get('CustomerPanelBodyLostPasswordToken')
                || 'ERROR: CustomerPanelBodyLostPasswordToken is missing!';
            my $Subject = $ConfigObject->Get('CustomerPanelSubjectLostPasswordToken')
                || 'ERROR: CustomerPanelSubjectLostPasswordToken is missing!';
            for ( sort keys %UserData ) {
                $Body =~ s/<OTOBO_$_>/$UserData{$_}/gi;
            }
            my $Sent = $EmailObject->Send(
                To       => $UserData{UserEmail},
                Subject  => $Subject,
                Charset  => $LayoutObject->{UserCharset},
                MimeType => 'text/plain',
                Body     => $Body
            );
            if ( !$Sent->{Success} ) {
                $LayoutObject->FatalError(
                    Comment => Translatable('Please contact the administrator.'),
                );    # throws a Kernel::System::Web::Exception
            }

            return $LayoutObject->CustomerLogin(
                Title       => 'Login',
                Message     => Translatable('Sent password reset instructions. Please check your email.'),
                MessageType => 'Success',
                %Param,
            );
        }

        # reset password
        # check if token is valid
        my $TokenValid = $UserObject->TokenCheck(
            Token  => $Token,
            UserID => $UserData{UserID},
        );

        if ( !$TokenValid ) {
            return $LayoutObject->CustomerLogin(
                Title   => 'Login',
                Message => Translatable('Invalid Token!'),
                %Param,
            );
        }

        # get new password
        $UserData{NewPW} = $UserObject->GenerateRandomPassword();

        # update new password
        my $Success = $UserObject->SetPassword(
            UserLogin => $User,
            PW        => $UserData{NewPW}
        );

        if ( !$Success ) {
            return $LayoutObject->CustomerLogin(
                Title   => 'Login',
                Message => Translatable('Reset password unsuccessful. Please contact the administrator.'),
                User    => $User,
            );
        }

        # send notify email
        my $Body = $ConfigObject->Get('CustomerPanelBodyLostPassword')
            || 'New Password is: <OTOBO_NEWPW>';
        my $Subject = $ConfigObject->Get('CustomerPanelSubjectLostPassword')
            || 'New Password!';
        for ( sort keys %UserData ) {
            $Body =~ s/<OTOBO_$_>/$UserData{$_}/gi;
        }
        my $Sent = $EmailObject->Send(
            To       => $UserData{UserEmail},
            Subject  => $Subject,
            Charset  => $LayoutObject->{UserCharset},
            MimeType => 'text/plain',
            Body     => $Body
        );

        if ( !$Sent->{Success} ) {
            $LayoutObject->CustomerFatalError(
                Comment => Translatable('Please contact the administrator.'),
            );    # throws a Kernel::System::Web::Exception
        }
        my $Message = $LayoutObject->{LanguageObject}->Translate(
            'Sent new password to %s. Please check your email.',
            $UserData{UserEmail},
        );

        return $LayoutObject->CustomerLogin(
            Title       => 'Login',
            Message     => $Message,
            User        => $User,
            MessageType => 'Success',
        );
    }

    # create new customer account
    elsif ( $Param{Action} eq 'CustomerCreateAccount' ) {

        # new layout object
        my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');

        # check feature
        if ( !$ConfigObject->Get('CustomerPanelCreateAccount') ) {

            # show normal login
            return $LayoutObject->CustomerLogin(
                Title   => 'Login',
                Message => Translatable('Feature not active!'),
            );
        }

        # get params
        my %GetParams;
        for my $Entry ( @{ $ConfigObject->Get('CustomerUser')->{Map} } ) {
            $GetParams{ $Entry->[0] } = $ParamObject->GetParam( Param => $Entry->[1] )
                || '';
        }
        $GetParams{ValidID} = 1;

        # check needed params
        if ( !$GetParams{UserCustomerID} ) {
            $GetParams{UserCustomerID} = $GetParams{UserEmail};
        }
        if ( !$GetParams{UserLogin} ) {
            $GetParams{UserLogin} = $GetParams{UserEmail};
        }

        # get new password
        $GetParams{UserPassword} = $UserObject->GenerateRandomPassword();

        # get user data
        my %UserData = $UserObject->CustomerUserDataGet( User => $GetParams{UserLogin} );
        if ( $UserData{UserID} || !$GetParams{UserLogin} ) {

            # send data to JS
            $LayoutObject->AddJSData(
                Key   => 'SignupError',
                Value => 1,
            );

            return $LayoutObject->CustomerLogin(
                Title         => 'Login',
                Message       => Translatable('This e-mail address already exists. Please log in or reset your password.'),
                UserTitle     => $GetParams{UserTitle},
                UserFirstname => $GetParams{UserFirstname},
                UserLastname  => $GetParams{UserLastname},
                UserEmail     => $GetParams{UserEmail},
            );
        }

        # check for mail address restrictions
        my @Whitelist = @{
            $ConfigObject->Get('CustomerPanelCreateAccount::MailRestrictions::Whitelist') // []
        };
        my @Blacklist = @{
            $ConfigObject->Get('CustomerPanelCreateAccount::MailRestrictions::Blacklist') // []
        };

        my $WhitelistMatched;
        for my $WhitelistEntry (@Whitelist) {
            my $Regex = eval {qr/$WhitelistEntry/i};
            if ($@) {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  =>
                        $LayoutObject->{LanguageObject}->Translate(
                            'The customer panel mail address whitelist contains the invalid regular expression $WhitelistEntry, please check and correct it.'
                        ),
                );
            }
            elsif ( $GetParams{UserEmail} =~ $Regex ) {
                $WhitelistMatched++;
            }
        }
        my $BlacklistMatched;
        for my $BlacklistEntry (@Blacklist) {
            my $Regex = eval {qr/$BlacklistEntry/i};
            if ($@) {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  =>
                        $LayoutObject->{LanguageObject}->Translate(
                            'The customer panel mail address blacklist contains the invalid regular expression $BlacklistEntry, please check and correct it.'
                        ),
                );
            }
            elsif ( $GetParams{UserEmail} =~ $Regex ) {
                $BlacklistMatched++;
            }
        }

        if ( ( @Whitelist && !$WhitelistMatched ) || ( @Blacklist && $BlacklistMatched ) ) {

            # send data to JS
            $LayoutObject->AddJSData(
                Key   => 'SignupError',
                Value => 1,
            );

            return $LayoutObject->CustomerLogin(
                Title         => 'Login',
                Message       => Translatable('This email address is not allowed to register. Please contact support staff.'),
                UserTitle     => $GetParams{UserTitle},
                UserFirstname => $GetParams{UserFirstname},
                UserLastname  => $GetParams{UserLastname},
                UserEmail     => $GetParams{UserEmail},
            );
        }

        # create account
        my $DateTimeObject = $Kernel::OM->Create('Kernel::System::DateTime');

        my $Now = $DateTimeObject->ToString();

        my $Add = $UserObject->CustomerUserAdd(
            %GetParams,
            Comment => $LayoutObject->{LanguageObject}->Translate( 'Added via Customer Panel (%s)', $Now ),
            ValidID => 1,
            UserID  => $ConfigObject->Get('CustomerPanelUserID'),
        );
        if ( !$Add ) {

            # send data to JS
            $LayoutObject->AddJSData(
                Key   => 'SignupError',
                Value => 1,
            );

            return $LayoutObject->CustomerLogin(
                Title         => 'Login',
                Message       => Translatable('Customer user can\'t be added!'),
                UserTitle     => $GetParams{UserTitle},
                UserFirstname => $GetParams{UserFirstname},
                UserLastname  => $GetParams{UserLastname},
                UserEmail     => $GetParams{UserEmail},
            );
        }

        # send notify email
        my $EmailObject = $Kernel::OM->Get('Kernel::System::Email');
        my $Body        = $ConfigObject->Get('CustomerPanelBodyNewAccount')
            || 'No Config Option found!';
        my $Subject = $ConfigObject->Get('CustomerPanelSubjectNewAccount')
            || 'New OTOBO Account!';
        for ( sort keys %GetParams ) {
            $Body =~ s/<OTOBO_$_>/$GetParams{$_}/gi;
        }

        # send account info
        my $Sent = $EmailObject->Send(
            To       => $GetParams{UserEmail},
            Subject  => $Subject,
            Charset  => $LayoutObject->{UserCharset},
            MimeType => 'text/plain',
            Body     => $Body
        );
        if ( !$Sent->{Success} ) {
            return join '',
                $LayoutObject->CustomerHeader(
                    Area  => 'Core',
                    Title => 'Error'
                ),
                $LayoutObject->CustomerWarning(
                    Comment => Translatable('Can\'t send account info!')
                ),
                $LayoutObject->CustomerFooter();
        }

        # show sent account info
        if ( $ConfigObject->Get('CustomerPanelLoginURL') ) {

            # redirect to alternate login
            $Param{RequestedURL} = $LayoutObject->LinkEncode( $Param{RequestedURL} );

            $LayoutObject->Redirect(
                ExtURL => $ConfigObject->Get('CustomerPanelLoginURL')
                    . "?RequestedURL=$Param{RequestedURL};User=$GetParams{UserLogin};"
                    . "Email=$GetParams{UserEmail};Reason=NewAccountCreated",
            );    # throws a Kernel::System::Web::Exception
        }

        my $AccountCreatedMessage = $LayoutObject->{LanguageObject}->Translate(
            'New account created. Sent login information to %s. Please check your email.',
            $GetParams{UserEmail},
        );

        # login screen
        return $LayoutObject->CustomerLogin(
            Title       => 'Login',
            Message     => $AccountCreatedMessage,
            User        => $GetParams{UserLogin},
            MessageType => 'Success',
        );
    }

    # show login site
    elsif ( !$Param{SessionID} ) {

        # create AuthObject
        my $AuthObject   = $Kernel::OM->Get('Kernel::System::CustomerAuth');
        my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
        if ( $AuthObject->GetOption( What => 'PreAuth' ) ) {

            # automatic login
            $Param{RequestedURL} = $LayoutObject->LinkEncode( $Param{RequestedURL} );

            my $PreAuth = $AuthObject->PreAuth(
                RequestedURL => $Param{RequestedURL},
            );

            if ( $PreAuth && $PreAuth->{RedirectURL} ) {

                if ( $ConfigObject->Get('SessionUseCookie') ) {

                    # always set a cookie, so that
                    # we know already if the browser supports cookies.
                    # ( the session cookie isn't available at that time ).

                    my $Expires = '+' . $ConfigObject->Get('SessionMaxTime') . 's';
                    if ( !$ConfigObject->Get('SessionUseCookieAfterBrowserClose') ) {
                        $Expires = '';
                    }

                    # set a cookie tentatively for checking cookie support
                    $LayoutObject->SetCookie(
                        Key     => 'OTOBOBrowserHasCookie',
                        Name    => 'OTOBOBrowserHasCookie',
                        Value   => 1,
                        Expires => $Expires,
                    );
                }

                $LayoutObject->Redirect(
                    ExtURL => $PreAuth->{RedirectURL},
                );    # throws a Kernel::System::Web::Exception
            }

            $LayoutObject->Redirect(
                OP => "Action=PreLogin&RequestedURL=$Param{RequestedURL}",
            );        # throws a Kernel::System::Web::Exception
        }
        elsif ( $ConfigObject->Get('CustomerPanelLoginURL') ) {

            # redirect to alternate login
            $Param{RequestedURL} = $LayoutObject->LinkEncode( $Param{RequestedURL} );

            $LayoutObject->Redirect(
                ExtURL => $ConfigObject->Get('CustomerPanelLoginURL')
                    . "?RequestedURL=$Param{RequestedURL}",
            );        # throws a Kernel::System::Web::Exception
        }

# Rother OSS / OneTimeAuthenticationLink
        my %ExtendedAuthParams;
        for my $Name ( $AuthObject->ExtendedParamNames() ) {
            my $ExtParam = $ParamObject->GetParam(
                Param => $Name,
                Raw   => 1
            );
            if ( defined $ExtParam ) {
                $ExtendedAuthParams{$Name} = $ExtParam;
            }
        }

        # redirect directly to Login if necessary parameters are present
        if ( %ExtendedAuthParams ) {
            my $LoginString = 'Action=Login';
            for my $Key ( keys %ExtendedAuthParams ) {
                $LoginString .= ";$Key=$ExtendedAuthParams{$Key}";
            }

            $Param{RequestedURL} = $LayoutObject->LinkEncode( $Param{RequestedURL} );
            print $LayoutObject->Redirect(
                OP => "$LoginString;RequestedURL=$Param{RequestedURL}",
            );
        }
# EO OneTimeAuthenticationLink

        # login screen
        return $LayoutObject->CustomerLogin(
            Title => 'Login',
            %Param,
        );
    }

    # run modules if a version value exists
    elsif ( $Kernel::OM->Get('Kernel::System::Main')->Require("Kernel::Modules::$Param{Action}") ) {

        # check session id
        if ( !$SessionObject->CheckSessionID( SessionID => $Param{SessionID} ) ) {

            # create new LayoutObject with new '%Param'
            $Kernel::OM->ObjectParamAdd(
                'Kernel::Output::HTML::Layout' => {
                    SetCookies => {},
                    %Param,
                },
            );

            # delete the OTOBO session cookie
            Kernel::Output::HTML::Layout->SetCookie(
                RegisterInOM => 1,
                Key          => 'SessionIDCookie',
                Name         => $Param{SessionName},
                Value        => '',
                Expires      => '-1y',
            );

            # if the wrong scheme is used, delete also the "other" cookie - issue #251
            my ($RequestScheme) = split /\//, $ParamObject->ServerProtocol, 2;
            if ( $RequestScheme ne $ConfigObject->Get('HttpType') ) {
                $Kernel::OM->ObjectParamAdd(
                    'Kernel::Output::HTML::Layout' => {
                        SetCookies => {},
                        %Param,
                    },
                );

                # delete the OTOBO session cookie
                # TODO: the Name is used twice
                Kernel::Output::HTML::Layout->SetCookie(
                    RegisterInOM => 1,
                    Key          => 'SessionIDCookiehttp',
                    Name         => $Param{SessionName},
                    Value        => '',
                    Expires      => '-1y',
                    Secure       => '',
                );
                Kernel::Output::HTML::Layout->SetCookie(
                    RegisterInOM => 1,
                    Key          => 'SessionIDCookiehttps',
                    Name         => $Param{SessionName},
                    Value        => '',
                    Expires      => '-1y',
                    Secure       => 1,
                );
            }

            $Kernel::OM->ObjectsDiscard( Objects => ['Kernel::Output::HTML::Layout'] );
            my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');

            # create AuthObject
            my $AuthObject = $Kernel::OM->Get('Kernel::System::CustomerAuth');
            if ( $AuthObject->GetOption( What => 'PreAuth' ) ) {

                # automatic re-login
                $Param{RequestedURL} = $LayoutObject->LinkEncode( $Param{RequestedURL} );

                my $PreAuth = $AuthObject->PreAuth(
                    RequestedURL => $Param{RequestedURL},
                );

                if ( $PreAuth && $PreAuth->{RedirectURL} ) {

                    if ( $ConfigObject->Get('SessionUseCookie') ) {

                        # always set a cookie, so that
                        # we know already if the browser supports cookies.
                        # ( the session cookie isn't available at that time ).

                        my $Expires = '+' . $ConfigObject->Get('SessionMaxTime') . 's';
                        if ( !$ConfigObject->Get('SessionUseCookieAfterBrowserClose') ) {
                            $Expires = '';
                        }

                        # set a cookie tentatively for checking cookie support
                        $LayoutObject->SetCookie(
                            Key     => 'OTOBOBrowserHasCookie',
                            Name    => 'OTOBOBrowserHasCookie',
                            Value   => 1,
                            Expires => $Expires,
                        );
                    }

                    $LayoutObject->Redirect(
                        ExtURL => $PreAuth->{RedirectURL},
                    );    # throws a Kernel::System::Web::Exception
                }

                $LayoutObject->Redirect(
                    OP => "?Action=PreLogin&RequestedURL=$Param{RequestedURL}",
                );        # throws a Kernel::System::Web::Exception
            }
            elsif ( $ConfigObject->Get('CustomerPanelLoginURL') ) {

                # redirect to alternate login
                $Param{RequestedURL} = $LayoutObject->LinkEncode( $Param{RequestedURL} );

                $LayoutObject->Redirect(
                    ExtURL => $ConfigObject->Get('CustomerPanelLoginURL')
                        . "?Reason=InvalidSessionID&RequestedURL=$Param{RequestedURL}",
                );        # throws a Kernel::System::Web::Exception
            }

            # show login
            return $LayoutObject->CustomerLogin(
                Title   => 'Login',
                Message =>
                    $LayoutObject->{LanguageObject}->Translate( $SessionObject->SessionIDErrorMessage() ),
                %Param,
            );
        }

        # get session data
        my %UserData = $SessionObject->GetSessionIDData(
            SessionID => $Param{SessionID},
        );

        $UserData{UserTimeZone} = $Self->_UserTimeZoneGet(%UserData);

        # check needed data
        if ( !$UserData{UserID} || !$UserData{UserLogin} || $UserData{UserType} ne 'Customer' ) {

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

            # redirect to alternate login
            if ( $ConfigObject->Get('CustomerPanelLoginURL') ) {
                $LayoutObject->Redirect(
                    ExtURL => $ConfigObject->Get('CustomerPanelLoginURL') . '?Reason=SystemError',
                );    # throws a Kernel::System::Web::Exception
            }

            # show login screen
            return $LayoutObject->CustomerLogin(
                Title   => 'Error',
                Message => Translatable('Error: invalid session.'),
                %Param,
            );
        }

        # check module registry
        my $ModuleReg = $ConfigObject->Get('CustomerFrontend::Module')->{ $Param{Action} };
        if ( !$ModuleReg ) {

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

            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  =>
                    "Module Kernel::Modules::$Param{Action} not registered in Kernel/Config.pm!",
            );

            $LayoutObject->CustomerFatalError(
                Comment => Translatable('Please contact the administrator.'),
            );    # throws a Kernel::System::Web::Exception
        }

        # module permission check for action
        if (
            ref $ModuleReg->{GroupRo} eq 'ARRAY'
            && !scalar @{ $ModuleReg->{GroupRo} }
            && ref $ModuleReg->{Group} eq 'ARRAY'
            && !scalar @{ $ModuleReg->{Group} }
            )
        {
            $Param{AccessRo} = 1;
            $Param{AccessRw} = 1;
        }
        else {

            ( $Param{AccessRo}, $Param{AccessRw} ) = $Self->_CheckModulePermission(
                ModuleReg => $ModuleReg,
                %UserData,
            );

            if ( !$Param{AccessRo} ) {

                # new layout object
                my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => 'No Permission to use this frontend action module!'
                );

                $LayoutObject->CustomerFatalError(
                    Comment => Translatable('Please contact the administrator.'),
                );    # throws a Kernel::System::Web::Exception
            }

        }

        my $NavigationConfig = $ConfigObject->Get('CustomerFrontend::Navigation')->{ $Param{Action} };

        # module permission check for submenu item
        if ( IsHashRefWithData($NavigationConfig) ) {

            KEY:
            for my $Key ( sort keys %{$NavigationConfig} ) {
                next KEY if $Key                 !~ m/^\d+/i;
                next KEY if $Param{RequestedURL} !~ m/Subaction/i;

                my @ModuleNavigationConfigs;

                # FIXME: Support both old (HASH) and new (ARRAY of HASH) navigation configurations, for reasons of
                #   backwards compatibility. Once we are sure everything has been migrated correctly, support for
                #   HASH-only configuration can be dropped in future major release.
                if ( IsHashRefWithData( $NavigationConfig->{$Key} ) ) {
                    push @ModuleNavigationConfigs, $NavigationConfig->{$Key};
                }
                elsif ( IsArrayRefWithData( $NavigationConfig->{$Key} ) ) {
                    push @ModuleNavigationConfigs, @{ $NavigationConfig->{$Key} };
                }

                # Skip incompatible configuration.
                else {
                    next KEY;
                }

                ITEM:
                for my $Item (@ModuleNavigationConfigs) {
                    if (
                        $Item->{Link} !~ m/Subaction=/i
                        || $Item->{Link} !~ m/$Param{Subaction}/i
                        )
                    {
                        next ITEM;
                    }
                    $Param{AccessRo} = 0;
                    $Param{AccessRw} = 0;

                    # module permission check for submenu item
                    if (
                        ref $Item->{GroupRo} eq 'ARRAY'
                        && !scalar @{ $Item->{GroupRo} }
                        && ref $Item->{Group} eq 'ARRAY'
                        && !scalar @{ $Item->{Group} }
                        )
                    {
                        $Param{AccessRo} = 1;
                        $Param{AccessRw} = 1;
                    }
                    else {

                        ( $Param{AccessRo}, $Param{AccessRw} ) = $Self->_CheckModulePermission(
                            ModuleReg => $Item,
                            %UserData,
                        );

                        if ( !$Param{AccessRo} ) {

                            # new layout object
                            my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
                            $Kernel::OM->Get('Kernel::System::Log')->Log(
                                Priority => 'error',
                                Message  => 'No Permission to use this frontend subaction module!'
                            );

                            $LayoutObject->CustomerFatalError(
                                Comment => Translatable('Please contact the administrator.')
                            );    # throws a Kernel::System::Web::Exception
                        }
                    }
                }
            }
        }

        # create new LayoutObject with new '%Param' and '%UserData'
        $Kernel::OM->ObjectParamAdd(
            'Kernel::Output::HTML::Layout' => {
                %Param,
                %UserData,
                ModuleReg => $ModuleReg,
            },
        );

        $Kernel::OM->ObjectsDiscard( Objects => ['Kernel::Output::HTML::Layout'] );

        # update last request time
        if (
            !$ParamObject->IsAJAXRequest()
            || $Param{Action} eq 'CustomerVideoChat'
            )
        {
            my $DateTimeObject = $Kernel::OM->Create('Kernel::System::DateTime');

            $SessionObject->UpdateSessionID(
                SessionID => $Param{SessionID},
                Key       => 'UserLastRequest',
                Value     => $DateTimeObject->ToEpoch(),
            );
        }

        # pre application module
        my $PreModule = $ConfigObject->Get('CustomerPanelPreApplicationModule');
        if ( $Param{Action} ne 'CustomerGenericContent' && $PreModule ) {
            my %PreModuleList;
            if ( ref $PreModule eq 'HASH' ) {
                %PreModuleList = %{$PreModule};
            }
            else {
                $PreModuleList{Init} = $PreModule;
            }

            MODULE:
            for my $PreModuleKey ( sort keys %PreModuleList ) {
                my $PreModule = $PreModuleList{$PreModuleKey};
                next MODULE if !$PreModule;
                next MODULE if !$Kernel::OM->Get('Kernel::System::Main')->Require($PreModule);

                # debug info
                if ( $Self->{Debug} ) {
                    $Kernel::OM->Get('Kernel::System::Log')->Log(
                        Priority => 'debug',
                        Message  => "CustomerPanelPreApplication module $PreModule is used.",
                    );
                }

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

                # use module
                my $PreModuleObject = $PreModule->new(
                    %Param,
                    %UserData,

                );
                my $Output = $PreModuleObject->PreRun();

                return $Output if $Output;
            }
        }

        # debug info
        if ( $Self->{Debug} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'debug',
                Message  => 'Kernel::Modules::' . $Param{Action} . '->new',
            );
        }

        my $FrontendObject = ( 'Kernel::Modules::' . $Param{Action} )->new(
            %Param,
            %UserData,
            ModuleReg => $ModuleReg,
            Debug     => $Self->{Debug},
        );

        # debug info
        if ( $Self->{Debug} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'debug',
                Message  => 'Kernel::Modules::' . $Param{Action} . '->run',
            );
        }

        # ->Run $Action with $FrontendObject
        my $Output = $FrontendObject->Run();

        # log request time for AdminPerformanceLog
        if ( $ConfigObject->Get('PerformanceLog') ) {
            my $File = $ConfigObject->Get('PerformanceLog::File');

            # Write to PerformanceLog file only if it is smaller than size limit (see bug#14747).
            if ( -s $File < ( 1024 * 1024 * $ConfigObject->Get('PerformanceLog::FileMax') ) ) {
                if ( open my $Out, '>>', $File ) {    ## no critic qw(OTOBO::ProhibitOpen)

                    # a fallback for the query string when the action is missing
                    if ( ( !$QueryString && $Param{Action} ) || $QueryString !~ /Action=/ ) {
                        $QueryString = 'Action=' . $Param{Action} . ';Subaction=' . $Param{Subaction};
                    }

                    my $Now = Time::HiRes::time();
                    print $Out join '::',
                        $Now,
                        'Customer',
                        ( $Now - $Self->{PerformanceLogStart} ),
                        $UserData{UserLogin},    # not used in the AdminPerformanceLog frontend
                        "$QueryString\n";
                    close $Out;

                    $Kernel::OM->Get('Kernel::System::Log')->Log(
                        Priority => 'debug',
                        Message  => 'Response::Customer: '
                            . ( $Now - $Self->{PerformanceLogStart} )
                            . "s taken (URL:$QueryString:$UserData{UserLogin})",
                    );
                }
                else {
                    $Kernel::OM->Get('Kernel::System::Log')->Log(
                        Priority => 'error',
                        Message  => "Can't write $File: $!",
                    );
                }
            }
            else {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => "PerformanceLog file '$File' is too large, you need to reset it in PerformanceLog page!",
                );
            }
        }

        return $Output;
    }

    # throws a Kernel::System::Web::Exception
    my %Data = $SessionObject->GetSessionIDData(
        SessionID => $Param{SessionID},
    );
    $Data{UserTimeZone} = $Self->_UserTimeZoneGet(%Data);
    $Kernel::OM->ObjectParamAdd(
        'Kernel::Output::HTML::Layout' => {
            %Param,
            %Data,
        },
    );

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

    $LayoutObject->CustomerFatalError(
        Comment => Translatable('Please contact the administrator.'),
    );
}

=head2 Response()

Generate a PSGI Response object from the content generated by C<Content()>.

    my $Response = $Interface->Response();

=cut

sub Response {
    my ($Self) = @_;

    # Note that the layout object mustn't be created before calling Content().
    # This is because Content() might want to set object params before the initial creations.
    # A notable example is the SetCookies parameter.
    my $Content = $Self->Content();

    # The filtered content is a string, regardless of whether the original content is
    # a string, an array reference, or a file handle.
    my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
    $Content = $LayoutObject->ApplyOutputFilters( Output => $Content );

    # The HTTP headers of the OTOBO web response object already have been set up.
    # Enhance it with the HTTP status code and the content.
    return $Kernel::OM->Get('Kernel::System::Web::Response')->Finalize( Content => $Content );
}

=begin Internal:

=head2 _StoreFailedLogins()

=cut

sub _StoreFailedLogins {
    my ( $Self, %Param ) = @_;
    my $CurrentTimeObject   = $Kernel::OM->Create('Kernel::System::DateTime');
    my $CurrentNewTimeStamp = $CurrentTimeObject->ToString();
    my $CacheObject         = $Kernel::OM->Get('Kernel::System::Cache');
    my $CheckHash           = $CacheObject->Get(
        Type => 'FailedLoginsCustomer',
        Key  => $Param{PostUser},
    );

    if ( !$CheckHash ) {
        $CacheObject->Set(
            Type  => 'FailedLoginsCustomer',
            Key   => $Param{PostUser},
            Value => [$CurrentNewTimeStamp],
            TTL   => $Param{PreventBruteForceConfig}{KeepCacheDuration},
        );

        return 0;
    }

    my @LoginTryArray = @{$CheckHash};

    # delete expired cache entries
    LOGIN:
    for my $LoginTime ( @{$CheckHash} ) {
        my $LoginTimeObject = $Kernel::OM->Create(
            'Kernel::System::DateTime',
            ObjectParams => {
                String => $LoginTime,
            },
        );
        my $Offset = $CurrentTimeObject->Delta(
            DateTimeObject => $LoginTimeObject,
        );

        if ( $Offset->{AbsoluteSeconds} > $Param{PreventBruteForceConfig}->{KeepCacheDuration} ) {
            shift @LoginTryArray;
        }
        else {
            last LOGIN;
        }
    }

    # add new failed login to cache
    push @LoginTryArray, $CurrentNewTimeStamp;
    $CacheObject->Set(
        Type  => 'FailedLoginsCustomer',
        Key   => $Param{PostUser},
        Value => \@LoginTryArray,
        TTL   => $Param{PreventBruteForceConfig}{KeepCacheDuration},
    );

    if ( scalar @LoginTryArray >= $Param{PreventBruteForceConfig}{MaxAttempt} ) {
        $CacheObject->Set(
            Type  => 'BannedLoginsCustomer',
            Key   => $Param{PostUser},
            Value => $CurrentNewTimeStamp,
            TTL   => $Param{PreventBruteForceConfig}{BanDuration},
        );
        return 1;
    }

    return 0;
}

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

    # get cache
    my $CacheObject = $Kernel::OM->Get('Kernel::System::Cache');

    my $BanTime = $CacheObject->Get(
        Type => 'BannedLoginsCustomer',
        Key  => $Param{PostUser},
    );

    if ( !$BanTime ) {
        return (
            Banned => 0,
        );
    }

    # calculate elapsed time
    my $CurTimeObject = $Kernel::OM->Create('Kernel::System::DateTime');
    my $BanTimeObject = $Kernel::OM->Create(
        'Kernel::System::DateTime',
        ObjectParams => {
            String => $BanTime,
        },
    );
    my $Offset = $CurTimeObject->Delta(
        DateTimeObject => $BanTimeObject,
    );

    # if the ban duration has been surpassed, delete the cache entry
    if ( $Offset->{AbsoluteSeconds} > $Param{PreventBruteForceConfig}{BanDuration} ) {
        $CacheObject->Delete(
            Type => 'BannedLoginsCustomer',
            Key  => $Param{PostUser},
        );
        return (
            Banned => 0,
        );
    }

    return (
        Banned       => 1,
        ResidualTime => $Param{PreventBruteForceConfig}{BanDuration} - $Offset->{AbsoluteSeconds},
    );
}

=head2 _CheckModulePermission()

module permission check

    ($AccessRo, $AccessRw = $AutoResponseObject->_CheckModulePermission(
        ModuleReg => $ModuleReg,
        %UserData,
    );

=cut

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

    my $AccessRo = 0;
    my $AccessRw = 0;

    PERMISSION:
    for my $Permission (qw(GroupRo Group)) {
        my $AccessOk = 0;
        my $Group    = $Param{ModuleReg}->{$Permission};

        next PERMISSION if !$Group;

        my $GroupObject = $Kernel::OM->Get('Kernel::System::CustomerGroup');

        if ( IsArrayRefWithData($Group) ) {
            GROUP:
            for my $Item ( @{$Group} ) {
                next GROUP if !$Item;
                next GROUP if !$GroupObject->PermissionCheck(
                    UserID    => $Param{UserID},
                    GroupName => $Item,
                    Type      => $Permission eq 'GroupRo' ? 'ro' : 'rw',
                );

                $AccessOk = 1;
                last GROUP;
            }
        }
        else {
            my $HasPermission = $GroupObject->PermissionCheck(
                UserID    => $Param{UserID},
                GroupName => $Group,
                Type      => $Permission eq 'GroupRo' ? 'ro' : 'rw',
            );
            if ($HasPermission) {
                $AccessOk = 1;
            }
        }
        if ( $Permission eq 'Group' && $AccessOk ) {
            $AccessRo = 1;
            $AccessRw = 1;
        }
        elsif ( $Permission eq 'GroupRo' && $AccessOk ) {
            $AccessRo = 1;
        }
    }

    return ( $AccessRo, $AccessRw );
}

=head2 _UserTimeZoneGet()

Get time zone for the current user. This function will validate passed time zone parameter and return default user time
zone if it's not valid.

    my $UserTimeZone = $Self->_UserTimeZoneGet(
        UserTimeZone => 'Europe/Berlin',
    );

=cut

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

    my $UserTimeZone;

    # Return passed time zone only if it's valid. It can happen that user preferences or session store an old-style
    #   offset which is not valid anymore. In this case, return the default value.
    #   Please see bug#13374 for more information.
    if (
        $Param{UserTimeZone}
        && Kernel::System::DateTime->IsTimeZoneValid( TimeZone => $Param{UserTimeZone} )
        )
    {
        $UserTimeZone = $Param{UserTimeZone};
    }

    $UserTimeZone ||= Kernel::System::DateTime->UserDefaultTimeZoneGet();

    return $UserTimeZone;
}

=end Internal:

=cut

1;
 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 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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::CustomerAuth::OneTimeAuthLink;

use strict;
use warnings;
use utf8;

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::System::CustomerUser',
    'Kernel::System::DB',
    'Kernel::System::Email',
    'Kernel::System::Log',
    'Kernel::System::Main',
    'Kernel::System::NotificationEvent',
    'Kernel::System::TemplateGenerator',
    'Kernel::System::Ticket',
);

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

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

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

    $Self->{Table} = 'ota_tokens';

    return $Self;
}

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

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

    # module options
    my %Option = (
        PreAuth => 0,
    );

    # return option
    return $Option{ $Param{What} };
}

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

    return qw/OTAToken/;
}

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

    # check needed stuff
    if ( !$Param{OTAToken} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'debug',
            Message  => "No Token provided!"
        );
        return;
    }

    $Self->{DBObject}->Prepare(
        SQL  => "SELECT used,user,ticket_number FROM $Self->{Table} WHERE token = ?",
        Bind => [ \$Param{OTAToken} ],
    );

    my @Row = $Self->{DBObject}->FetchrowArray();
    my ( $Used, $User, $TicketNumber ) = (0);

    if (@Row) {
        ( $Used, $User, $TicketNumber ) = @Row;
    }

    if ( !$Used || !$User ) {
        return {
            Error => $Kernel::OM->Get('Kernel::Config')->Get('OneTimeAuth::CustomerErrorMessageLinkExpired') || 'Ihr Link verweist auf kein noch gültiges Ticket.',
        };
    }

    my $CustomerUserObject = $Kernel::OM->Get('Kernel::System::CustomerUser');

    # send out new email if the ticket is still considered active but no current link exists
    if ( $Used == 1 ) {

        # store failed login count
        my %CustomerData = $CustomerUserObject->CustomerUserDataGet( User => $Param{User} );
        if (%CustomerData) {
            my $Count = $CustomerData{UserLoginFailed} || 0;
            $Count++;
            $CustomerUserObject->SetPreferences(
                Key    => 'UserLoginFailed',
                Value  => $Count,
                UserID => $CustomerData{UserLogin},
            );
        }

        # check whether active login link still exists
        $Self->{DBObject}->Prepare(
            SQL  => "SELECT user FROM $Self->{Table} WHERE ticket_number = ? AND used = ?",
            Bind => [ \$TicketNumber, \2 ],
        );

        if ( $Self->{DBObject}->FetchrowArray() ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'debug',
                Message  => "CustomerUser '$User' tried to log in with an old token. New token exists - nothing to do."
            );

            return {
                Error => $Kernel::OM->Get('Kernel::Config')->Get('OneTimeAuth::CustomerErrorMessageWrongLink')
                    || 'Aus Sicherheitsgründen müssen Sie den neuesten Ihnen zugesandten Link nutzen um auf dieses Ticket zuzugreifen.',
            };
        }
        else {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'debug',
                Message  => "CustomerUser '$User' tried to log in with an old token. No active token left - sending a new one via mail."
            );

            $Self->SendNewToken(
                User         => $User,
                TicketNumber => $TicketNumber,
            );

            return {
                Error => $Kernel::OM->Get('Kernel::Config')->Get('OneTimeAuth::CustomerErrorMessageNewLink')
                    || 'Ihre Session ist leider abgelaufen - ein neuer Link wurde an Ihre Email-Adresse gesendet.',
            };
        }
    }
    elsif ( $Used == 2 ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'debug',
            Message  => "CustomerUser '$User' logged in via token."
        );

        $Self->DeactivateTicketTokens(
            TicketNumber => $TicketNumber,
        );

        return $User;
    }

    return;
}

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

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

    # deactivate all other tokens for this ticket
    $Self->DeactivateTicketTokens(
        TicketNumber => $Param{TicketNumber},
    );

    my $OTATokenLength = 24;
    my $RandomString;

    my $Try = 1;
    while ($Try) {
        $RandomString = $Kernel::OM->Get('Kernel::System::Main')->GenerateRandomString(
            Length => $OTATokenLength,
        );

        # check whether the string already exists
        $Self->{DBObject}->Prepare(
            SQL  => "SELECT user FROM $Self->{Table} WHERE token = ?",
            Bind => [ \$Param{OTAToken} ],
        );

        if ( $Self->{DBObject}->FetchrowArray() ) {
            $Try++;
        }
        else {
            $Try = 0;
        }

        if ( $Try > 5 ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Could not generate a unique random string after five retries - something is not right!"
            );
            return;
        }
    }

    return if !$Self->{DBObject}->Do(
        SQL => "INSERT INTO $Self->{Table} ( token, ticket_number, used, user, create_time, change_time )
            VALUES ( ?, ?, ?, ?, current_timestamp, current_timestamp )",
        Bind => [ \$RandomString, \$Param{TicketNumber}, \2, \$Param{User} ],
    );

    return $RandomString;
}

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

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

    return if !$Self->{DBObject}->Do(
        SQL  => "UPDATE $Self->{Table} SET used = 1, change_time = current_timestamp WHERE ticket_number = ? AND used = 2",
        Bind => [ \$Param{TicketNumber} ],
    );

    return 1;
}

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

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

    return if !$Self->{DBObject}->Do(
        SQL  => "DELETE FROM $Self->{Table} WHERE ticket_number = ?",
        Bind => [ \$Param{TicketNumber} ],
    );

    return 1;
}

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

    my $ConfigObject = $Kernel::OM->Get('Kernel::Config');

    # check needed stuff
    for my $Needed (qw/TicketNumber User/) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!"
            );

            return $ConfigObject->Get('OneTimeAuth::CustomerErrorMessageRefreshFailed') // 'Link could not be generated, please contact us directly!';
        }
    }

    my $TicketLink = $ConfigObject->Get('HttpType') . '://' . $ConfigObject->Get('FQDN') . '/otobo/customer.pl';
    $TicketLink .= "?Action=CustomerTicketZoom;TicketNumber=$Param{TicketNumber}";

    # check if the user already has a passsword - then no direct link is needed
    my %User = $Kernel::OM->Get('Kernel::System::CustomerUser')->CustomerUserDataGet(
        User => $Param{User},
    );

    if ( !$User{UserPassword} ) {

        # generate token
        my $Token = $Self->GenerateToken(
            %Param,
        );

        if ( !$Token ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Error in token generation!"
            );

            return $ConfigObject->Get('OneTimeAuth::CustomerErrorMessage') // 'Link could not be generated, please contact us directly!';
        }

        $TicketLink .= ";OTAToken=$Token";
    }

    return "<a href='$TicketLink' target='_blank'>$TicketLink</a>";
}

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

    my $ConfigObject = $Kernel::OM->Get('Kernel::Config');
    my $TicketObject = $Kernel::OM->Get('Kernel::System::Ticket');

    # get the compare time if a delay is given
    my $Delay       = $Kernel::OM->Get('Kernel::Config')->Get('OneTimeAuth::AccessDaysAfterClose') || 0;
    my $StillOKTime = $Kernel::OM->Create('Kernel::System::DateTime')->ToEpoch() - 24 * 60 * 60 * $Delay;

    $Self->{DBObject}->Prepare(
        SQL => "SELECT DISTINCT(ticket_number) FROM $Self->{Table}",
    );

    my @TicketNumbers;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        push @TicketNumbers, $Row[0];
    }

    TICKET:
    for my $TN (@TicketNumbers) {
        my $TicketID = $TicketObject->TicketIDLookup(
            TicketNumber => $TN,
        );

        my %Ticket = $TicketObject->TicketGet(
            TicketID => $TicketID,
        );

        # remove old tokens
        if ( $Ticket{StateType} eq 'closed' || $Ticket{StateType} eq 'removed' || $Ticket{StateType} eq 'merged' ) {
            if ($Delay) {
                my $LastChangedTime = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String => $Ticket{Changed},
                    }
                )->ToEpoch();

                next TICKET if $LastChangedTime > $StillOKTime;
            }

            $Self->DeleteTicketTokens(
                TicketNumber => $TN,
            );
        }
    }

    return 1;
}

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

    # check needed stuff
    for my $Needed (qw/TicketNumber User/) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!"
            );

            return;
        }
    }

    my $ConfigObject       = $Kernel::OM->Get('Kernel::Config');
    my $CustomerUserObject = $Kernel::OM->Get('Kernel::System::CustomerUser');
    my $TicketObject       = $Kernel::OM->Get('Kernel::System::Ticket');

    my $TicketID = $TicketObject->TicketIDLookup(
        TicketNumber => $Param{TicketNumber},
    );
    my %Ticket = $TicketObject->TicketGet(
        TicketID => $TicketID,
    );
    my %User = $Kernel::OM->Get('Kernel::System::CustomerUser')->CustomerUserDataGet(
        User => $Param{User},
    );

    my $TemplateGenerator = $Kernel::OM->Get('Kernel::System::TemplateGenerator');
    my $Sender            = $TemplateGenerator->Sender(
        QueueID => $Ticket{QueueID},
        UserID  => 1,
    );

    my $NotificationID = $ConfigObject->Get('OneTimeAuth::TokenRefreshNotificationID');

    my ( $Body, $Subject );

    if ($NotificationID) {
        my %Notification = $Kernel::OM->Get('Kernel::System::NotificationEvent')->NotificationGet(
            ID => $NotificationID,
        );

        my %Languages = map { $_ => $_ } @{ $Notification{Data}{LanguageID} };
        my $Language  = $Languages{de} || $Languages{en} || $Notification{Data}{LanguageID}[0];

        # replace place holder stuff
        $Body = $TemplateGenerator->_Replace(
            RichText   => $ConfigObject->Get('Frontend::RichText'),
            Text       => $Notification{Message}{$Language}{Body},
            Data       => {},
            TicketData => \%Ticket,
            UserID     => 1,
        );

        $Subject = $TemplateGenerator->_Replace(
            RichText   => 0,
            Text       => $Notification{Message}{$Language}{Subject},
            Data       => {},
            TicketData => \%Ticket,
            UserID     => 1,
        );
    }

    else {
        my $TicketLink = $Self->TicketLink(%Param);

        $Subject = "Neuer Authentifizierungslink für Ticket#$Ticket{TicketNumber}";
        $Body    = "Guten Tag<br/>Ihr aktueller Link um auf Ticket#$Ticket{TicketNumber} zugreifen zu können lautet:<br/>$TicketLink";
    }

    my $EmailObject = $Kernel::OM->Get('Kernel::System::Email');
    my $Sent        = $EmailObject->Send(
        From     => $Sender,
        To       => $User{UserEmail},
        Subject  => $Subject,
        Charset  => 'utf-8',
        MimeType => 'text/html',
        Body     => $Body,
    );

    if ( !$Sent ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Could not send new token to $Param{User} for Ticket#$Param{TicketNumber}!"
        );

        return;
    }

    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-2025 Rother OSS GmbH, https://otobo.io/
# --
# 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::PostMaster::Filter::CreateNewCustomerUser;

use strict;
use warnings;

use Kernel::System::VariableCheck qw(:all);

our @ObjectDependencies = (
    'Kernel::System::CustomerUser',
    'Kernel::System::Log',
);

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

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

    # get parser object
    $Self->{ParserObject} = $Param{ParserObject} || die "Got no ParserObject!";

    # Get communication log object.
    $Self->{CommunicationLogObject} = $Param{CommunicationLogObject} || die "Got no CommunicationLogObject!";

    return $Self;
}

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

    # only needed for new tickets
    return 1 if $Param{TicketID};

    # check needed stuff
    for (qw(GetParam JobConfig)) {
        if ( !$Param{$_} ) {
            $Self->{CommunicationLogObject}->ObjectLog(
                ObjectLogType => 'Message',
                Priority      => 'Error',
                Key           => 'Kernel::System::PostMaster::Filter::CreateNewCustomerUser',
                Value         => "Need $_!",
            );
            return;
        }
    }

    my @EmailAddressOnField = $Self->{ParserObject}->SplitAddressLine(
        Line => $Self->{ParserObject}->GetParam( WHAT => 'From' ),
    );

    my $IncomingMailAddress;

    for my $EmailAddress (@EmailAddressOnField) {
        $IncomingMailAddress = $Self->{ParserObject}->GetEmailAddress(
            Email => $EmailAddress,
        );
    }

    return 1 if !$IncomingMailAddress;

    my $CustomerUserObject = $Kernel::OM->Get('Kernel::System::CustomerUser');

    my %List = $CustomerUserObject->CustomerSearch(
        PostMasterSearch => lc($IncomingMailAddress),
        Valid            => 0,
    );

    # user already exists
    if (%List) {

        # return if no X-OTOBO-CustomerUser spoofing is possible/dangerous
        return 1 if !$Param{JobConfig}{CustomerHeaderSpoofProtection} && !$Param{JobConfig}{SetCheckBoxName};

        my %CustomerData;
        LOGIN:
        for my $UserLogin ( sort keys %List ) {
            my %CustomerUser = $CustomerUserObject->CustomerUserDataGet(
                User => $UserLogin,
            );

            if ( $CustomerUser{ValidID} == 1 ) {
                %CustomerData = %CustomerUser;
                last LOGIN;
            }
        }

        # if user exists but is not valid, do nothing
        return 1 if !%CustomerData;

        if ( $Param{JobConfig}{SetCheckBoxName} && $CustomerData{Source} eq ( $Param{JobConfig}{CustomerUserBackend} || 'CustomerUser' ) ) {
            $Param{GetParam}{ 'X-OTOBO-DynamicField-' . $Param{JobConfig}{SetCheckBoxName} } = 1;
        }

        return 1 if !$Param{JobConfig}{CustomerHeaderSpoofProtection};

        # take CustomerID from customer backend lookup or from from field
        if ( $CustomerData{UserLogin} ) {
            $Param{GetParam}{'X-OTOBO-CustomerUser'} = $CustomerData{UserLogin};

            # notice that UserLogin is from customer source backend
            $Self->{CommunicationLogObject}->ObjectLog(
                ObjectLogType => 'Message',
                Priority      => 'Notice',
                Key           => 'Kernel::System::PostMaster::Filter::CreateNewCustomerUser',
                Value         => "Take UserLogin ($CustomerData{UserLogin}) from "
                    . "customer source backend based on ($IncomingMailAddress).",
            );
        }
        if ( $CustomerData{UserCustomerID} ) {
            $Param{GetParam}{'X-OTOBO-CustomerNo'} = $CustomerData{UserCustomerID};

            # notice that UserCustomerID is from customer source backend
            $Self->{CommunicationLogObject}->ObjectLog(
                ObjectLogType => 'Message',
                Priority      => 'Notice',
                Key           => 'Kernel::System::PostMaster::Filter::CreateNewCustomerUser',
                Value         => "Take UserCustomerID ($CustomerData{UserCustomerID})"
                    . " from customer source backend based on ($IncomingMailAddress).",
            );
        }
    }

    # user does not yet exist - create it!
    else {
        my $UserLogin = lc($IncomingMailAddress);

        my $Success = $CustomerUserObject->CustomerUserAdd(
            Source         => $Param{JobConfig}{CustomerUserBackend} || 'CustomerUser',
            UserFirstname  => ' ',
            UserLastname   => ' ',
            UserCustomerID => $UserLogin,
            UserLogin      => $UserLogin,
            UserEmail      => $UserLogin,
            ValidID        => 1,
            UserID         => 1,
        );

        if ($Success) {

            # notice that UserLogin is from customer source backend
            $Self->{CommunicationLogObject}->ObjectLog(
                ObjectLogType => 'Message',
                Priority      => 'Notice',
                Key           => 'Kernel::System::PostMaster::Filter::CreateNewCustomerUser',
                Value         => "Create and set new UserLogin ($UserLogin).",
            );

            $Param{GetParam}{'X-OTOBO-CustomerUser'} = $UserLogin;
            $Param{GetParam}{'X-OTOBO-CustomerNo'}   = $UserLogin;

            if ( $Param{JobConfig}{SetCheckBoxName} ) {
                $Param{GetParam}{ 'X-OTOBO-DynamicField-' . $Param{JobConfig}{SetCheckBoxName} } = 1;
            }

            # set preferences
            $CustomerUserObject->SetPreferences(
                UserID => $UserLogin,
                Key    => 'UserTimeZone',
                Value  => 'Europe/Berlin',
            );
            $CustomerUserObject->SetPreferences(
                UserID => $UserLogin,
                Key    => 'UserShowTickets',
                Value  => '25',
            );
            $CustomerUserObject->SetPreferences(
                UserID => $UserLogin,
                Key    => 'UserRefreshTime',
                Value  => '0',
            );
        }
    }

    return 1;
}

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