OTOBO-AI 11.0.30 Rother OSS GmbH https://otobo.io/ GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 First stable release for 11.0. Otobo AI Interface package to connect to Otobo AI Services. 11.0.x In order for FAQ items to by dynamically synchronized with the Otobo-AI vector DB, please make sure to install the optional Elasticsearch-FAQ package to provide the necessary FAQ event handling. Damit FAQ Artikel dynamisch mit der Otobo-AI Vector DB synchronisiert werden können, installieren Sie bitte das optionale Elasticsearch-FAQ Paket, um das notwendige FAQ Event Handling bereitzustellen. # create the package name my $CodeModule = 'var::packagesetup::OTOBOAI'; $Kernel::OM->Get($CodeModule)->CodeInstall(); # create the package name my $CodeModule = 'var::packagesetup::OTOBOAI'; $Kernel::OM->Get($CodeModule)->CodeUpgrade(); # create the package name my $CodeModule = 'var::packagesetup::OTOBOAI'; $Kernel::OM->Get($CodeModule)->CodeUninstall(); b8c303e417deebed5540687d1f648cd2265ac320 2026-10-28 15:06:15 opms.rother-oss.com # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - 6efdc7bf2a3325277cd79a60f0f2407f8ad59e87 - Kernel/Output/HTML/ArticleAction/AgentTicketCompose.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::Output::HTML::ArticleAction::AgentTicketCompose;

use strict;
use warnings;

use Kernel::Language qw(Translatable);

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::Output::HTML::Layout',
    'Kernel::System::Log',
    'Kernel::System::Queue',
    'Kernel::System::SystemAddress',
    'Kernel::System::Ticket',
# Rother OSS / OTOBO-AI
    'Kernel::System::DynamicField',
    'Kernel::System::DynamicField::Backend',
# EO OTOBO-AI
);

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

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

    return $Self;
}

# optional AclActionLookup
sub CheckAccess {
    my ( $Self, %Param ) = @_;

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

    if ( $Param{ChannelName} eq 'Email' && $Param{Article}->{SenderType} eq 'system' ) {

        # skip email notifications
        return;
    }

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

    # check if module is registered
    return if !$ConfigObject->Get('Frontend::Module')->{AgentTicketCompose};

    # check Acl
    return if !$Param{AclActionLookup}->{AgentTicketCompose};

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

    my $Config = $ConfigObject->Get('Ticket::Frontend::AgentTicketCompose');
    if ( $Config->{Permission} ) {
        my $Ok = $TicketObject->TicketPermission(
            Type     => $Config->{Permission},
            TicketID => $Param{Ticket}->{TicketID},
            UserID   => $Param{UserID},
            LogNo    => 1,
        );
        return if !$Ok;
    }
    if ( $Config->{RequiredLock} ) {
        my $Locked = $TicketObject->TicketLockGet(
            TicketID => $Param{Ticket}->{TicketID}
        );
        if ($Locked) {
            my $AccessOk = $TicketObject->OwnerCheck(
                TicketID => $Param{Ticket}->{TicketID},
                OwnerID  => $Param{UserID},
            );
            return if !$AccessOk;
        }
    }

    return 1;
}

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

    # Check needed stuff.
    for my $Needed (qw(Ticket Article StandardTemplates Type UserID)) {
        if ( !$Param{$Needed} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Needed!",
            );
            return;
        }
    }

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

    # get StandardResponsesStrg
    # my %StandardResponseHash = %{ $Param{StandardResponses} || {} };
    my %StandardResponseHash = %{ $Param{StandardTemplates}->{Answer} || {} };

# Rother OSS / OTOBO-AI
    # retrieve the aricle's OTOBOAI dynamic field value
    my $DynamicFieldName = $Kernel::OM->Get('Kernel::Config')->Get('OTOBOAI::DynamicFieldOTOBOAI') || 'OTOBOAI';

    my $OTOBOAIDFConfig = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldGet(
        Name => $DynamicFieldName,
    );
    my $OTOBOAIValue = $Kernel::OM->Get('Kernel::System::DynamicField::Backend')->ValueGet(
        DynamicFieldConfig => $OTOBOAIDFConfig,
        ObjectID           => $Param{Article}->{ArticleID},
    ) || '';

    # remove OTOBOAI answer template if the dynamic field holds the empty answer token
    my $EmptyAnswerToken = $Kernel::OM->Get('Kernel::Config')->Get('OTOBOAI::DynamicFieldOTOBOAI::EmptyAnswerToken');
    if ( $EmptyAnswerToken && $OTOBOAIValue eq $EmptyAnswerToken ) {
        delete @StandardResponseHash{ grep { $StandardResponseHash{$_} eq 'OTOBOAI Answer Template' } keys %StandardResponseHash };
    }
# EO OTOBO-AI
    # get revers StandardResponseHash because we need to sort by Values
    # from %ReverseStandardResponseHash we get value of Key by %StandardResponseHash Value
    # and @StandardResponseArray is created as array of hashes with elements Key and Value

    my %ReverseStandardResponseHash = reverse %StandardResponseHash;
    my @StandardResponseArray       = map {
        {
            Key   => $ReverseStandardResponseHash{$_},
            Value => $_
        }
    } sort values %StandardResponseHash;

    # use this array twice (also for Reply All), so copy it first
    my @StandardResponseArrayReplyAll = @StandardResponseArray;

    my @MenuItems;
    if (@StandardResponseArray) {

        # build HTML string
        my $StandardResponsesStrg = $LayoutObject->BuildSelection(
            Name         => 'ResponseID',
            ID           => 'ResponseID' . $Param{Article}->{ArticleID},
            Class        => 'Modernize Small',
            Data         => \@StandardResponseArray,
            PossibleNone => 1,
            Translation  => 1,
        );

        push @MenuItems, {
            ItemType              => 'Dropdown',
            DropdownType          => 'Reply',
            StandardResponsesStrg => $StandardResponsesStrg,
            Name                  => Translatable('Reply'),
            Class                 => 'AsPopup PopupType_TicketAction',
            Action                => 'AgentTicketCompose',
            FormID                => 'Reply' . $Param{Article}->{ArticleID},
            ResponseElementID     => 'ResponseID' . $Param{Article}->{ArticleID},
            Type                  => $Param{Type},
        };
    }

    # check if reply all is needed
    my $Recipients = '';
    KEY:
    for my $Key (qw(From To Cc)) {
        next KEY if !$Param{Article}->{$Key};
        if ($Recipients) {
            $Recipients .= ', ';
        }
        $Recipients .= $Param{Article}->{$Key};
    }
    my $RecipientCount = 0;
    if ($Recipients) {
        my $EmailParser = Kernel::System::EmailParser->new(
            %{$Self},
            Mode => 'Standalone',
        );
        my @Addresses = $EmailParser->SplitAddressLine( Line => $Recipients );
        ADDRESS:
        for my $Address (@Addresses) {
            my $Email = $EmailParser->GetEmailAddress( Email => $Address );
            next ADDRESS if !$Email;
            my $IsLocal = $Kernel::OM->Get('Kernel::System::SystemAddress')->SystemAddressIsLocalAddress(
                Address => $Email,
            );
            next ADDRESS if $IsLocal;
            $RecipientCount++;
        }
    }
    if ( @StandardResponseArrayReplyAll && $RecipientCount > 1 ) {

        my $StandardResponsesStrg = $LayoutObject->BuildSelection(
            Name         => 'ResponseID',
            ID           => 'ResponseIDAll' . $Param{Article}->{ArticleID},
            Class        => 'Modernize Small',
            Data         => \@StandardResponseArrayReplyAll,
            PossibleNone => 1,
            Translation  => 1,
        );

        push @MenuItems, {
            ItemType              => 'Dropdown',
            DropdownType          => 'Reply',
            StandardResponsesStrg => $StandardResponsesStrg,
            Name                  => Translatable('Reply All'),
            Class                 => 'AsPopup PopupType_TicketAction',
            Action                => 'AgentTicketCompose',
            FormID                => 'ReplyAll' . $Param{Article}->{ArticleID},
            ReplyAll              => 1,
            ResponseElementID     => 'ResponseIDAll' . $Param{Article}->{ArticleID},
            Type                  => $Param{Type},
        };
    }

    return @MenuItems;
}

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',
    'Kernel::System::DynamicField',
    'Kernel::System::DynamicField::Backend',
    'Kernel::System::Encode',
    'Kernel::System::HTMLUtils',
    'Kernel::System::Log',
# Rother OSS / OTOBO-AI
    'Kernel::System::OtoboAI',
# EO OTOBO-AI
    '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,
    );

# Rother OSS / OTOBO-AI
    # when template is of type Answer, replace AI tag
    if (
        $TemplateType eq 'Answer'
        && $Param{TicketID}
        && $Param{ArticleID}
    ) {

        # check if tag is present in the template first
        #   to prevent unnecessary request triggering
        my $Start = '<';
        my $End   = '>';
        if ( $Self->{RichText} ) {
            $Start = '&lt;';
            $End   = '&gt;';
        }
        my $AITag = $Start . 'OTOBO_AIAnswer_OTOBOAI' . $End;
        if ( $TemplateText =~ /$AITag/ ) {
            my $ConfigObject = $Kernel::OM->Get('Kernel::Config');
            my $DynamicFieldName = $ConfigObject->Get('OTOBOAI::DynamicFieldOTOBOAI') || 'OTOBOAI';
            my $OverwriteFlag    = $ConfigObject->Get('OTOBOAI::OverwritePreviousResponse') || 0;

            my $Placeholder = $ConfigObject->Get('OTOBOAI::Placeholder') || '<|waiting for AI answer|>';
            $Placeholder = $Kernel::OM->Get('Kernel::Output::HTML::Layout')->{LanguageObject}->Translate( $Placeholder );

            # fetch dynamic field value for article id
            my $OTOBOAIDFConfig = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldGet(
                Name => $DynamicFieldName,
            );
            if ( !IsHashRefWithData($OTOBOAIDFConfig) ) {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => "DynamicField '$DynamicFieldName' not found on the system!",
                );
                return;
            }
            my $OTOBOAIValue = '';
            if ( !$OverwriteFlag ) {
                $OTOBOAIValue = $Kernel::OM->Get('Kernel::System::DynamicField::Backend')->ValueGet(
                    DynamicFieldConfig => $OTOBOAIDFConfig,
                    ObjectID           => $Param{ArticleID},
                );
            }

            my $RequestType = $Kernel::OM->Get('Kernel::Config')->Get('OTOBOAI::AnswerTemplateRequestType') || 'Synchronous';
            if ( $RequestType eq 'Asynchronous' ) {
                # sure we want to start a new request if we have placeholder?
                if ( !$OTOBOAIValue ) { #|| $OTOBOAIValue eq $Placeholder ) {
                    $Kernel::OM->Get('Kernel::System::OtoboAI')->GetAnswerAsync(
                        ObjectID => $Param{ArticleID},
                    );

                    if ( !$OTOBOAIValue ) {
                        $Kernel::OM->Get('Kernel::System::DynamicField::Backend')->ValueSet(
                            DynamicFieldConfig => $OTOBOAIDFConfig,
                            ObjectID           => $Param{ArticleID},
                            Value              => $Placeholder,
                            DoWrite            => 1,
                            UserID             => $Param{UserID},
                        );
                        $OTOBOAIValue = $Placeholder;
                    }
                }
            }
            elsif ( $RequestType eq 'Synchronous' ) {
                if ( !$OTOBOAIValue || $OTOBOAIValue eq $Placeholder ) {

                    if ( !$OTOBOAIValue ) {
                        $Kernel::OM->Get('Kernel::System::DynamicField::Backend')->ValueSet(
                            DynamicFieldConfig => $OTOBOAIDFConfig,
                            ObjectID           => $Param{ArticleID},
                            Value              => $Placeholder,
                            DoWrite            => 1,
                            UserID             => $Param{UserID},
                        );
                    }
                    my $Result = $Kernel::OM->Get('Kernel::System::OtoboAI')->GetAnswer(
                        ObjectID => $Param{ArticleID},
                    );
                    if(IsHashRefWithData($Result) && IsHashRefWithData($Result->{Data})) {
                        $OTOBOAIValue = $Result->{Data}->{Answer};
                    }
                }
            }

            # check if LLM output is a token indicating an empty answer as specified in this setting
            my $EmptyAnswerToken = $Kernel::OM->Get('Kernel::Config')->Get('OTOBOAI::DynamicFieldOTOBOAI::EmptyAnswerToken');
            if ( $EmptyAnswerToken && $OTOBOAIValue eq $EmptyAnswerToken ) {
                $OTOBOAIValue = '';
            }

            my $HTMLValue = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToHTML(
                String => $OTOBOAIValue || '',
            );

            # replace <OTOBO_AIAnswer_DFName> tag
            $TemplateText =~ s/$AITag/$HTMLValue/g;
        }
    }
# EO OTOBO-AI

    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;

    # 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/AuthSession/FS.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::AuthSession::FS;

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

use strict;
use warnings;

use Kernel::Language qw(Translatable);

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::System::DateTime',
    'Kernel::System::Log',
    'Kernel::System::Main',
    'Kernel::System::Storable',
    'Kernel::System::Web::Request',
);

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

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

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

    # get more common params
    $Self->{SessionSpool} = $ConfigObject->Get('SessionDir');
    $Self->{SystemID}     = $ConfigObject->Get('SystemID');

    if ( !-e $Self->{SessionSpool} ) {
        if ( !mkdir( $Self->{SessionSpool}, 0770 ) ) {    ## no critic qw(ValuesAndExpressions::ProhibitLeadingZeros)
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Can't create directory '$Self->{SessionSpool}': $!",
            );
        }
    }

    return $Self;
}

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

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

    my $ParamObject = $Kernel::OM->Get('Kernel::System::Web::Request');
    my $RemoteAddr  = $Param{RemoteAddr} || $ParamObject->RemoteAddr() || 'none';

    # set default message
    $Self->{SessionIDErrorMessage} = Translatable('Session invalid. Please log in again.');

    # session id check
    my %Data = $Self->GetSessionIDData( SessionID => $Param{SessionID} );

    if ( !$Data{UserID} || !$Data{UserLogin} ) {
        $Self->{SessionIDErrorMessage} = Translatable('Session invalid. Please log in again.');
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'notice',
            Message  => "SessionID: '$Param{SessionID}' is invalid!!!",
        );
        return;
    }

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

    # remote ip check
    if (
        $Data{UserRemoteAddr} ne $RemoteAddr
        && $ConfigObject->Get('SessionCheckRemoteIP')
        )
    {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'notice',
            Message  => "RemoteIP of '$Param{SessionID}' ($Data{UserRemoteAddr}) is "
                . "different from registered IP ($RemoteAddr). Invalidating session!"
                . " Disable config 'SessionCheckRemoteIP' if you don't want this!",
        );

        # delete session id if it isn't the same remote ip?
        if ( $ConfigObject->Get('SessionDeleteIfNotRemoteID') ) {
            $Self->RemoveSessionID( SessionID => $Param{SessionID} );
        }

        return;
    }

    # check session idle time
    my $TimeNow            = $Kernel::OM->Create('Kernel::System::DateTime')->ToEpoch();
    my $MaxSessionIdleTime = $ConfigObject->Get('SessionMaxIdleTime');

    if ( ( $TimeNow - $MaxSessionIdleTime ) >= $Data{UserLastRequest} ) {

        $Self->{SessionIDErrorMessage} = Translatable('Session has timed out. Please log in again.');

        my $Timeout = int( ( $TimeNow - $Data{UserLastRequest} ) / ( 60 * 60 ) );

        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'notice',
            Message  =>
                "SessionID ($Param{SessionID}) idle timeout ($Timeout h)! Don't grant access!!!",
        );

        # delete session id if too old?
        if ( $ConfigObject->Get('SessionDeleteIfTimeToOld') ) {
            $Self->RemoveSessionID( SessionID => $Param{SessionID} );
        }

        return;
    }

    # check session time
    my $MaxSessionTime = $ConfigObject->Get('SessionMaxTime');

    if ( ( $TimeNow - $MaxSessionTime ) >= $Data{UserSessionStart} ) {

        $Self->{SessionIDErrorMessage} = Translatable('Session has timed out. Please log in again.');

        my $Timeout = int( ( $TimeNow - $Data{UserSessionStart} ) / ( 60 * 60 ) );

        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'notice',
            Message  => "SessionID ($Param{SessionID}) too old ($Timeout h)! Don't grant access!!!",
        );

        # delete session id if too old?
        if ( $ConfigObject->Get('SessionDeleteIfTimeToOld') ) {
            $Self->RemoveSessionID( SessionID => $Param{SessionID} );
        }

        return;
    }

    return 1;
}

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

    return $Self->{SessionIDErrorMessage} || '';
}

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

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

    # check cache
    return %{ $Self->{Cache}->{ $Param{SessionID} } }
        if $Self->{Cache}->{ $Param{SessionID} };

    # read data
    my $Content = $Kernel::OM->Get('Kernel::System::Main')->FileRead(
        Directory       => $Self->{SessionSpool},
        Filename        => 'Data-' . $Param{SessionID},
        Type            => 'Local',
        Mode            => 'binmode',
        DisableWarnings => 1,
    );

    return if !$Content;
    return if ref $Content ne 'SCALAR';

    # read data structure back from file dump, use block eval for safety reasons
    my $Session = eval {
        $Kernel::OM->Get('Kernel::System::Storable')->Deserialize( Data => ${$Content} );
    };

    if ( !$Session || ref $Session ne 'HASH' ) {
        delete $Self->{Cache}->{ $Param{SessionID} };
        return;
    }

    # cache result
    $Self->{Cache}->{ $Param{SessionID} } = $Session;

    return %{$Session};
}

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

    # get system time
    my $TimeNow = $Kernel::OM->Create('Kernel::System::DateTime')->ToEpoch();

    # get remote address and the http user agent
    my $ParamObject     = $Kernel::OM->Get('Kernel::System::Web::Request');
    my $RemoteAddr      = $ParamObject->RemoteAddr()         || 'none';
    my $RemoteUserAgent = $ParamObject->Header('User-Agent') || 'none';

    my $MainObject = $Kernel::OM->Get('Kernel::System::Main');

    # create session id
    my $SessionID = $Self->{SystemID} . $MainObject->GenerateRandomString(
        Length => 32,
    );

    # create challenge token
    my $ChallengeToken = $MainObject->GenerateRandomString(
        Length => 32,
    );

    my %Data;
    KEY:
    for my $Key ( sort keys %Param ) {

        next KEY if !$Key;

        $Data{$Key} = $Param{$Key};
    }

    $Data{UserSessionStart}    = $TimeNow;
    $Data{UserRemoteAddr}      = $RemoteAddr;
    $Data{UserRemoteUserAgent} = $RemoteUserAgent;
    $Data{UserChallengeToken}  = $ChallengeToken;

    # dump the data
    my $DataContent = $Kernel::OM->Get('Kernel::System::Storable')->Serialize( Data => \%Data );

    # write data file
    my $FileLocation = $MainObject->FileWrite(
        Directory       => $Self->{SessionSpool},
        Filename        => 'Data-' . $SessionID,
        Content         => \$DataContent,
        Type            => 'Local',
        Mode            => 'binmode',
        Permission      => '660',
        DisableWarnings => 1,
    );

    return if !$FileLocation;

    # set cache
    $Self->{Cache}->{$SessionID} = \%Data;

    # create needed state content
    my $UserType         = $Self->{Cache}->{$SessionID}->{UserType}         || '';
    my $UserLogin        = $Self->{Cache}->{$SessionID}->{UserLogin}        || '';
    my $UserSessionStart = $Self->{Cache}->{$SessionID}->{UserSessionStart} || '';
    my $UserLastRequest  = $Self->{Cache}->{$SessionID}->{UserLastRequest}  || '';
    my $SessionSource    = $Self->{Cache}->{$SessionID}->{SessionSource}    || '';

    my $StateContent = $UserType . '####' . $UserLogin . '####' . $UserSessionStart . '####' . $UserLastRequest;

    if ($SessionSource) {
        $StateContent .= '####' . $SessionSource;
    }

    # write state file
    $MainObject->FileWrite(
        Directory       => $Self->{SessionSpool},
        Filename        => 'State-' . $SessionID,
        Content         => \$StateContent,
        Type            => 'Local',
        Mode            => 'binmode',
        Permission      => '660',
        DisableWarnings => 1,
    );

    return $SessionID;
}

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

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

    my $MainObject = $Kernel::OM->Get('Kernel::System::Main');

    # delete file
    my $DeleteData = $MainObject->FileDelete(
        Directory       => $Self->{SessionSpool},
        Filename        => 'Data-' . $Param{SessionID},
        Type            => 'Local',
        DisableWarnings => 1,
    );
    my $DeleteState = $MainObject->FileDelete(
        Directory       => $Self->{SessionSpool},
        Filename        => 'State-' . $Param{SessionID},
        Type            => 'Local',
        DisableWarnings => 1,
    );

    return if !$DeleteData;
    return if !$DeleteState;

    delete $Self->{Cache}->{ $Param{SessionID} };

    $Kernel::OM->Get('Kernel::System::Log')->Log(
        Priority => 'notice',
        Message  => "Removed SessionID $Param{SessionID}."
    );

    return 1;
}

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

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

    # check cache
    if ( !$Self->{Cache}->{ $Param{SessionID} } ) {
        my %SessionData = $Self->GetSessionIDData( SessionID => $Param{SessionID} );

        $Self->{Cache}->{ $Param{SessionID} } = \%SessionData;
    }

    # update the value, set cache
    $Self->{Cache}->{ $Param{SessionID} }->{ $Param{Key} } = $Param{Value};

    return 1;
}

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

    # read data
    my @List = $Kernel::OM->Get('Kernel::System::Main')->DirectoryRead(
        Directory => $Self->{SessionSpool},
        Filter    => 'Data-' . $Self->{SystemID} . '*',
    );

    my @SessionIDs;
    for my $SessionID (@List) {
        $SessionID =~ s!^.*/!!;
        $SessionID =~ s{ Data- } {}xms;
        push @SessionIDs, $SessionID;
    }

    return @SessionIDs;
}

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

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

    my $TimeNow = $Kernel::OM->Create('Kernel::System::DateTime')->ToEpoch();

    my $MainObject = $Kernel::OM->Get('Kernel::System::Main');

    my @List = $MainObject->DirectoryRead(
        Directory => $Self->{SessionSpool},
        Filter    => 'State-' . $Self->{SystemID} . '*',
    );

    my $ActiveSessionCount = 0;
    my %ActiveSessionPerUserCount;
    SESSIONID:
    for my $SessionID (@List) {

        $SessionID =~ s!^.*/!!;
        $SessionID =~ s{ State- } {}xms;

        next SESSIONID if !$SessionID;

        # read state data
        my $StateData = $MainObject->FileRead(
            Directory       => $Self->{SessionSpool},
            Filename        => 'State-' . $SessionID,
            Type            => 'Local',
            Mode            => 'binmode',
            DisableWarnings => 1,
        );

        next SESSIONID if !$StateData;
        next SESSIONID if ref $StateData ne 'SCALAR';

        my @SessionData = split /####/, ${$StateData};

        # get needed data
        my $UserType        = $SessionData[0] || '';
        my $UserLogin       = $SessionData[1] || '';
        my $UserLastRequest = $SessionData[3] || $TimeNow;
        my $SessionSource   = $SessionData[4] || '';

        # Don't count sessions from source 'GenericInterface'.
        next SESSIONID if $SessionSource eq 'GenericInterface';

        next SESSIONID if $UserType ne $Param{UserType};

        next SESSIONID if ( $UserLastRequest + $MaxSessionIdleTime ) < $TimeNow;

        $ActiveSessionCount++;

        $ActiveSessionPerUserCount{$UserLogin} || 0;
        $ActiveSessionPerUserCount{$UserLogin}++;
    }

    my %Result = (
        Total   => $ActiveSessionCount,
        PerUser => \%ActiveSessionPerUserCount,
    );

    return %Result;
}

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

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

    # get config
    my $MaxSessionTime     = $ConfigObject->Get('SessionMaxTime');
    my $MaxSessionIdleTime = $ConfigObject->Get('SessionMaxIdleTime');

    # get current time
    my $TimeNow = $Kernel::OM->Create('Kernel::System::DateTime')->ToEpoch();

    # get main object
    my $MainObject = $Kernel::OM->Get('Kernel::System::Main');

    # read data
    my @List = $MainObject->DirectoryRead(
        Directory => $Self->{SessionSpool},
        Filter    => 'State-' . $Self->{SystemID} . '*',
    );

    my @ExpiredSession;
    my @ExpiredIdle;
    SESSIONID:
    for my $SessionID (@List) {

        $SessionID =~ s!^.*/!!;
        $SessionID =~ s{ State- } {}xms;

        next SESSIONID if !$SessionID;

        # read state data
        my $StateData = $MainObject->FileRead(
            Directory       => $Self->{SessionSpool},
            Filename        => 'State-' . $SessionID,
            Type            => 'Local',
            Mode            => 'binmode',
            DisableWarnings => 1,
        );

        next SESSIONID if !$StateData;
        next SESSIONID if ref $StateData ne 'SCALAR';

        my @SessionData = split /####/, ${$StateData};

        # get needed data
        my $UserSessionStart = $SessionData[2] || $TimeNow;
        my $UserLastRequest  = $SessionData[3] || $TimeNow;

        # time calculation
        my $ValidTime     = $UserSessionStart + $MaxSessionTime - $TimeNow;
        my $ValidIdleTime = $UserLastRequest + $MaxSessionIdleTime - $TimeNow;

        # delete invalid session time
        if ( $ValidTime <= 0 ) {
            push @ExpiredSession, $SessionID;
        }

        # delete invalid idle session time
        elsif ( $ValidIdleTime <= 0 ) {
            push @ExpiredIdle, $SessionID;
        }
    }

    return ( \@ExpiredSession, \@ExpiredIdle );
}

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

    # delete fs files
    my @SessionIDs = $Self->GetAllSessionIDs();

    return 1 if !@SessionIDs;

    SESSIONID:
    for my $SessionID (@SessionIDs) {

        next SESSIONID if !$SessionID;

        $Self->RemoveSessionID( SessionID => $SessionID );
    }

    return 1;
}

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

    return 1 if !$Self->{Cache};

    # get main object
    my $MainObject = $Kernel::OM->Get('Kernel::System::Main');

    SESSIONID:
    for my $SessionID ( sort keys %{ $Self->{Cache} } ) {

        next SESSIONID if !$SessionID;

        my %SessionData;
        KEY:
        for my $Key ( sort keys %{ $Self->{Cache}->{$SessionID} } ) {

            next KEY if !$Key;

            $SessionData{$Key} = $Self->{Cache}->{$SessionID}->{$Key};
        }

        # dump the data
        my $DataContent = $Kernel::OM->Get('Kernel::System::Storable')->Serialize(
            Data => \%SessionData,
        );

        # write data file
        $MainObject->FileWrite(
            Directory       => $Self->{SessionSpool},
            Filename        => 'Data-' . $SessionID,
            Content         => \$DataContent,
            Type            => 'Local',
            Mode            => 'binmode',
            Permission      => '660',
            DisableWarnings => 1,
        );

        # create needed state content
        my $UserType         = $Self->{Cache}->{$SessionID}->{UserType}         || '';
        my $UserLogin        = $Self->{Cache}->{$SessionID}->{UserLogin}        || '';
        my $UserSessionStart = $Self->{Cache}->{$SessionID}->{UserSessionStart} || '';
        my $UserLastRequest  = $Self->{Cache}->{$SessionID}->{UserLastRequest}  || '';
        my $SessionSource    = $Self->{Cache}->{$SessionID}->{SessionSource}    || '';

        my $StateContent = $UserType . '####'
            . $UserLogin . '####'
            . $UserSessionStart . '####'
            . $UserLastRequest;

        if ($SessionSource) {
            $StateContent .= '####' . $SessionSource;
        }

        # write state file
        $MainObject->FileWrite(
            Directory       => $Self->{SessionSpool},
            Filename        => 'State-' . $SessionID,
            Content         => \$StateContent,
            Type            => 'Local',
            Mode            => 'binmode',
            Permission      => '660',
            DisableWarnings => 1,
        );
    }

    # remove cached data
    delete $Self->{Cache};

    return 1;
}

1;
 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - 6efdc7bf2a3325277cd79a60f0f2407f8ad59e87 - Kernel/System/AuthSession/DB.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::AuthSession::DB;

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

use strict;
use warnings;
use utf8;

# core modules
use MIME::Base64 qw(decode_base64 encode_base64);

# CPAN modules

# OTOBO modules
use Kernel::Language qw(Translatable);

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::System::DateTime',
    'Kernel::System::DB',
    'Kernel::System::Encode',
    'Kernel::System::Log',
    'Kernel::System::Main',
    'Kernel::System::Storable',
    'Kernel::System::Web::Request',
);

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

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

    $Self->{SessionTable} = $Kernel::OM->Get('Kernel::Config')->Get('SessionTable') || 'sessions';

    # get database type
    $Self->{DBType} = $Kernel::OM->Get('Kernel::System::DB')->{'DB::Type'} || '';
    $Self->{DBType} = lc $Self->{DBType};

    return $Self;
}

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

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

    my $ParamObject = $Kernel::OM->Get('Kernel::System::Web::Request');
    my $RemoteAddr  = $ParamObject->RemoteAddr() || 'none';

    # set default message
    $Self->{SessionIDErrorMessage} = Translatable('Session invalid. Please log in again.');

    # get session data
    my %Data = $Self->GetSessionIDData( SessionID => $Param{SessionID} );

    if ( !$Data{UserID} || !$Data{UserLogin} ) {
        $Self->{SessionIDErrorMessage} = Translatable('Session invalid. Please log in again.');
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'notice',
            Message  => "SessionID: '$Param{SessionID}' is invalid!!!",
        );
        return;
    }

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

    # remote ip check
    if (
        $Data{UserRemoteAddr} ne $RemoteAddr
        && $ConfigObject->Get('SessionCheckRemoteIP')
        )
    {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'notice',
            Message  => "RemoteIP of '$Param{SessionID}' ($Data{UserRemoteAddr}) is "
                . "different from registered IP ($RemoteAddr). Invalidating session! "
                . "Disable config 'SessionCheckRemoteIP' if you don't want this!",
        );

        # delete session id if it isn't the same remote ip?
        if ( $ConfigObject->Get('SessionDeleteIfNotRemoteID') ) {
            $Self->RemoveSessionID( SessionID => $Param{SessionID} );
        }

        return;
    }

    # check session idle time
    my $TimeNow            = $Kernel::OM->Create('Kernel::System::DateTime')->ToEpoch();
    my $MaxSessionIdleTime = $ConfigObject->Get('SessionMaxIdleTime');

    if ( ( $TimeNow - $MaxSessionIdleTime ) >= $Data{UserLastRequest} ) {

        $Self->{SessionIDErrorMessage} = Translatable('Session has timed out. Please log in again.');

        my $Timeout = int( ( $TimeNow - $Data{UserLastRequest} ) / ( 60 * 60 ) );

        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'notice',
            Message  =>
                "SessionID ($Param{SessionID}) idle timeout ($Timeout h)! Don't grant access!!!",
        );

        # delete session id if too old?
        if ( $ConfigObject->Get('SessionDeleteIfTimeToOld') ) {
            $Self->RemoveSessionID( SessionID => $Param{SessionID} );
        }

        return;
    }

    # check session time
    my $MaxSessionTime = $ConfigObject->Get('SessionMaxTime');

    if ( ( $TimeNow - $MaxSessionTime ) >= $Data{UserSessionStart} ) {

        $Self->{SessionIDErrorMessage} = Translatable('Session has timed out. Please log in again.');

        my $Timeout = int( ( $TimeNow - $Data{UserSessionStart} ) / ( 60 * 60 ) );

        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'notice',
            Message  => "SessionID ($Param{SessionID}) too old ($Timeout h)! Don't grant access!!!",
        );

        # delete session id if too old
        if ( $ConfigObject->Get('SessionDeleteIfTimeToOld') ) {
            $Self->RemoveSessionID( SessionID => $Param{SessionID} );
        }

        return;
    }

    return 1;
}

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

    return $Self->{SessionIDErrorMessage} || '';
}

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

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

    return %{ $Self->{Cache}->{ $Param{SessionID} } } if $Self->{Cache}->{ $Param{SessionID} };

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

    # read data
    $DBObject->Prepare(
        SQL => "
            SELECT id, data_key, data_value, serialized
            FROM $Self->{SessionTable}
            WHERE session_id = ?
            ORDER BY id ASC",
        Bind => [ \$Param{SessionID} ],
    );

    # get encode object
    my $EncodeObject = $Kernel::OM->Get('Kernel::System::Encode');

    # get storable object
    my $StorableObject = $Kernel::OM->Get('Kernel::System::Storable');

    my %Session;
    my %SessionID;
    ROW:
    while ( my @Row = $DBObject->FetchrowArray() ) {

        # deserialize data if needed
        if ( $Row[3] ) {
            my $Value = eval {
                $StorableObject->Deserialize( Data => decode_base64( $Row[2] ) );
            };

            # workaround for the oracle problem with empty
            # strings and NULL values in VARCHAR columns
            if ( $Value && ref $Value eq 'SCALAR' ) {
                $Value = ${$Value};
            }

            $EncodeObject->EncodeOutput( \$Value );

            $Session{ $Row[1] } = $Value;
        }
        else {
            $Session{ $Row[1] } = $Row[2];
        }

        $SessionID{ $Row[1] } = $Row[0];
    }

    if ( !%Session ) {
        delete $Self->{Cache}->{ $Param{SessionID} };
        delete $Self->{CacheID}->{ $Param{SessionID} };
        delete $Self->{CacheUpdate}->{ $Param{SessionID} };
        return;
    }

    # cache result
    $Self->{Cache}->{ $Param{SessionID} }   = \%Session;
    $Self->{CacheID}->{ $Param{SessionID} } = \%SessionID;

    return %Session;
}

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

    my $TimeNow = $Kernel::OM->Create('Kernel::System::DateTime')->ToEpoch();

    # get remote address and the http user agent
    my $ParamObject     = $Kernel::OM->Get('Kernel::System::Web::Request');
    my $RemoteAddr      = $Param{RemoteAddr} || $ParamObject->RemoteAddr() || 'none';
    my $RemoteUserAgent = $ParamObject->Header('User-Agent') || 'none';

    # get main object
    my $MainObject = $Kernel::OM->Get('Kernel::System::Main');

    # create session id
    my $SessionID = $MainObject->GenerateRandomString(
        Length => 32,
    );

    # create challenge token
    my $ChallengeToken = $MainObject->GenerateRandomString(
        Length => 32,
    );

    my %Data;
    KEY:
    for my $Key ( sort keys %Param ) {

        next KEY if !$Key;

        $Data{$Key} = $Param{$Key};
    }

    $Data{UserSessionStart}    = $TimeNow;
    $Data{UserRemoteAddr}      = $RemoteAddr;
    $Data{UserRemoteUserAgent} = $RemoteUserAgent;
    $Data{UserChallengeToken}  = $ChallengeToken;

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

    # create sql data
    my @SQLs;
    $Self->_SQLCreate(
        Data      => \%Data,
        SQLs      => \@SQLs,
        SessionID => $SessionID,
    );

    return if !@SQLs;

    # delete old session data with the same session id
    $DBObject->Do(
        SQL => "
            DELETE FROM $Self->{SessionTable}
            WHERE session_id = ?",
        Bind => [ \$SessionID, ],
    );

    # store session id and data
    ROW:
    for my $Row (@SQLs) {

        next ROW if !$Row;
        next ROW if ref $Row ne 'HASH';
        next ROW if !$Row->{SQL};
        next ROW if !$Row->{Bind};
        next ROW if ref $Row->{Bind} ne 'ARRAY';

        $DBObject->Do(
            SQL  => $Row->{SQL},
            Bind => $Row->{Bind},
        );
    }

    # set cache
    $Self->{Cache}->{$SessionID} = \%Data;

    return $SessionID;
}

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

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

    # delete session from the database
    return if !$Kernel::OM->Get('Kernel::System::DB')->Do(
        SQL  => "DELETE FROM $Self->{SessionTable} WHERE session_id = ?",
        Bind => [ \$Param{SessionID} ],
    );

    # reset cache
    delete $Self->{Cache}->{ $Param{SessionID} };
    delete $Self->{CacheID}->{ $Param{SessionID} };
    delete $Self->{CacheUpdate}->{ $Param{SessionID} };

    # log event
    $Kernel::OM->Get('Kernel::System::Log')->Log(
        Priority => 'notice',
        Message  => "Removed SessionID $Param{SessionID}."
    );

    return 1;
}

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

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

    # check cache
    if ( !$Self->{Cache}->{ $Param{SessionID} } ) {
        my %SessionData = $Self->GetSessionIDData( SessionID => $Param{SessionID} );

        $Self->{Cache}->{ $Param{SessionID} } = \%SessionData;
    }

    # update the value, set cache
    $Self->{Cache}->{ $Param{SessionID} }->{ $Param{Key} }       = $Param{Value};
    $Self->{CacheUpdate}->{ $Param{SessionID} }->{ $Param{Key} } = $Param{Value};

    return 1;
}

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

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

    # get all session ids from the database
    return if !$DBObject->Prepare(
        SQL => "SELECT DISTINCT(session_id) FROM $Self->{SessionTable}",
    );

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

    return @SessionIDs;
}

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

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

    # get system time
    my $TimeNow = $Kernel::OM->Create('Kernel::System::DateTime')->ToEpoch();

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

    $DBObject->Prepare(
        SQL => "
            SELECT session_id, data_key, data_value
            FROM $Self->{SessionTable}
            WHERE data_key = 'UserType'
                OR data_key = 'UserLastRequest'
                OR data_key = 'UserLogin'
                OR data_key = 'SessionSource'
            ORDER BY id ASC",
    );

    my %SessionData;
    ROW:
    while ( my @Row = $DBObject->FetchrowArray() ) {

        next ROW if !$Row[0];
        next ROW if !$Row[1];

        $SessionData{ $Row[0] }->{ $Row[1] } = $Row[2];
    }

    my $ActiveSessionCount = 0;
    my %ActiveSessionPerUserCount;
    SESSIONID:
    for my $SessionID ( sort keys %SessionData ) {

        next SESSIONID if !$SessionID;
        next SESSIONID if !$SessionData{$SessionID};

        # Don't count session from source 'GenericInterface'
        my $SessionSource = $SessionData{$SessionID}->{SessionSource} || '';

        next SESSIONID if $SessionSource eq 'GenericInterface';

        # get needed data
        my $UserType        = $SessionData{$SessionID}->{UserType}        || '';
        my $UserLastRequest = $SessionData{$SessionID}->{UserLastRequest} || $TimeNow;
        my $UserLogin       = $SessionData{$SessionID}->{UserLogin};

        next SESSIONID if $UserType ne $Param{UserType};

        next SESSIONID if ( $UserLastRequest + $MaxSessionIdleTime ) < $TimeNow;

        $ActiveSessionCount++;

        $ActiveSessionPerUserCount{$UserLogin} || 0;
        $ActiveSessionPerUserCount{$UserLogin}++;
    }

    my %Result = (
        Total   => $ActiveSessionCount,
        PerUser => \%ActiveSessionPerUserCount,
    );

    return %Result;
}

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

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

    # get config
    my $MaxSessionTime     = $ConfigObject->Get('SessionMaxTime');
    my $MaxSessionIdleTime = $ConfigObject->Get('SessionMaxIdleTime');

    # get current time
    my $TimeNow = $Kernel::OM->Create('Kernel::System::DateTime')->ToEpoch();

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

    # get all needed timestamps to investigate the expired sessions
    $DBObject->Prepare(
        SQL => "
            SELECT session_id, data_key, data_value
            FROM $Self->{SessionTable}
            WHERE data_key = 'UserSessionStart'
                OR data_key = 'UserLastRequest'
            ORDER BY id ASC",
    );

    my %SessionData;
    ROW:
    while ( my @Row = $DBObject->FetchrowArray() ) {

        next ROW if !$Row[0];
        next ROW if !$Row[1];

        $SessionData{ $Row[0] }->{ $Row[1] } = $Row[2];
    }

    my @ExpiredSession;
    my @ExpiredIdle;
    SESSIONID:
    for my $SessionID ( sort keys %SessionData ) {

        next SESSIONID if !$SessionID;
        next SESSIONID if !$SessionData{$SessionID};

        # get needed timestamps
        my $UserSessionStart = $SessionData{$SessionID}->{UserSessionStart} || $TimeNow;
        my $UserLastRequest  = $SessionData{$SessionID}->{UserLastRequest}  || $TimeNow;

        # time calculation
        my $ValidTime     = $UserSessionStart + $MaxSessionTime - $TimeNow;
        my $ValidIdleTime = $UserLastRequest + $MaxSessionIdleTime - $TimeNow;

        # delete invalid session time
        if ( $ValidTime <= 0 ) {
            push @ExpiredSession, $SessionID;
        }

        # delete invalid idle session time
        elsif ( $ValidIdleTime <= 0 ) {
            push @ExpiredIdle, $SessionID;
        }
    }

    return ( \@ExpiredSession, \@ExpiredIdle );
}

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

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

    # use 'truncate table' if possible in order to reset the auto increment value
    if (
        $Self->{DBType} eq 'mysql'
        || $Self->{DBType} eq 'postgresql'
        || $Self->{DBType} eq 'oracle'
        || $Self->{DBType} eq 'mssql'
        )
    {

        return if !$DBObject->Do( SQL => "TRUNCATE TABLE $Self->{SessionTable}" );
    }
    else {
        return if !$DBObject->Do( SQL => "DELETE FROM $Self->{SessionTable}" );
    }

    # remove cached data
    delete $Self->{Cache};
    delete $Self->{CacheID};
    delete $Self->{CacheUpdate};

    return 1;
}

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

    return 1 if !$Self->{CacheUpdate};

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

    SESSIONID:
    for my $SessionID ( sort keys %{ $Self->{CacheUpdate} } ) {

        next SESSIONID if !$SessionID;

        # extract session data to update
        my $Data = $Self->{CacheUpdate}->{$SessionID};

        next SESSIONID if !$Data;
        next SESSIONID if ref $Data ne 'HASH';
        next SESSIONID if !%{$Data};

        # create sql data
        my @SQLs;
        $Self->_SQLCreate(
            Data      => $Data,
            SQLs      => \@SQLs,
            SessionID => $SessionID,
        );

        next SESSIONID if !@SQLs;

        # store session id and data
        ROW:
        for my $Row (@SQLs) {

            next ROW if !$Row;
            next ROW if ref $Row ne 'HASH';
            next ROW if !$Row->{SQL};
            next ROW if !$Row->{Bind};
            next ROW if ref $Row->{Bind} ne 'ARRAY';

            $DBObject->Do(
                SQL  => $Row->{SQL},
                Bind => $Row->{Bind},
            );
        }

        KEY:
        for my $Key ( sort keys %{ $Self->{CacheUpdate}->{$SessionID} } ) {

            next KEY if !$Key;

            # extract database id
            my $ID = $Self->{CacheID}->{$SessionID}->{$Key} || 1;

            # delete old session data from the database
            $DBObject->Do(
                SQL => "
                    DELETE FROM $Self->{SessionTable}
                    WHERE session_id = ?
                        AND data_key = ?
                        AND id <= ?",
                Bind => [ \$SessionID, \$Key, \$ID ],
            );
        }
    }

    # remove cached data
    delete $Self->{Cache};
    delete $Self->{CacheID};
    delete $Self->{CacheUpdate};

    return 1;
}

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

    return if !$Param{Data};
    return if ref $Param{Data} ne 'HASH';
    return if !%{ $Param{Data} };
    return if !$Param{SessionID};
    return if !$Param{SQLs};
    return if ref $Param{SQLs} ne 'ARRAY';

    my $StorableObject = $Kernel::OM->Get('Kernel::System::Storable');

    if ( $Self->{DBType} eq 'mysql' || $Self->{DBType} eq 'postgresql' ) {

        # define row
        my $SQL = "INSERT INTO $Self->{SessionTable} "
            . "(session_id, data_key, data_value, serialized) VALUES ";
        my @Bind;

        KEY:
        for my $Key ( sort keys %{ $Param{Data} } ) {

            next KEY if !$Key;

            my $Value      = $Param{Data}->{$Key};
            my $Serialized = 0;

            if (
                ref $Value eq 'HASH'
                || ref $Value eq 'ARRAY'
                || ref $Value eq 'SCALAR'
                )
            {

                # dump the data
                $Value = encode_base64(
                    $StorableObject->Serialize( Data => $Value )
                );
                $Serialized = 1;
            }

            push @Bind, \$Param{SessionID};
            push @Bind, \$Key;
            push @Bind, \$Value;
            push @Bind, \$Serialized;

            $SQL .= '(?,?,?,?),';
        }

        # remove the last character
        chop $SQL;

        my %Row = (
            SQL  => $SQL,
            Bind => \@Bind,
        );

        push @{ $Param{SQLs} }, \%Row;

        return 1;
    }
    elsif ( $Self->{DBType} eq 'oracle' ) {

        # define row
        my $SQL = '';
        my @Bind;
        my $Counter = 0;

        KEY:
        for my $Key ( sort keys %{ $Param{Data} } ) {

            next KEY if !$Key;

            $Counter++;

            my $Value      = $Param{Data}->{$Key};
            my $Serialized = 0;

            if (
                !defined $Value
                || $Value eq ''
                || ref $Value eq 'HASH'
                || ref $Value eq 'ARRAY'
                || ref $Value eq 'SCALAR'
                )
            {

                # workaround for the oracle problem with empty strings
                # and NULL values in VARCHAR columns
                if ( !defined $Value ) {

                    my $Empty = undef;
                    $Value = \$Empty;
                }
                elsif ( $Value eq '' ) {

                    my $Empty = '';
                    $Value = \$Empty;
                }

                # dump the data
                $Value = encode_base64(
                    $StorableObject->Serialize( Data => $Value )
                );
                $Serialized = 1;
            }

            $SQL ||= 'INSERT ALL ';
            $SQL .= "INTO $Self->{SessionTable} "
                . "(session_id, data_key, data_value, serialized) VALUES (?,?,?,?) ";

            push @Bind, \$Param{SessionID};
            push @Bind, \$Key;
            push @Bind, \$Value;
            push @Bind, \$Serialized;

            # split SQLs with more than 4k charecters
            next KEY if $Counter < 40;

            # copy bind to be able to clean the array reference
            my @BindCopy = @Bind;

            $SQL .= 'SELECT * FROM dual';

            my %Row = (
                SQL  => $SQL,
                Bind => \@BindCopy,
            );

            push @{ $Param{SQLs} }, \%Row;

            # clean variable
            $SQL     = '';
            @Bind    = ();
            $Counter = 0;
        }

        if ( $SQL && @Bind ) {

            $SQL .= 'SELECT * FROM dual';

            my %Row = (
                SQL  => $SQL,
                Bind => \@Bind,
            );

            push @{ $Param{SQLs} }, \%Row;
        }

        return 1;
    }
    else {

        KEY:
        for my $Key ( sort keys %{ $Param{Data} } ) {

            next KEY if !$Key;

            my $Value      = $Param{Data}->{$Key};
            my $Serialized = 0;

            if (
                ref $Value eq 'HASH'
                || ref $Value eq 'ARRAY'
                || ref $Value eq 'SCALAR'
                )
            {

                # dump the data
                $Value = encode_base64(
                    $StorableObject->Serialize( Data => $Value )
                );
                $Serialized = 1;
            }

            my @Bind;
            push @Bind, \$Param{SessionID};
            push @Bind, \$Key;
            push @Bind, \$Value;
            push @Bind, \$Serialized;

            my $SQL = "INSERT INTO $Self->{SessionTable} "
                . "(session_id, data_key, data_value, serialized) VALUES (?,?,?,?)";

            my %Row = (
                SQL  => $SQL,
                Bind => \@Bind,
            );

            push @{ $Param{SQLs} }, \%Row;
        }

        return 1;
    }
}

1;
 <?xml version="1.0" encoding="utf-8"?>
<otobo_config version="2.0" init="Application">
    <Setting Name="DashboardBackend###0160-OTOBOAIDashboard" Required="0" Valid="0">
        <Description Translatable="1">Parameters for the dashboard backend of the tickets overview by search template of the agent interface. "Limit" is the number of entries shown by default. "Group" is used to restrict the access to the plugin (e. g. Group: admin;group1;group2;). "Default" determines if the plugin is enabled by default or if the user needs to enable it manually. "CacheTTLLocal" is the cache time in minutes for the plugin. "Mandatory" determines if the plugin is always shown and can not be removed by agents. Note: Only Ticket attributes and Dynamic Fields (DynamicField_NameX) are allowed for DefaultColumns.</Description>
        <Navigation>Frontend::Agent::View::Dashboard</Navigation>
        <Value>
            <Hash>
                <Item Key="Module">Kernel::Output::HTML::Dashboard::OtoboAIDashboard</Item>
                <Item Key="Title" Translatable="1">OTOBO-AI Bot</Item>
                <Item Key="Description" Translatable="1">Automatic responses from OTOBO Bot.</Item>
                <Item Key="Filter" Translatable="1">All</Item>
                <Item Key="Time">Age</Item>
                <Item Key="Limit">10</Item>
                <Item Key="Permission">rw</Item>
                <Item Key="Block">ContentLarge</Item>
                <Item Key="Group"></Item>
                <Item Key="Default">1</Item>
                <Item Key="CacheTTLLocal">0.5</Item>
                <Item Key="DefaultColumns">
                    <Hash>
                        <DefaultItem ValueType="Select">
                            <Item ValueType="Option" Value="0" Translatable="1">0 - Disabled</Item>
                            <Item ValueType="Option" Value="1" Translatable="1">1 - Available</Item>
                            <Item ValueType="Option" Value="2" Translatable="1">2 - Enabled by default</Item>
                        </DefaultItem>
                        <Item Key="Age" SelectedID="2"></Item>
                        <Item Key="Changed" SelectedID="1"></Item>
                        <Item Key="Created" SelectedID="1"></Item>
                        <Item Key="CustomerCompanyName" SelectedID="1"></Item>
                        <Item Key="CustomerID" SelectedID="1"></Item>
                        <Item Key="CustomerName" SelectedID="1"></Item>
                        <Item Key="CustomerUserID" SelectedID="1"></Item>
                        <Item Key="EscalationResponseTime" SelectedID="1"></Item>
                        <Item Key="EscalationSolutionTime" SelectedID="1"></Item>
                        <Item Key="EscalationTime" SelectedID="1"></Item>
                        <Item Key="EscalationUpdateTime" SelectedID="1"></Item>
                        <Item Key="TicketNumber" SelectedID="2"></Item>
                        <Item Key="Lock" SelectedID="1"></Item>
                        <Item Key="Owner" SelectedID="1"></Item>
                        <Item Key="PendingTime" SelectedID="1"></Item>
                        <Item Key="Queue" SelectedID="1"></Item>
                        <Item Key="Responsible" SelectedID="1"></Item>
                        <Item Key="Priority" SelectedID="1"></Item>
                        <Item Key="Service" SelectedID="1"></Item>
                        <Item Key="State" SelectedID="1"></Item>
                        <Item Key="SLA" SelectedID="1"></Item>
                        <Item Key="Title" SelectedID="2"></Item>
                        <Item Key="Type" SelectedID="1"></Item>
                    </Hash>
                </Item>
                <Item Key="Mandatory">0</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="Loader::Module::AgentDashboard###0160-OTOBOAIDashboard" Required="0" Valid="1">
        <Description Translatable="1">Loader module registration for the agent interface.</Description>
        <Navigation>Frontend::Agent::ModuleRegistration::Loader</Navigation>
        <Value>
            <Hash>
                <Item Key="JavaScript">
                    <Array>
                        <Item>Core.UI.InputFields.js</Item>
                        <Item>Core.Agent.OtoboAIWidget.js</Item>
                    </Array>
                </Item>
                <Item Key="CSS">
                    <Array>
                        <Item>OtoboAIDashboard.css</Item>
                    </Array>
                </Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="OtoboAIDashboard::Frontend::TextAreaQuestion" Required="1" Valid="1">
        <Description Translatable="1">Permitted width for compose question windows.</Description>
        <Navigation>Frontend::Agent::View::Dashboard</Navigation>
        <Value>
            <Item ValueType="String" ValueRegex="^[0-9]{1,3}$">100</Item>
        </Value>
    </Setting>
    <Setting Name="Frontend::Module###OtoboAIDashboard" Required="0" Valid="1">
        <Description Translatable="1">Frontend module registration for the agent interface.</Description>
        <Navigation>Frontend::Agent::ModuleRegistration</Navigation>
        <Value>
            <Item ValueType="FrontendRegistration">
                <Hash>
                    <Item Key="Group">
                        <Array>
                        </Array>
                    </Item>
                    <Item Key="GroupRo">
                        <Array>
                        </Array>
                    </Item>
                    <Item Key="Description">Otobo AI Dashboard Widget</Item>
                    <Item Key="Title"></Item>
                    <Item Key="NavBarName"></Item>
                </Hash>
            </Item>
        </Value>
    </Setting>
    <Setting Name="OtoboAIDashboard::Frontend::CacheTTL" Required="1" Valid="1">
        <Description Translatable="1">Number of hours of TTL for the Otobo-AI cache elements.</Description>
        <Navigation>Frontend::Agent::View::Dashboard</Navigation>
        <Value>
                <Hash>
                    <Item Key="Request">2</Item>
                    <Item Key="Answer">2</Item>
                </Hash>
        </Value>
    </Setting>
    <Setting Name="OtoboAIDashboard::Frontend::PollingInterval" Required="1" Valid="1">
        <Description Translatable="1">Number of seconds on the client side between attempts to get a cached answer.</Description>
        <Navigation>Frontend::Agent::View::Dashboard</Navigation>
        <Value>
            <Item ValueType="String" ValueRegex="^[0-9]{1,3}$">5</Item>
        </Value>
    </Setting>
    <Setting Name="OtoboAIDashboard::Frontend::TimeoutInterval" Required="1" Valid="1">
        <Description Translatable="1">Timeout to consider that a request has no response.</Description>
        <Navigation>Frontend::Agent::View::Dashboard</Navigation>
        <Value>
            <Item ValueType="String" ValueRegex="^[0-9]{1,3}$">300</Item>
        </Value>
    </Setting>
</otobo_config>
 <?xml version="1.0" encoding="utf-8"?>
<otobo_config version="2.0" init="Application">
    <Setting Name="OTOBOAI::Ticket::SearchRestrictions###0100-Default" Required="0" Valid="1">
        <Description Translatable="1">Add search restrictions or parameters, to select tickets for import in the RAG pipeline. The pipeline in determined by the label provided. Please note that any changes to this setting may desynchronize the underlying vector DB. Thus, a full reimport of the ticket knowledge base via console command is required to guarantee a valid database state.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Hash>
                <DefaultItem>
                    <Array></Array>
                </DefaultItem>
                <Item Key="Label">
                    <Array>
                        <Item>default</Item>
                    </Array>
                </Item>
                <Item Key="Queues">
                    <Array>
                        <Item>Raw</Item>
                    </Array>
                </Item>
                <Item Key="UseSubQueues">1</Item>
                <Item Key="Types">
                    <Array>
                        <Item>Unclassified</Item>
                    </Array>
                </Item>
                <Item Key="StateType">
                    <Array>
                        <Item>closed</Item>
                        <Item>closed successful</Item>
                    </Array>
                </Item>
                <Item Key="Services">
                    <Array>
                    </Array>
                </Item>
                <Item Key="TicketCloseTimeNewerMinutes">1576800</Item>
                <Item Key="TicketCloseTimeOlderMinutes">1440</Item>
                <Item Key="ArchiveFlags">
                    <Array>
                        <Item>y</Item>
                        <Item>n</Item>
                    </Array>
                </Item>
<!--
                <Item Key="DynamicField_FieldNameX">
                    <Hash>
                        <Item Key="Empty">0</Item>
                        <Item Key="Equals">123</Item>
                        <Item Key="Like">some value</Item>
                        <Item Key="GreaterThan">2001-01-01 01:01:01</Item>
                        <Item Key="GreaterThanEquals">2001-01-01 01:01:01</Item>
                        <Item Key="SmallerThan">2001-01-01 01:01:01</Item>
                        <Item Key="SmallerThanEquals">2001-01-01 01:01:01</Item>

                    </Hash>
                </Item>
-->
            </Hash>
        </Value>
    </Setting>
    <Setting Name="OTOBOAI::Ticket::SearchRestrictions###0200-Custom1" Required="0" Valid="0">
        <Description Translatable="1">Add search restrictions or parameters, to select tickets for import in the RAG pipeline. The pipeline in determined by the label provided. Please note that any changes to this setting may desynchronize the underlying vector DB. Thus, a full reimport of the ticket knowledge base via console command is required to guarantee a valid database state.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Hash>
                <DefaultItem>
                    <Array></Array>
                </DefaultItem>
                <Item Key="Label">
                    <Array>
                        <Item>Custom1</Item>
                    </Array>
                </Item>
                <Item Key="Queues">
                    <Array>
                        <Item>Raw</Item>
                    </Array>
                </Item>
                <Item Key="UseSubQueues">1</Item>
                <Item Key="Types">
                    <Array>
                        <Item>Unclassified</Item>
                    </Array>
                </Item>
                <Item Key="StateType">
                    <Array>
                        <Item>closed</Item>
                        <Item>closed successful</Item>
                    </Array>
                </Item>
                <Item Key="Services">
                    <Array>
                    </Array>
                </Item>
                <Item Key="TicketCloseTimeNewerMinutes">1576800</Item>
                <Item Key="TicketCloseTimeOlderMinutes">1440</Item>
                <Item Key="ArchiveFlags">
                    <Array>
                        <Item>y</Item>
                        <Item>n</Item>
                    </Array>
                </Item>
<!--
                <Item Key="DynamicField_FieldNameX">
                    <Hash>
                        <Item Key="Empty">0</Item>
                        <Item Key="Equals">123</Item>
                        <Item Key="Like">some value</Item>
                        <Item Key="GreaterThan">2001-01-01 01:01:01</Item>
                        <Item Key="GreaterThanEquals">2001-01-01 01:01:01</Item>
                        <Item Key="SmallerThan">2001-01-01 01:01:01</Item>
                        <Item Key="SmallerThanEquals">2001-01-01 01:01:01</Item>

                    </Hash>
                </Item>
-->
            </Hash>
        </Value>
    </Setting>
    <Setting Name="OTOBOAI::Ticket::SearchRestrictions###0300-Custom2" Required="0" Valid="0">
        <Description Translatable="1">Add search restrictions or parameters, to select tickets for import in the RAG pipeline. The pipeline in determined by the label provided. Please note that any changes to this setting may desynchronize the underlying vector DB. Thus, a full reimport of the ticket knowledge base via console command is required to guarantee a valid database state.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Hash>
                <DefaultItem>
                    <Array></Array>
                </DefaultItem>
                <Item Key="Label">
                    <Array>
                        <Item>Custom2</Item>
                    </Array>
                </Item>
                <Item Key="Queues">
                    <Array>
                        <Item>Raw</Item>
                    </Array>
                </Item>
                <Item Key="UseSubQueues">1</Item>
                <Item Key="Types">
                    <Array>
                        <Item>Unclassified</Item>
                    </Array>
                </Item>
                <Item Key="StateType">
                    <Array>
                        <Item>closed</Item>
                        <Item>closed successful</Item>
                    </Array>
                </Item>
                <Item Key="Services">
                    <Array>
                    </Array>
                </Item>
                <Item Key="TicketCloseTimeNewerMinutes">1576800</Item>
                <Item Key="TicketCloseTimeOlderMinutes">1440</Item>
                <Item Key="ArchiveFlags">
                    <Array>
                        <Item>y</Item>
                        <Item>n</Item>
                    </Array>
                </Item>
<!--
                <Item Key="DynamicField_FieldNameX">
                    <Hash>
                        <Item Key="Empty">0</Item>
                        <Item Key="Equals">123</Item>
                        <Item Key="Like">some value</Item>
                        <Item Key="GreaterThan">2001-01-01 01:01:01</Item>
                        <Item Key="GreaterThanEquals">2001-01-01 01:01:01</Item>
                        <Item Key="SmallerThan">2001-01-01 01:01:01</Item>
                        <Item Key="SmallerThanEquals">2001-01-01 01:01:01</Item>

                    </Hash>
                </Item>
-->
            </Hash>
        </Value>
    </Setting>
    <Setting Name="OTOBOAI::FAQ::SearchRestrictions###0100-Default" Required="0" Valid="1">
        <Description Translatable="1">Add search restrictions or parameters, to select tickets for import in the RAG pipeline. The pipeline in determined by the label provided. Please note that any changes to this setting may desynchronize the underlying vector DB. Thus, a full reimport of the ticket knowledge base via console command is required to guarantee a valid database state.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Hash>
                <Item Key="Label">
                    <Array>
                        <Item>default</Item>
                    </Array>
                </Item>
                <Item Key="CategoryIDs">
                    <Array>
                        <Item>1</Item>
                        <Item>2</Item>
                        <Item>3</Item>
                    </Array>
                </Item>
                <Item Key="LanguageIDs">
                    <Array>
                        <Item>1</Item>
                        <Item>2</Item>
                    </Array>
                </Item>
                <Item Key="States">
                    <Hash>
                        <Item Key="1">internal</Item>
                        <Item Key="2">external</Item>
                        <Item Key="3">public</Item>
                    </Hash>
                </Item>
                <Item Key="Approved">1</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="OTOBOAI::FAQ::SearchRestrictions###0200-Custom1" Required="0" Valid="0">
        <Description Translatable="1">Add search restrictions or parameters, to select FAQ articles for import into the RAG pipeline. The pipeline is determined by the label given. Please note that any changes to this setting may desyncronize the underlying vector DB. Thus, a full reimport of the FAQ knowledge base via console command is required to guarantee a valid database state.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Hash>
                <Item Key="Label">
                    <Array>
                        <Item>Custom1</Item>
                    </Array>
                </Item>
                <Item Key="CategoryIDs">
                    <Array>
                        <Item>1</Item>
                        <Item>2</Item>
                        <Item>3</Item>
                    </Array>
                </Item>
                <Item Key="LanguageIDs">
                    <Array>
                        <Item>1</Item>
                        <Item>2</Item>
                    </Array>
                </Item>
                <Item Key="States">
                    <Hash>
                        <Item Key="1">internal</Item>
                        <Item Key="2">external</Item>
                        <Item Key="3">public</Item>
                    </Hash>
                </Item>
                <Item Key="Approved">1</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="OTOBOAI::FAQ::SearchRestrictions###0300-Custom2" Required="0" Valid="0">
        <Description Translatable="1">Add search restrictions or parameters, to select FAQ articles for import into the RAG pipeline. The pipeline is determined by the label given. Please note that any changes to this setting may desyncronize the underlying vector DB. Thus, a full reimport of the FAQ knowledge base via console command is required to guarantee a valid database state.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Hash>
                <Item Key="Label">
                    <Array>
                        <Item>Custom2</Item>
                    </Array>
                </Item>
                <Item Key="CategoryIDs">
                    <Array>
                        <Item>1</Item>
                        <Item>2</Item>
                        <Item>3</Item>
                    </Array>
                </Item>
                <Item Key="LanguageIDs">
                    <Array>
                        <Item>1</Item>
                        <Item>2</Item>
                    </Array>
                </Item>
                <Item Key="States">
                    <Hash>
                        <Item Key="1">internal</Item>
                        <Item Key="2">external</Item>
                        <Item Key="3">public</Item>
                    </Hash>
                </Item>
                <Item Key="Approved">1</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="OTOBOAI::Document::SearchRestrictions###0100-Default" Required="0" Valid="1">
        <Description Translatable="1">Location for documents to include for the RAG pipeline. The pipeline is determined by the label given. Changes to this setting do not automatically update the underlying vector DB. Please appropriately import/purge/reimport via console command for these changes to take effect.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Hash>
                <Item Key="Label">
                    <Array>
                        <Item>default</Item>
                    </Array>
                </Item>
                <Item Key="NewerThanDays">300</Item>
                <Item Key="DocumentPath">/opt/otobo/var/ai/doc</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="OTOBOAI::Document::SearchRestrictions###0200-Custom1" Required="0" Valid="0">
        <Description Translatable="1">Location for documents to include for the RAG pipeline. The pipeline is determined by the label given. Changes to this setting do not automatically update the underlying vector DB. Please appropriately import/purge/reimport via console command for these changes to take effect.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Hash>
                <Item Key="Label">
                    <Array>
                        <Item>Custom1</Item>
                    </Array>
                </Item>
                <Item Key="NewerThanDays">300</Item>
                <Item Key="DocumentPath">/opt/otobo/var/ai/doc</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="OTOBOAI::Document::SearchRestrictions###0200-Custom2" Required="0" Valid="0">
        <Description Translatable="1">Location for documents to include for the RAG pipeline. The pipeline is determined by the label given. Changes to this setting do not automatically update the underlying vector DB. Please appropriately import/purge/reimport via console command for these changes to take effect.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Hash>
                <Item Key="Label">
                    <Array>
                        <Item>Custom2</Item>
                    </Array>
                </Item>
                <Item Key="NewerThanDays">300</Item>
                <Item Key="DocumentPath">/opt/otobo/var/ai/doc</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="GenericInterface::Invoker::Module###OTOBOAI::IngestMany" Required="0" Valid="1">
        <Description Translatable="1">GenericInterface module registration for the invoker layer.</Description>
        <Navigation>GenericInterface::Invoker::ModuleRegistration</Navigation>
        <Value>
            <Hash>
                <Item Key="Name">IngestMany</Item>
                <Item Key="Controller">IngestMany</Item>
                <Item Key="ConfigDialog">AdminGenericInterfaceInvokerDefault</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="GenericInterface::Invoker::Module###OTOBOAI::GetAnswer" Required="0" Valid="1">
        <Description Translatable="1">GenericInterface module registration for the invoker layer.</Description>
        <Navigation>GenericInterface::Invoker::ModuleRegistration</Navigation>
        <Value>
            <Hash>
                <Item Key="Name">GetAnswer</Item>
                <Item Key="Controller">GetAnswer</Item>
                <Item Key="ConfigDialog">AdminGenericInterfaceInvokerDefault</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="GenericInterface::Invoker::Module###OTOBOAI::Purge" Required="0" Valid="1">
        <Description Translatable="1">GenericInterface module registration for the invoker layer.</Description>
        <Navigation>GenericInterface::Invoker::ModuleRegistration</Navigation>
        <Value>
            <Hash>
                <Item Key="Name">Purge</Item>
                <Item Key="Controller">Purge</Item>
                <Item Key="ConfigDialog">AdminGenericInterfaceInvokerDefault</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="GenericInterface::Invoker::Module###OTOBOAI::QueryEmbeddings" Required="0" Valid="1">
        <Description Translatable="1">GenericInterface module registration for the invoker layer.</Description>
        <Navigation>GenericInterface::Invoker::ModuleRegistration</Navigation>
        <Value>
            <Hash>
                <Item Key="Name">QueryEmbeddings</Item>
                <Item Key="Controller">QueryEmbeddings</Item>
                <Item Key="ConfigDialog">AdminGenericInterfaceInvokerDefault</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="DynamicFields::Driver###TextAreaAI" Required="0" Valid="1">
        <Description Translatable="1">DynamicField backend registration.</Description>
        <Navigation>Core::DynamicFields::DriverRegistration</Navigation>
        <Value>
            <Hash>
                <Item Key="DisplayName" Translatable="1">Textarea AI</Item>
                <Item Key="Module">Kernel::System::DynamicField::Driver::TextAreaAI</Item>
                <Item Key="ConfigDialog">AdminDynamicFieldTextAreaAI</Item>
                <Item Key="DisabledAdd">1</Item>
                <Item Key="ObjectTypes">
                    <Array>
                        <Item>Article</Item>
                    </Array>
                </Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="Daemon::SchedulerCronTaskManager::Task###RebuildOtoboAIIndex" Required="0" Valid="0" ConfigLevel="100">
        <Description Translatable="1">Rebuilds the OTOBO AI Vector DB index.</Description>
        <Navigation>Daemon::SchedulerCronTaskManager::Task</Navigation>
        <Value>
            <Hash>
                <Item Key="TaskName">RebuildOtoboAIIndex</Item>
                <!--
                    run job once at 01:00 AM in the Morning
                -->
                <Item Key="Schedule">0 1 * * *</Item>
                <Item Key="Module">Kernel::System::Console::Command::Maint::AI::Import</Item>
                <Item Key="Function">Execute</Item>
                <Item Key="MaximumParallelInstances">1</Item>
                <Item Key="Params">
                    <Array>
                        <Item>--target</Item>
                        <Item>tfd</Item>
                        <Item>--reimport</Item>
                        <Item>1</Item>
                    </Array>
                </Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="Ticket::EventModulePost###8000-PopulateOTOBOAIDynamicField" Required="0" Valid="1">
        <Description Translatable="1">Event module registration. For asynchronous LLM response collection, you can define trigger events (e.g., TicketCreate). Emitted events are validated against this string using a regular expression; multiple events may be specified, separated by an arbitrary delimiter. The Transition attribute determines when the event is executed: either exactly when it is emitted (0) or at the end of the entire action (1).</Description>
        <Navigation>Core::Event::Ticket</Navigation>
        <Value>
            <Hash>
                <Item Key="Module">Kernel::System::Ticket::Event::PopulateOTOBOAIDynamicField</Item>
                <Item Key="Event">ArticleCreate</Item>
                <Item Key="Transaction">1</Item>
                <Item Key="Queues">
                    <Array>
                    </Array>
                </Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="Ticket::EventModulePost###8100-PopulateOTOBOAIDynamicField" Required="0" Valid="0">
        <Description Translatable="1">Event module registration. For asynchronous LLM response collection, you can define trigger events (e.g., TicketCreate). Emitted events are validated against this string using a regular expression; multiple events may be specified, separated by an arbitrary delimiter. The Transition attribute determines when the event is executed: either exactly when it is emitted (0) or at the end of the entire action (1).</Description>
        <Navigation>Core::Event::Ticket</Navigation>
        <Value>
            <Hash>
                <Item Key="Module">Kernel::System::Ticket::Event::PopulateOTOBOAIDynamicField</Item>
                <Item Key="Event">TicketQueueUpdate</Item>
                <Item Key="Transaction">1</Item>
                <Item Key="Queues">
                    <Array>
                    </Array>
                </Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="Ticket::EventModulePost###8200-PopulateOTOBOAIDynamicField" Required="0" Valid="0">
        <Description Translatable="1">Event module registration. For asynchronous LLM response collection, you can define trigger events (e.g., TicketCreate). Emitted events are validated against this string using a regular expression; multiple events may be specified, separated by an arbitrary delimiter. The Transition attribute determines when the event is executed: either exactly when it is emitted (0) or at the end of the entire action (1).</Description>
        <Navigation>Core::Event::Ticket</Navigation>
        <Value>
            <Hash>
                <Item Key="Module">Kernel::System::Ticket::Event::PopulateOTOBOAIDynamicField</Item>
                <Item Key="Event">TicketQueueUpdate</Item>
                <Item Key="Transaction">1</Item>
                <Item Key="Queues">
                    <Array>
                    </Array>
                </Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="Ticket::EventModulePost###8300-OTOBOAIIncrementalSynchronization" Required="0" Valid="0">
        <Description Translatable="1">Event module registration. Whenever a Ticket is created or updated, e.g. by receiving new articles or changing state, it should be reimported into the vector DB. Therefore, this setting describes which internal OTOBO events should trigger a re-check of the SearchRestrictions. For a list of standard, Ticket-related OTOBO events, please consult the Developer Manual.</Description>
        <Navigation>Core::Event::Ticket</Navigation>
        <Value>
            <Hash>
                <Item Key="Module">Kernel::System::Ticket::Event::OTOBOAIIncrementalSynchronization</Item>
                <Item Key="Event">TicketCreate|Ticket.*Update|TicketMerge|TicketDelete|ArticleCreate|ArticleUpdate|ArticleEdit</Item>
                <Item Key="Transaction">1</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="FAQ::EventModulePost###8300-OTOBOAIIncrementalSynchronization" Required="0" Valid="0">
        <Description Translatable="1">Event module registration. Whenever an FAQ item is created or updated, it should be reimported into the vector DB.</Description>
        <Navigation>Core::Event::Ticket</Navigation>
        <Value>
            <Hash>
                <Item Key="Module">Kernel::System::FAQ::Event::OTOBOAIIncrementalSynchronization</Item>
                <Item Key="Event">FAQCreate|FAQUpdate|FAQDelete</Item>
                <Item Key="Transaction">1</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="Frontend::Module###AdminDynamicFieldTextAreaAI" Required="0" Valid="1">
        <Description Translatable="1">Frontend module registration for the agent interface.</Description>
        <Navigation>Frontend::Admin::ModuleRegistration</Navigation>
        <Value>
            <Item ValueType="FrontendRegistration">
                <Hash>
                    <Item Key="GroupRo">
                        <Array>
                        </Array>
                    </Item>
                    <Item Key="Group">
                        <Array>
                            <Item>admin</Item>
                        </Array>
                    </Item>
                    <Item Key="Description" Translatable="1">This module is part of the admin area of OTOBO.</Item>
                    <Item Key="Title" Translatable="1">Dynamic Fields TextAreaAI Backend GUI</Item>
                    <Item Key="NavBarName">Admin</Item>
                </Hash>
            </Item>
        </Value>
    </Setting>
    <Setting Name="Loader::Module::AdminDynamicFieldTextAreaAI###003-OTOBOAI" Required="0" Valid="1">
        <Description Translatable="1">Loader module registration for the agent interface.</Description>
        <Navigation>Frontend::Admin::ModuleRegistration::Loader</Navigation>
        <Value>
            <Hash>
                <Item Key="JavaScript">
                    <Array>
                        <Item>Core.Agent.Admin.DynamicField.js</Item>
                        <Item>Core.Agent.Admin.DynamicFieldText.js</Item>
                        <Item>Core.Agent.Admin.SysConfig.Entity.js</Item>
                    </Array>
                </Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="OTOBOAI::AnswerTemplateRequestType" Required="0" Valid="1">
        <Description Translatable="1">Define if opening the answer template on an article which has no AI answer pre-fetched should block (synchronous) or show a placeholder (asynchronous).</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Item ValueType="Select" SelectedID="Asynchronous">
                <Item ValueType="Option" Value="Synchronous" Translatable="1">Synchronous</Item>
                <Item ValueType="Option" Value="Asynchronous" Translatable="1">Asynchronous</Item>
            </Item>
        </Value>
    </Setting>
    <Setting Name="OTOBOAI::Placeholder" Required="0" Valid="1">
        <Description Translatable="1">Define a string which is used as a placeholder while waiting for the AI answer. Only visible if AI answer generation is asynchronous.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Item ValueType="String"><![CDATA[<|        AI answer generation in progress. Please reopen window to check again...     |>]]></Item>
        </Value>
    </Setting>
    <Setting Name="OTOBOAI::DynamicFieldOTOBOAI" Required="0" Valid="1">
        <Description Translatable="1">This option defines the dynamic field in which an OTOBOAI answer is stored. It may be included in a response template. If changed, the field has to be created manually.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Item ValueType="String">OTOBOAI</Item>
        </Value>
    </Setting>
    <Setting Name="OTOBOAI::DynamicFieldOTOBOAI::EmptyAnswerToken" Required="0" Valid="1">
        <Description Translatable="1">An LLM may not be capable of outputting an empty string. Adjust the prompt to output this token as substitute for an empty string instead. If the dynamic field receives this token, the resulting OTOBOAI answer template will hold no answer string.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Item ValueType="String">NO_OUTPUT</Item>
        </Value>
    </Setting>
    <Setting Name="OTOBOAI::OverwritePreviousResponse" Required="0" Valid="1">
        <Description Translatable="1">By activating this option, previous AI answers fetched for an article are ignored and a new request to the LLM is started. This is only useful in development settings and should not be activated in production.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Item ValueType="Checkbox">0</Item>
        </Value>
    </Setting>
    <Setting Name="OTOBOAI::StripSignatureRegex" Required="0" Valid="0">
        <Description Translatable="1">Cut off this and subsequent lines from ticket articles during ingestion into the RAG. The value is a Regular Expression. This is useful to strip reoccurring suffixes like signatures from articles.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Item ValueType="String">^--\s*$</Item>
        </Value>
    </Setting>

    <Setting Name="OTOBOAI::AllowedArticleSenderTypes" Required="0" Valid="1">
        <Description Translatable="1">Array of allowed ArticleSenderTypes to be indexed by OTOBO AI. Valid values are 'customer', 'agent', and 'system'.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Array>
                <Item>agent</Item>
                <Item>customer</Item>
            </Array>
        </Value>
    </Setting>

    <Setting Name="OTOBOAI::OnlyVisibleForCustomer" Required="0" Valid="1">
        <Description Translatable="1">Allow only articles visible for customers to be ingested by the RAG. If set, notes will be excluded from ingestion.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
                <Item ValueType="Checkbox">1</Item>
        </Value>
    </Setting>

    <Setting Name="OTOBOAI::QueueToRAGMapping" Required="0" Valid="0">
        <Description Translatable="1">Determine the use-case specific RAG pipeline to invoke depending on queue name. If no RAG pipeline is configured here, the default RAG is used. Subqueues have to be listed using ::-notation.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
                <Hash>
                    <Item Key="Raw">Custom1</Item>
                    <Item Key="Postmaster">Custom2</Item>
                </Hash>
        </Value>
    </Setting>

    <Setting Name="OTOBOAI::DefaultRAG" Required="0" Valid="1">
        <Description Translatable="1">Set the default RAG pipeline used as a fallback and in the dashboard widget.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Item ValueType="String">default</Item>
        </Value>
    </Setting>

    <Setting Name="Ticket::Frontend::MenuModule###452-AIChat" Required="0" Valid="1">
        <Description Translatable="1">Open the OTOBO AI Chat.</Description>
        <Navigation>Frontend::Agent::View::TicketZoom::MenuModule</Navigation>
        <Value>
            <Hash>
                <Item Key="Module">Kernel::Output::HTML::TicketMenu::Generic</Item>
                <Item Key="Name" Translatable="1">AI Chat</Item>
                <Item Key="Description" Translatable="1">Chat with AI about this ticket.</Item>
                <Item Key="Action">AgentTicketAIChat</Item>
                <Item Key="Link">Action=AgentTicketAIChat;TicketID=[% Data.TicketID | html %]</Item>
                <Item Key="Target"></Item>
                <Item Key="PopupType">TicketAction</Item>
            </Hash>
        </Value>
    </Setting>

    <Setting Name="Frontend::Module###AgentTicketAIChat" Required="0" Valid="1">
        <Description Translatable="1">Frontend module registration for the agent interface.</Description>
        <Navigation>Frontend::Agent::ModuleRegistration</Navigation>
        <Value>
            <Item ValueType="FrontendRegistration">
                <Hash>
                    <Item Key="GroupRo">
                        <Array>
                        </Array>
                    </Item>
                    <Item Key="Group">
                        <Array>
                        </Array>
                    </Item>
                    <Item Key="Description" Translatable="1">This module is part of the agent area of OTOBO.</Item>
                    <Item Key="Title" Translatable="1">AI Chat Launcher</Item>
                    <Item Key="NavBarName"></Item>
                </Hash>
            </Item>
        </Value>
    </Setting>
    <!--
    <Setting Name="Loader::Module::AgentTicketAIChat###003-OTOBOAI" Required="0" Valid="1">
        <Description Translatable="1">Loader module registration for the agent interface.</Description>
        <Navigation>Frontend::Agent::ModuleRegistration::Loader</Navigation>
        <Value>
            <Hash>
                <Item Key="JavaScript">
                    <Array>
                    </Array>
                </Item>
            </Hash>
        </Value>
    </Setting>
-->

    <Setting Name="OTOBOAI::MCP::Host" Required="0" Valid="1">
        <Description Translatable="1">The hostname of the MCP server, e.g., 'mcp' when running in Docker.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Item ValueType="String">mcp</Item>
        </Value>
    </Setting>

    <Setting Name="OTOBOAI::Chat::Endpoint" Required="0" Valid="1">
        <Description Translatable="1">The endpoint url of the AI chat interface. It may include the following placeholder {{OTOBO_SID}}, {{TICKET_ID}}, and {{ARTICLE_ID}} to pass the context to the chat.</Description>
        <Navigation>Core::OTOBOAI</Navigation>
        <Value>
            <Item ValueType="String">https://{{FQDN}}:9000/?model=beta-generate-2&amp;q=Hallo%2C%20merke%20dir%20diese%20Daten%3A%20{{OTOBO_SID}}{{TICKET_ID}}{{ARTICLE_ID}}</Item>
        </Value>
    </Setting>

    <Setting Name="GenericInterface::Operation::Module###Ticket::ArticleDFUpdate" Required="0" Valid="1">
        <Description Translatable="1">GenericInterface module registration for the operation layer.</Description>
        <Navigation>GenericInterface::Operation::ModuleRegistration</Navigation>
        <Value>
            <Hash>
                <Item Key="Name">ArticleDFUpdate</Item>
                <Item Key="Controller">Ticket</Item>
                <Item Key="ConfigDialog">AdminGenericInterfaceOperationDefault</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="GenericInterface::Operation::Module###Ticket::Link" Required="0" Valid="1">
        <Description Translatable="1">GenericInterface module registration for the operation layer.</Description>
        <Navigation>GenericInterface::Operation::ModuleRegistration</Navigation>
        <Value>
            <Hash>
                <Item Key="Name">Link</Item>
                <Item Key="Controller">Ticket</Item>
                <Item Key="ConfigDialog">AdminGenericInterfaceOperationDefault</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="GenericInterface::Operation::Module###Ticket::UnLink" Required="0" Valid="1">
        <Description Translatable="1">GenericInterface module registration for the operation layer.</Description>
        <Navigation>GenericInterface::Operation::ModuleRegistration</Navigation>
        <Value>
            <Hash>
                <Item Key="Name">UnLink</Item>
                <Item Key="Controller">Ticket</Item>
                <Item Key="ConfigDialog">AdminGenericInterfaceOperationDefault</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="GenericInterface::Operation::Module###Ticket::QueryEmbeddings" Required="0" Valid="1">
        <Description Translatable="1">GenericInterface module registration for the operation layer.</Description>
        <Navigation>GenericInterface::Operation::ModuleRegistration</Navigation>
        <Value>
            <Hash>
                <Item Key="Name">QueryEmbeddings</Item>
                <Item Key="Controller">Ticket</Item>
                <Item Key="ConfigDialog">AdminGenericInterfaceOperationDefault</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="GenericInterface::Operation::Module###Ticket::TicketGetAI" Required="0" Valid="1">
        <Description Translatable="1">GenericInterface module registration for the operation layer.</Description>
        <Navigation>GenericInterface::Operation::ModuleRegistration</Navigation>
        <Value>
            <Hash>
                <Item Key="Name">TicketGetAI</Item>
                <Item Key="Controller">Ticket</Item>
                <Item Key="ConfigDialog">AdminGenericInterfaceOperationDefault</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="GenericInterface::Operation::Module###ElasticSearch::FAQSearch" Required="0" Valid="1">
        <Description Translatable="1">GenericInterface module registration for the operation layer.</Description>
        <Navigation>GenericInterface::Operation::ModuleRegistration</Navigation>
        <Value>
            <Hash>
                <Item Key="Name">FAQSearch</Item>
                <Item Key="Controller">ElasticSearch</Item>
                <Item Key="ConfigDialog">AdminGenericInterfaceOperationDefault</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="GenericInterface::Operation::Module###ElasticSearch::TicketSearch" Required="0" Valid="1">
        <Description Translatable="1">GenericInterface module registration for the operation layer.</Description>
        <Navigation>GenericInterface::Operation::ModuleRegistration</Navigation>
        <Value>
            <Hash>
                <Item Key="Name">TicketSearch</Item>
                <Item Key="Controller">ElasticSearch</Item>
                <Item Key="ConfigDialog">AdminGenericInterfaceOperationDefault</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="Ticket::Frontend::AgentTicketZoom###Widgets###0450-AISimilarTickets" Required="0" Valid="0">
        <Description Translatable="1">AgentTicketZoom widget that displays similar ticket data in the side bar. The RAG container must be available.</Description>
        <Navigation>Frontend::Agent::View::TicketZoom</Navigation>
        <Value>
            <Hash>
                <Item Key="Module">Kernel::Output::HTML::TicketZoom::AISimilarTickets</Item>
                <Item Key="Location">Sidebar</Item>
                <Item Key="Async">1</Item>
            </Hash>
        </Value>
    </Setting>
</otobo_config>
 # --
# 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/
# --
# 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::GenericInterface::Operation::Ticket::ArticleDFUpdate;

use v5.24;
use strict;
use warnings;

use parent qw(
    Kernel::GenericInterface::Operation::Ticket::TicketUpdate
);

# core modules
use Scalar::Util qw(reftype);
use MIME::Base64 qw(encode_base64);

# CPAN modules

# OTOBO modules
use Kernel::System::VariableCheck qw(IsArrayRefWithData IsHashRefWithData IsString IsStringWithData);

our $ObjectManagerDisabled = 1;

=head1 NAME

Kernel::GenericInterface::Operation::Ticket::ArticleDFUpdate - GenericInterface Article Dynamic Field Update

=head1 PUBLIC INTERFACE

=head2 new()

usually, you want to create an instance of this
by using C<Kernel::GenericInterface::Operation->new();>.

=cut

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

    my $Self = bless {}, $Type;

    # check needed objects
    for my $Needed (qw( DebuggerObject WebserviceID )) {
        if ( !$Param{$Needed} ) {
            return {
                Success      => 0,
                ErrorMessage => "Got no $Needed!",
            };
        }

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

    $Self->{Config}    = $Kernel::OM->Get('Kernel::Config')->Get('GenericInterface::Operation::ArticleDFUpdate');
    $Self->{Operation} = $Param{Operation};

    return $Self;
}

=head2 Run()

perform UpdateArticleDynamicField Operation. This will return the updated TicketID and
the updated ArticleID.

    my $Result = $OperationObject->Run(
        Data => {
            UserLogin         => 'some agent login',                            # UserLogin or CustomerUserLogin or SessionID is
                                                                                #   required
            SessionID         => 123,

            Password  => 'some password',                                       # if UserLogin or customerUserLogin is sent then
                                                                                #   Password is required

            TicketID     => 123,                                                # TicketID or TicketNumber is required
            TicketNumber => '2004040510440485',

            ArticleID    => 123,                                                # optional, otherwise last customer article id is used
            DynamicField =>
                {
                    Name   => 'some name',
                    Value  => $Value,                                          # value type depends on the dynamic field
                },
                # ...
            ],
        },
    );

    $Result = {
        Success         => 1,                       # 0 or 1
        ErrorMessage    => '',                      # in case of error
        Data            => {                        # result data payload after Operation
            TicketID    => 123,                     # Ticket  ID number in OTOBO (help desk system)
            ArticleID   => 43,                      # Article ID number in OTOBO (help desk system)
        },
    };

=cut

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

    my $Result = $Self->Init(
        WebserviceID => $Self->{WebserviceID},
    );

    if ( !$Result->{Success} ) {
        $Self->ReturnError(
            ErrorCode    => 'Webservice.InvalidConfiguration',
            ErrorMessage => $Result->{ErrorMessage},
        );
    }

    # check needed stuff
    if ( !IsHashRefWithData( $Param{Data} ) ) {
        return $Self->ReturnError(
            ErrorCode    => 'ArticleDFUpdate.EmptyRequest',
            ErrorMessage => "ArticleDFUpdate: The request data is invalid!",
        );
    }

    if ( !$Param{Data}->{TicketID} && !$Param{Data}->{TicketNumber} ) {
        return $Self->ReturnError(
            ErrorCode    => 'ArticleDFUpdate.MissingParameter',
            ErrorMessage => "ArticleDFUpdate: TicketID or TicketNumber is required!",
        );
    }

    if (
        !$Param{Data}->{UserLogin}
        && !$Param{Data}->{SessionID}
        )
    {
        return $Self->ReturnError(
            ErrorCode    => 'ArticleDFUpdate.MissingParameter',
            ErrorMessage => "ArticleDFUpdate: UserLogin or SessionID is required!",
        );
    }

    if ( $Param{Data}->{UserLogin} ) {
        if ( !$Param{Data}->{Password} ) {
            return $Self->ReturnError(
                ErrorCode    => 'ArticleDFUpdate.MissingParameter',
                ErrorMessage => "ArticleDFUpdate: Password or SessionID is required!",
            );
        }
    }

    # authenticate user
    my ( $UserID, $UserType ) = $Self->Auth(
        %Param,
    );

    if ( !$UserID ) {
        return $Self->ReturnError(
            ErrorCode    => 'ArticleDFUpdate.AuthFail',
            ErrorMessage => "ArticleDFUpdate: User could not be authenticated!",
        );
    }

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

    # check TicketID
    my $TicketID;
    if ( $Param{Data}->{TicketNumber} ) {
        $TicketID = $TicketObject->TicketIDLookup(
            TicketNumber => $Param{Data}->{TicketNumber},
            UserID       => $UserID,
        );

    }
    else {
        $TicketID = $Param{Data}->{TicketID};
    }

    if ( !($TicketID) ) {
        return $Self->ReturnError(
            ErrorCode    => 'ArticleDFUpdate.AccessDenied',
            ErrorMessage => "ArticleDFUpdate: User does not have access to the ticket!",
        );
    }

    my %TicketData = $TicketObject->TicketGet(
        TicketID      => $TicketID,
        DynamicFields => 0,
        UserID        => $UserID,
    );

    if ( !IsHashRefWithData( \%TicketData ) ) {
        return $Self->ReturnError(
            ErrorCode    => 'ArticleDFUpdate.AccessDenied',
            ErrorMessage => "ArticleDFUpdate: User does not have access to the ticket!",
        );
    }

    # check basic needed permissions
    my $Access;
    if ( $UserType eq 'User' ) {

        $Access = $TicketObject->TicketPermission(
            Type     => 'rw',
            TicketID => $TicketID,
            UserID   => $UserID,
        );
    }
    else {
        $Access = $TicketObject->TicketCustomerPermission(
            Type     => 'rw',
            TicketID => $TicketID,
            UserID   => $UserID,
        );
    }
    if ( !$Access ) {
        return $Self->ReturnError(
            ErrorCode    => 'ArticleDFUpdate.AccessDenied',
            ErrorMessage => "ArticleDFUpdate: User does not have access to the ticket!",
        );
    }

    my $DynamicFields = $Param{Data}->{DynamicField};
    if ( !IsArrayRefWithData($DynamicFields) ) {

        if ( !IsHashRefWithData($DynamicFields) ) {
            return $Self->ReturnError(
                ErrorCode    => 'ArticleDFUpdate.MissingParameter',
                ErrorMessage => "ArticleDFUpdate: DynamicField Element is missing.",
            );
        }
        $DynamicFields = [$DynamicFields];
    }

    if ( !IsArrayRefWithData($DynamicFields) ) {

        return $Self->ReturnError(
            ErrorCode    => 'ArticleDFUpdate.MissingParameter',
            ErrorMessage => "ArticleDFUpdate: DynamicField Element is empty.",
        );
    }

    for my $DynamicField ( $DynamicFields->@* ) {

        if ( !IsHashRefWithData($DynamicField) ) {
            return $Self->ReturnError(
                ErrorCode    => 'ArticleDFUpdate.MissingParameter',
                ErrorMessage => "ArticleDFUpdate: DynamicField Element is missing.",
            );
        }

        if ( !$DynamicField->{Name} ) {
            return $Self->ReturnError(
                ErrorCode    => 'ArticleDFUpdate.MissingParameter',
                ErrorMessage => "ArticleDFUpdate: DynamicField Element is missing child key 'Name'.",
            );
        }

        if ( !$DynamicField->{Value} ) {
            return $Self->ReturnError(
                ErrorCode    => 'ArticleDFUpdate.MissingParameter',
                ErrorMessage => "ArticleDFUpdate: DynamicField Element is missing child key 'Value'.",
            );
        }
    }

    # do the DF update

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

    my $ArticleID = $Param{Data}->{ArticleID};
    if ( !$ArticleID ) {

        my @Articles = $ArticleObject->ArticleList(
            TicketID   => $TicketID,
            SenderType => 'customer',
            OnlyLast   => 1,
        );
        if (@Articles) {
            $ArticleID = $Articles[0]{ArticleID};
        }
    }

    if ( !$ArticleID ) {

        return $Self->ReturnError(
            ErrorCode    => 'ArticleDFUpdate.NoCustomerArticle',
            ErrorMessage => 'This ticket does not have a customer article.',
        );
    }

    $Result = 1;

    DYNAMICFIELD:
    for my $DynamicField ( $DynamicFields->@* ) {

        my $DynamicFieldConfig = $DynamicFieldObject->DynamicFieldGet(
            Name => $DynamicField->{Name},
        );

        my $Success = $BackendObject->ValueSet(
            DynamicFieldConfig => $DynamicFieldConfig,       # complete config of the DynamicField
            ObjectID           => $ArticleID,                # ID of the current object that the field
                                                             # must be linked to, e. g. TicketID
            Value              => $DynamicField->{Value},    # Value to store, depends on backend type
            UserID             => $UserID,
            DoWrite            => 1,                         # specific to OTOBOAI DF
        );

        if ( !$Success ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Unable to set value '"
                    . $DynamicField->{Value}
                    . "' for DF "
                    . $DynamicField->{Name}
                    . " on ArticleID $ArticleID with TicketID $TicketID",
            );
        }

        $Result = $Success if $Result;
    }

    return {
        Success => $Result,
        Data    => {
            TicketID  => $TicketID,
            ArticleID => $ArticleID,
            Success   => 1,
        }
    };
}

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

use strict;
use warnings;

use parent qw(
    Kernel::GenericInterface::Operation::Common
    Kernel::GenericInterface::Operation::Ticket::Common
);

# core modules
use MIME::Base64 qw(encode_base64);

# CPAN modules

# OTOBO modules
use Kernel::System::VariableCheck qw(IsArrayRefWithData IsHashRefWithData IsStringWithData);

our $ObjectManagerDisabled = 1;

=begin stopwords

OSS ai

=end stopwords

=head1 NAME

Kernel::GenericInterface::Operation::Ticket::TicketGetAI - GenericInterface Ticket Get Operation backend

=head1 PUBLIC INTERFACE

=head2 new()

usually, you want to create an instance of this
by using Kernel::GenericInterface::Operation->new();

=cut

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

    my $Self = {};
    bless( $Self, $Type );

    # check needed objects
    for my $Needed (qw(DebuggerObject WebserviceID)) {
        if ( !$Param{$Needed} ) {
            return {
                Success      => 0,
                ErrorMessage => "Got no $Needed!",
            };
        }

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

    return $Self;
}

=head2 Run()

perform TicketGet Operation. This function is able to return
one or more ticket entries in one call.

    my $Result = $OperationObject->Run(
        Data => {
            UserLogin            => 'some agent login',                            # UserLogin or CustomerUserLogin or SessionID is
                                                                                   #   required
            CustomerUserLogin    => 'some customer login',
            SessionID            => 123,

            Password             => 'some password',                               # if UserLogin or customerUserLogin is sent then
                                                                                   #   Password is required
            TicketID             => '32,33',                                       # required, could be coma separated IDs or an Array
            DynamicFields        => 0,                                             # Optional, 0 as default. Indicate if Dynamic Fields
                                                                                   #     should be included or not on the ticket content.
            Extended             => 1,                                             # Optional, 0 as default
            AllArticles          => 1,                                             # Optional, 0 as default. Set as 1 will include articles
                                                                                   #     for tickets.
            ArticleSenderType    => [ $ArticleSenderType1, $ArticleSenderType2 ],  # Optional, only requested article sender types
            ArticleOrder         => 'DESC',                                        # Optional, DESC,ASC - default is ASC
            ArticleLimit         => 5,                                             # Optional
            Attachments          => 1,                                             # Optional, 0 as default. If it's set with the value 1,
                                                                                   # attachments for articles will be included on ticket data
            GetAttachmentContents = 1                                              # Optional, 1 as default. 0|1,
            HTMLBodyAsAttachment => 1                                              # Optional, If enabled the HTML body version of each article
                                                                                   #    is added to the attachments list
# Rother OSS / otobo-ai
            Links                => undef | 1 | [ 'Ticket', 'FAQ', 'ConfigItem']
# EO otobo-ai
        },
    );

    $Result = {
        Success      => 1,                                # 0 or 1
        ErrorMessage => '',                               # In case of an error
        Data         => {
            Ticket => [
                {
                    TicketNumber       => '20101027000001',
                    Title              => 'some title',
                    TicketID           => 123,
                    State              => 'some state',
                    StateID            => 123,
                    StateType          => 'some state type',
                    Priority           => 'some priority',
                    PriorityID         => 123,
                    Lock               => 'lock',
                    LockID             => 123,
                    Queue              => 'some queue',
                    QueueID            => 123,
                    CustomerID         => 'customer_id_123',
                    CustomerUserID     => 'customer_user_id_123',
                    Owner              => 'some_owner_login',
                    OwnerID            => 123,
                    Type               => 'some ticket type',
                    TypeID             => 123,
                    SLA                => 'some sla',
                    SLAID              => 123,
                    Service            => 'some service',
                    ServiceID          => 123,
                    Responsible        => 'some_responsible_login',
                    ResponsibleID      => 123,
                    Age                => 3456,
                    Created            => '2010-10-27 20:15:00'
                    CreateBy           => 123,
                    Changed            => '2010-10-27 20:15:15',
                    ChangeBy           => 123,
                    ArchiveFlag        => 'y',
                    TimeUnit           => 123,

                    # If DynamicFields => 1 was passed, you'll get an entry like this for each dynamic field:
                    DynamicField => [
                        {
                            Name  => 'some name',
                            Value => 'some value',
                        },
                    ],

                    # (time stamps of expected escalations)
                    EscalationResponseTime           (unix time stamp of response time escalation)
                    EscalationUpdateTime             (unix time stamp of update time escalation)
                    EscalationSolutionTime           (unix time stamp of solution time escalation)

                    # (general escalation info of nearest escalation type)
                    EscalationDestinationIn          (escalation in e. g. 1h 4m)
                    EscalationDestinationTime        (date of escalation in unix time, e. g. 72193292)
                    EscalationDestinationDate        (date of escalation, e. g. "2009-02-14 18:00:00")
                    EscalationTimeWorkingTime        (seconds of working/service time till escalation, e. g. "1800")
                    EscalationTime                   (seconds total till escalation of nearest escalation time type - response, update or solution time, e. g. "3600")

                    # (detailed escalation info about first response, update and solution time)
                    FirstResponseTimeEscalation      (if true, ticket is escalated)
                    FirstResponseTimeNotification    (if true, notify - x% of escalation has reached)
                    FirstResponseTimeDestinationTime (date of escalation in unix time, e. g. 72193292)
                    FirstResponseTimeDestinationDate (date of escalation, e. g. "2009-02-14 18:00:00")
                    FirstResponseTimeWorkingTime     (seconds of working/service time till escalation, e. g. "1800")
                    FirstResponseTime                (seconds total till escalation, e. g. "3600")

                    UpdateTimeEscalation             (if true, ticket is escalated)
                    UpdateTimeNotification           (if true, notify - x% of escalation has reached)
                    UpdateTimeDestinationTime        (date of escalation in unix time, e. g. 72193292)
                    UpdateTimeDestinationDate        (date of escalation, e. g. "2009-02-14 18:00:00")
                    UpdateTimeWorkingTime            (seconds of working/service time till escalation, e. g. "1800")
                    UpdateTime                       (seconds total till escalation, e. g. "3600")

                    SolutionTimeEscalation           (if true, ticket is escalated)
                    SolutionTimeNotification         (if true, notify - x% of escalation has reached)
                    SolutionTimeDestinationTime      (date of escalation in unix time, e. g. 72193292)
                    SolutionTimeDestinationDate      (date of escalation, e. g. "2009-02-14 18:00:00")
                    SolutionTimeWorkingTime          (seconds of working/service time till escalation, e. g. "1800")
                    SolutionTime                     (seconds total till escalation, e. g. "3600")

                    # if you use param Extended to get extended ticket attributes
                    FirstResponse                   (timestamp of first response, first contact with customer)
                    FirstResponseInMin              (minutes till first response)
                    FirstResponseDiffInMin          (minutes till or over first response)

                    SolutionInMin                   (minutes till solution time)
                    SolutionDiffInMin               (minutes till or over solution time)

                    FirstLock                       (timestamp of first lock)

# Rother OSS / otobo-ai
                    Links => [
                        {
                            "TargetType" => "Ticket",
                            "TargetID"   => "3",
                            "LinkType"   => "Normal"
                        }
                    ],
# EO otobo-ai

                    Article => [
                        {
                            ArticleID
                            From
                            To
                            Cc
                            Subject
                            Body
                            ReplyTo
                            MessageID
                            InReplyTo
                            References
                            SenderType
                            SenderTypeID
                            IsVisibleForCustomer
                            ContentType
                            Charset
                            MimeType
                            IncomingTime
                            TimeUnit

                            # If DynamicFields => 1 was passed, you'll get an entry like this for each dynamic field:
                            DynamicField => [
                                {
                                    Name  => 'some name',
                                    Value => 'some value',
                                },
                            ],

                            Attachment => [
                                {
                                    Content            => "xxxx",     # actual attachment contents, base64 enconded
                                    ContentAlternative => "",
                                    ContentID          => "",
                                    ContentType        => "application/pdf",
                                    FileID             => 34,
                                    Filename           => "StdAttachment-Test1.pdf",
                                    FilesizeRaw        => 4722,
                                },
                                {
                                   # . . .
                                },
                            ]
                        },
                        {
                            #. . .
                        },
                    ],
                },
                {
                    #. . .
                },
            ]
        },
    };

=cut

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

    my $Result = $Self->Init(
        WebserviceID => $Self->{WebserviceID},
    );

    if ( !$Result->{Success} ) {
        return $Self->ReturnError(
            ErrorCode    => 'Webservice.InvalidConfiguration',
            ErrorMessage => $Result->{ErrorMessage},
        );
    }

    my ( $UserID, $UserType ) = $Self->Auth(
        %Param,
    );

    return $Self->ReturnError(
        ErrorCode    => 'TicketGet.AuthFail',
        ErrorMessage => "TicketGet: Authorization failing!",
    ) if !$UserID;

    # check needed stuff
    for my $Needed (qw(TicketID)) {
        if ( !$Param{Data}->{$Needed} ) {
            return $Self->ReturnError(
                ErrorCode    => 'TicketGet.MissingParameter',
                ErrorMessage => "TicketGet: $Needed parameter is missing!",
            );
        }
    }
    my $ErrorMessage = '';

    # all needed variables
    my @TicketIDs;
    if ( IsStringWithData( $Param{Data}->{TicketID} ) ) {
        @TicketIDs = split( /,/, $Param{Data}->{TicketID} );
    }
    elsif ( IsArrayRefWithData( $Param{Data}->{TicketID} ) ) {
        @TicketIDs = @{ $Param{Data}->{TicketID} };
    }
    else {
        return $Self->ReturnError(
            ErrorCode    => 'TicketGet.WrongStructure',
            ErrorMessage => "TicketGet: Structure for TicketID is not correct!",
        );
    }

    # Get the list of article dynamic fields
    my $ArticleDynamicFieldList = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldList(
        ObjectType => 'Article',
        ResultType => 'HASH',
    );

    # Crate a lookup list for easy search
    my %ArticleDynamicFieldLookup = reverse %{$ArticleDynamicFieldList};

    TICKET:
    for my $TicketID (@TicketIDs) {

        my $Access = $Self->CheckAccessPermissions(
            TicketID => $TicketID,
            UserID   => $UserID,
            UserType => $UserType,
        );

        next TICKET if $Access;

        return $Self->ReturnError(
            ErrorCode    => 'TicketGet.AccessDenied',
            ErrorMessage => 'TicketGet: User does not have access to the ticket!',
        );
    }

    my $DynamicFields         = $Param{Data}->{DynamicFields} || 0;
    my $Extended              = $Param{Data}->{Extended}      || 0;
    my $AllArticles           = $Param{Data}->{AllArticles}   || 0;
    my $ArticleOrder          = $Param{Data}->{ArticleOrder}  || 'ASC';
    my $ArticleLimit          = $Param{Data}->{ArticleLimit}  || 0;
    my $Attachments           = $Param{Data}->{Attachments}   || 0;
    my $GetAttachmentContents = $Param{Data}->{GetAttachmentContents} // 1;

    my $ReturnData = {
        Success => 1,
    };
    my @Item;

    my $ArticleSenderType = '';
    if ( IsArrayRefWithData( $Param{Data}->{ArticleSenderType} ) ) {
        $ArticleSenderType = $Param{Data}->{ArticleSenderType};
    }
    elsif ( IsStringWithData( $Param{Data}->{ArticleSenderType} ) ) {
        $ArticleSenderType = [ $Param{Data}->{ArticleSenderType} ];
    }

    # By default, do not include HTML body as attachment, unless it is explicitly requested.
    my %ExcludeAttachments = (
        ExcludePlainText => 1,
        ExcludeHTMLBody  => $Param{Data}->{HTMLBodyAsAttachment} ? 0 : 1,
    );

    # start ticket loop
    TICKET:
    for my $TicketID (@TicketIDs) {
        my $TicketArticleLimit = $ArticleLimit;

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

        # get the Ticket entry
        my %TicketEntryRaw = $TicketObject->TicketGet(
            TicketID      => $TicketID,
            DynamicFields => $DynamicFields,
            Extended      => $Extended,
            UserID        => $UserID,
        );

        if ( !IsHashRefWithData( \%TicketEntryRaw ) ) {

            $ErrorMessage = 'Could not get Ticket data'
                . ' in Kernel::GenericInterface::Operation::Ticket::TicketGet::Run()';

            return $Self->ReturnError(
                ErrorCode    => 'TicketGet.NotValidTicketID',
                ErrorMessage => "TicketGet: $ErrorMessage",
            );
        }

        my %TicketEntry;
        my @DynamicFields;

        # remove all dynamic fields from main ticket hash and set them into an array.
        ATTRIBUTE:
        for my $Attribute ( sort keys %TicketEntryRaw ) {

            if ( $Attribute =~ m{\A DynamicField_(.*) \z}msx ) {
                push @DynamicFields, {
                    Name  => $1,
                    Value => $TicketEntryRaw{$Attribute},
                };
                next ATTRIBUTE;
            }

            $TicketEntry{$Attribute} = $TicketEntryRaw{$Attribute};
        }

        $TicketEntry{TimeUnit} = $TicketObject->TicketAccountedTimeGet(
            TicketID => $TicketID,
        );

        # add dynamic fields array into 'DynamicField' hash key if any
        if (@DynamicFields) {
            $TicketEntry{DynamicField} = \@DynamicFields;
        }

        # set Ticket entry data
        my $TicketBundle = {
            %TicketEntry,
        };

        if ( !$AllArticles ) {
# Rother OSS / otobo-ai
            $TicketBundle->{Links} = $Self->_AddLinks(
                Data         => $Param{Data},
                TicketBundle => $TicketBundle
            );
# EO otobo-ai
            push @Item, $TicketBundle;
            next TICKET;
        }

        my %ArticleListFilters;
        if ( $UserType eq 'Customer' ) {
            %ArticleListFilters = (
                IsVisibleForCustomer => 1,
            );
        }

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

        my @Articles;
        if ($ArticleSenderType) {
            for my $SenderType ( @{ $ArticleSenderType || [] } ) {
                my @ArticlesFiltered = $ArticleObject->ArticleList(
                    TicketID   => $TicketID,
                    SenderType => $SenderType,
                    %ArticleListFilters,
                );
                push @Articles, @ArticlesFiltered;
            }
        }
        else {
            @Articles = $ArticleObject->ArticleList(
                TicketID => $TicketID,
                %ArticleListFilters,
            );
        }

        # Modify ArticleLimit if it is greater then number of articles (see bug#14585).
        if ( $ArticleLimit > scalar @Articles ) {
            $TicketArticleLimit = scalar @Articles;
        }

        # Set number of articles by ArticleLimit and ArticleOrder parameters.
        if ( IsArrayRefWithData( \@Articles ) && $TicketArticleLimit ) {
            if ( $ArticleOrder eq 'DESC' ) {
                @Articles = reverse @Articles;
            }
            @Articles = @Articles[ 0 .. ( $TicketArticleLimit - 1 ) ];
        }

        # start article loop
        ARTICLE:
        for my $Article (@Articles) {

            my $ArticleBackendObject = $ArticleObject->BackendForArticle( %{$Article} );

            my %ArticleData = $ArticleBackendObject->ArticleGet(
                TicketID      => $TicketID,
                ArticleID     => $Article->{ArticleID},
                DynamicFields => $DynamicFields,
            );
            $Article = \%ArticleData;

            next ARTICLE if !$Attachments;

            # get attachment index (without attachments)
            my %AtmIndex = $ArticleBackendObject->ArticleAttachmentIndex(
                ArticleID => $Article->{ArticleID},
                %ExcludeAttachments,
            );

            next ARTICLE if !IsHashRefWithData( \%AtmIndex );

            my @Attachments;
            ATTACHMENT:
            for my $FileID ( sort keys %AtmIndex ) {
                next ATTACHMENT if !$FileID;
                my %Attachment = $ArticleBackendObject->ArticleAttachment(
                    ArticleID => $Article->{ArticleID},
                    FileID    => $FileID,                 # as returned by ArticleAttachmentIndex
                );

                next ATTACHMENT if !IsHashRefWithData( \%Attachment );

                $Attachment{FileID} = $FileID;
                if ($GetAttachmentContents)
                {
                    # convert content to base64, but prevent 76 chars brake, see bug#14500.
                    $Attachment{Content} = encode_base64( $Attachment{Content}, '' );
                }
                else {
                    # unset content
                    $Attachment{Content}            = '';
                    $Attachment{ContentAlternative} = '';
                }
                push @Attachments, {%Attachment};
            }

            # set Attachments data
            $Article->{Attachment} = \@Attachments;

        }    # finish article loop

        # set Ticket entry data
        if (@Articles) {

            my @ArticleBox;

            for my $ArticleRaw (@Articles) {
                my %Article;
                my @ArticleDynamicFields;

                # remove all dynamic fields from main article hash and set them into an array.
                ATTRIBUTE:
                for my $Attribute ( sort keys %{$ArticleRaw} ) {

                    if ( $Attribute =~ m{\A DynamicField_(.*) \z}msx ) {

                        # skip dynamic fields that are not article related
                        # this is needed because ArticleGet() also returns ticket dynamic fields
                        next ATTRIBUTE if ( !$ArticleDynamicFieldLookup{$1} );

                        push @ArticleDynamicFields, {
                            Name  => $1,
                            Value => $ArticleRaw->{$Attribute},
                        };
                        next ATTRIBUTE;
                    }

                    $Article{$Attribute} = $ArticleRaw->{$Attribute};
                }

                $Article{TimeUnit} = $ArticleObject->ArticleAccountedTimeGet(
                    ArticleID => $ArticleRaw->{ArticleID}
                );

                # add dynamic fields array into 'DynamicField' hash key if any
                if (@ArticleDynamicFields) {
                    $Article{DynamicField} = \@ArticleDynamicFields;
                }

                push @ArticleBox, \%Article;
            }
            $TicketBundle->{Article} = \@ArticleBox;
        }

# Rother OSS / otobo-ai
        $TicketBundle->{Links} = $Self->_AddLinks(
            Data         => $Param{Data},
            TicketBundle => $TicketBundle
        );
# EO otobo-ai

        push @Item, $TicketBundle;
    }    # finish ticket loop

    if ( !scalar @Item ) {
        $ErrorMessage = 'Could not get Ticket data'
            . ' in Kernel::GenericInterface::Operation::Ticket::TicketGet::Run()';

        return $Self->ReturnError(
            ErrorCode    => 'TicketGet.NotTicketData',
            ErrorMessage => "TicketGet: $ErrorMessage",
        );

    }

    # set ticket data into return structure
    $ReturnData->{Data}->{Ticket} = \@Item;

    # return result
    return $ReturnData;
}

# Rother OSS / otobo-ai
sub _AddLinks {

    my ( $Self, %Param ) = @_;
    my $TicketBundle = $Param{TicketBundle};
    my $TicketID     = $TicketBundle->{TicketID};

    # get links
    my $GetLinks = $Param{Data}->{Links};
    if ($GetLinks) {

        if ( ref $GetLinks ne 'ARRAY' ) {
            $GetLinks = [$GetLinks];
        }
        my $LinkObject = $Kernel::OM->Get('Kernel::System::LinkObject');
        my $Links      = $LinkObject->LinkListWithData(
            Object    => 'Ticket',
            Key       => $TicketID,
            State     => 'Valid',
            UserID    => 1,
            Direction => 'Both',
        );

        my @Links2Return;

        OBJECTTYPE:
        for my $TargetType ( $GetLinks->@* ) {

            next OBJECTTYPE if !exists $Links->{$TargetType};

            for my $LinkKind ( keys $Links->{$TargetType}->%* ) {

                for my $Direction ( keys $Links->{$TargetType}->{$LinkKind}->%* ) {

                    for my $Link ( keys $Links->{$TargetType}->{$LinkKind}->{$Direction}->%* ) {

                        my $Data = $Links->{$TargetType}->{$LinkKind}->{$Direction}->{$Link};

                        push @Links2Return, {
                            LinkType   => $LinkKind,
                            TargetType => $TargetType,
                            TargetID   => $Link,
                            Data       => $Data,
                            Direction  => $Direction,
                        };
                    }
                }
            }
        }
        return \@Links2Return;
    }

    return [];
}

# EO otobo-ai

1;
 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjYgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIEtlcm5lbDo6R2VuZXJpY0ludGVyZmFjZTo6T3BlcmF0aW9uOjpFbGFzdGljU2VhcmNoOjpUaWNrZXRTZWFyY2g7Cgp1c2Ugc3RyaWN0Owp1c2Ugd2FybmluZ3M7Cgp1c2UgS2VybmVsOjpTeXN0ZW06OlZhcmlhYmxlQ2hlY2sgcXcoIDphbGwgKTsKCnVzZSBwYXJlbnQgcXcoCiAgICBLZXJuZWw6OkdlbmVyaWNJbnRlcmZhY2U6Ok9wZXJhdGlvbjo6Q29tbW9uCik7CgpvdXIgJE9iamVjdE1hbmFnZXJEaXNhYmxlZCA9IDE7Cgo9aGVhZDEgTkFNRQoKS2VybmVsOjpHZW5lcmljSW50ZXJmYWNlOjpPcGVyYXRpb246OkVsYXN0aWNTZWFyY2g6OlRpY2tldFNlYXJjaCAtIEdlbmVyaWNJbnRlcmZhY2UgRVMgU2VhcmNoIE9wZXJhdGlvbiBiYWNrZW5kIGZvciBUaWNrZXRzCgo9aGVhZDEgUFVCTElDIElOVEVSRkFDRQoKPWhlYWQyIG5ldygpCgp1c3VhbGx5LCB5b3Ugd2FudCB0byBjcmVhdGUgYW4gaW5zdGFuY2Ugb2YgdGhpcwpieSB1c2luZyBLZXJuZWw6OkdlbmVyaWNJbnRlcmZhY2U6Ok9wZXJhdGlvbi0+bmV3KCk7Cgo9Y3V0CgpzdWIgbmV3IHsKICAgIG15ICggJFR5cGUsICVQYXJhbSApID0gQF87CgogICAgbXkgJFNlbGYgPSB7fTsKICAgIGJsZXNzKCAkU2VsZiwgJFR5cGUgKTsKCiAgICAjIGNoZWNrIG5lZWRlZCBvYmplY3RzCiAgICBmb3IgbXkgJE5lZWRlZCAocXcoRGVidWdnZXJPYmplY3QgV2Vic2VydmljZUlEKSkgewogICAgICAgIGlmICggISRQYXJhbXskTmVlZGVkfSApIHsKICAgICAgICAgICAgcmV0dXJuIHsKICAgICAgICAgICAgICAgIFN1Y2Nlc3MgICAgICA9PiAwLAogICAgICAgICAgICAgICAgRXJyb3JNZXNzYWdlID0+ICJHb3Qgbm8gJE5lZWRlZCEiLAogICAgICAgICAgICB9OwogICAgICAgIH0KCiAgICAgICAgJFNlbGYtPnskTmVlZGVkfSA9ICRQYXJhbXskTmVlZGVkfTsKICAgIH0KCiAgICByZXR1cm4gJFNlbGY7Cn0KCj1oZWFkMiBJbml0KCkKCmluaXRpYWxpemUgdGhlIG9wZXJhdGlvbiBieSBjaGVja2luZyB0aGUgd2ViIHNlcnZpY2UgY29uZmlndXJhdGlvbiBhbmQgZ2F0aGVyIG9mIHRoZSBkeW5hbWljIGZpZWxkcwoKICAgIG15ICRSZXR1cm4gPSAkQ29tbW9uT2JqZWN0LT5Jbml0KAogICAgICAgIFdlYnNlcnZpY2VJRCA9PiAxLAogICAgKTsKCnJldHVybnM6CgogICAgJFJldHVybiA9IHsKICAgICAgICBTdWNjZXNzID0+IDEsICAgICAgICAgICAgICAgICAgICAgICAjIG9yIDAgaW4gY2FzZSBvZiBmYWlsdXJlLAogICAgICAgIEVycm9yTWVzc2FnZSA9PiAnRXJyb3IgTWVzc2FnZScsCiAgICB9Cgo9Y3V0CgpzdWIgSW5pdCB7CiAgICBteSAoICRTZWxmLCAlUGFyYW0gKSA9IEBfOwoKICAgICMgY2hlY2sgbmVlZGVkCiAgICBpZiAoICEkUGFyYW17V2Vic2VydmljZUlEfSApIHsKICAgICAgICByZXR1cm4gewogICAgICAgICAgICBTdWNjZXNzICAgICAgPT4gMCwKICAgICAgICAgICAgRXJyb3JNZXNzYWdlID0+ICJHb3Qgbm8gV2Vic2VydmljZUlEISIsCiAgICAgICAgfTsKICAgIH0KCiAgICAjIGdldCB3ZWIgc2VydmljZSBjb25maWd1cmF0aW9uCiAgICBteSAkV2Vic2VydmljZSA9ICRLZXJuZWw6Ok9NLT5HZXQoJ0tlcm5lbDo6U3lzdGVtOjpHZW5lcmljSW50ZXJmYWNlOjpXZWJzZXJ2aWNlJyktPldlYnNlcnZpY2VHZXQoCiAgICAgICAgSUQgPT4gJFBhcmFte1dlYnNlcnZpY2VJRH0sCiAgICApOwoKICAgIGlmICggIUlzSGFzaFJlZldpdGhEYXRhKCRXZWJzZXJ2aWNlKSApIHsKICAgICAgICByZXR1cm4gewogICAgICAgICAgICBTdWNjZXNzICAgICAgPT4gMCwKICAgICAgICAgICAgRXJyb3JNZXNzYWdlID0+CiAgICAgICAgICAgICAgICAnQ291bGQgbm90IGRldGVybWluZSBXZWIgc2VydmljZSBjb25maWd1cmF0aW9uJwogICAgICAgICAgICAgICAgLiAnIGluIEtlcm5lbDo6R2VuZXJpY0ludGVyZmFjZTo6T3BlcmF0aW9uOjpUaWNrZXQ6OkNvbW1vbjo6bmV3KCknLAogICAgICAgIH07CiAgICB9CgogICAgcmV0dXJuIHsKICAgICAgICBTdWNjZXNzID0+IDEsCiAgICB9Owp9Cgo9aGVhZDIgUnVuKCkKClBlcmZvcm0gRkFRU2VhcmNoIE9wZXJhdGlvbi4gVGhpcyB3aWxsIHJldHVybiBUaWNrZXQgaXRlbXMgZnJvbSBFUy4KCiAgICBteSAkUmVzdWx0ID0gJE9wZXJhdGlvbk9iamVjdC0+UnVuKAoKICAgICAgICBEYXRhID0+IHsKICAgICAgICAgICAgRnVsbHRleHQgPT4gJ3NlYXJjaHRlcm0nCiAgICAgICAgICAgIExpbWl0ICAgID0+IDEwLCAgICAgICAgICAgICAgICAgICAgIyBvcHRpb25hbCwgZGVmYXVsdCBpcyAxMAogICAgICAgIH0KICAgICk7CgogICAgJFJlc3VsdCA9IHsKICAgICAgICBTdWNjZXNzICAgICAgPT4gMSwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICMgMCBvciAxCiAgICAgICAgRXJyb3JNZXNzYWdlID0+ICcnLCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAjIEluIGNhc2Ugb2YgYW4gZXJyb3IKICAgICAgICBEYXRhICAgICAgICAgPT4gWwogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAnQXR0YWNobWVudHMnID0+IFtdLAogICAgICAgICAgICAgICAgJ0NhdGVnb3J5SUQnID0+IDEsCiAgICAgICAgICAgICAgICAnRmllbGQxJyA9PiAnPHN5bXB0aG9tPicsCiAgICAgICAgICAgICAgICAnRmllbGQyJyA9PiAnPHByb2JsZW0+JywKICAgICAgICAgICAgICAgICdGaWVsZDMnID0+ICc8c29sdXRpb24+JywKICAgICAgICAgICAgICAgICdJdGVtSUQnID0+IDIsCiAgICAgICAgICAgICAgICAnS2V5d29yZHMnID0+ICdLYXR6ZSwgSHVuZ2VyLCBGdXR0ZXInLAogICAgICAgICAgICAgICAgJ051bWJlcicgPT4gJzEwMDAyJywKICAgICAgICAgICAgICAgICdTdGF0ZVR5cGVJRCcgPT4gMSwKICAgICAgICAgICAgICAgICdUaXRsZScgPT4gJ0thdHplIGZ1ZXR0ZXJuIScKICAgICAgICAgICAgfSwKICAgICAgICBdLAogICAgfTsKCj1jdXQKCnN1YiBSdW4gewogICAgbXkgKCAkU2VsZiwgJVBhcmFtICkgPSBAXzsKCiAgICBteSAkUmVzdWx0ID0gJFNlbGYtPkluaXQoCiAgICAgICAgV2Vic2VydmljZUlEID0+ICRTZWxmLT57V2Vic2VydmljZUlEfSwKICAgICk7CgogICAgaWYgKCAhJFJlc3VsdC0+e1N1Y2Nlc3N9ICkgewogICAgICAgICRTZWxmLT5SZXR1cm5FcnJvcigKICAgICAgICAgICAgRXJyb3JDb2RlICAgID0+ICdXZWJzZXJ2aWNlLkludmFsaWRDb25maWd1cmF0aW9uJywKICAgICAgICAgICAgRXJyb3JNZXNzYWdlID0+ICRSZXN1bHQtPntFcnJvck1lc3NhZ2V9LAogICAgICAgICk7CiAgICB9CgogICAgbXkgKCAkVXNlcklELCAkVXNlclR5cGUgKSA9ICRTZWxmLT5BdXRoKAogICAgICAgICVQYXJhbSwKICAgICk7CgogICAgcmV0dXJuICRTZWxmLT5SZXR1cm5FcnJvcigKICAgICAgICBFcnJvckNvZGUgICAgPT4gJ0VsYXN0aWNTZWFyY2guQXV0aEZhaWwnLAogICAgICAgIEVycm9yTWVzc2FnZSA9PiAiRWxhc3RpY1NlYXJjaDogQXV0aG9yaXphdGlvbiBmYWlsaW5nISIsCiAgICApIGlmICEkVXNlcklEOwoKICAgIG15ICRFU09iamVjdCA9ICRLZXJuZWw6Ok9NLT5HZXQoJ0tlcm5lbDo6U3lzdGVtOjpFbGFzdGljc2VhcmNoJyk7CiAgICBteSBAUmVzdWx0ICAgPSAkRVNPYmplY3QtPlRpY2tldFNlYXJjaCgKICAgICAgICBGdWxsdGV4dCA9PiAkUGFyYW17RGF0YX0tPntGdWxsdGV4dH0sCiAgICAgICAgUmVzdWx0ICAgPT4gJ0ZVTEwnLAogICAgICAgIFVzZXJJRCAgID0+ICRVc2VySUQsCiAgICAgICAgTGltaXQgICAgPT4gJFBhcmFte0RhdGF9LT57TGltaXR9IC8vIDEwLAogICAgKTsKCiAgICBteSBAUmV0dXJuOwoKICAgIGZvciBteSAkSXRlbSAoQFJlc3VsdCkgewogICAgICAgIGZvciBteSAkS2V5ICgga2V5cyAkSXRlbS0+JSogKSB7CiAgICAgICAgICAgIHB1c2ggQFJldHVybiwgJEl0ZW0tPnskS2V5fTsKICAgICAgICB9CiAgICB9CgogICAgcmV0dXJuIHsKICAgICAgICBTdWNjZXNzID0+IDEsCiAgICAgICAgRGF0YSAgICA9PiBcQFJldHVybiwKICAgIH07Cn0KCjE7Cg== # --
# 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/
# --
# 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::GenericInterface::Operation::Ticket::Link;

use v5.24;
use strict;
use warnings;

use parent qw(
    Kernel::GenericInterface::Operation::Ticket::TicketUpdate
);

# core modules
use Scalar::Util qw(reftype);
use MIME::Base64 qw(encode_base64);

# CPAN modules

# OTOBO modules
use Kernel::System::VariableCheck qw(IsArrayRefWithData IsHashRefWithData IsString IsStringWithData);

our $ObjectManagerDisabled = 1;

=head1 NAME

Kernel::GenericInterface::Operation::Ticket::Link - Link Ticket to Objects

=head1 PUBLIC INTERFACE

=head2 new()

usually, you want to create an instance of this
by using C<Kernel::GenericInterface::Operation->new();>.

=cut

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

    my $Self = bless {}, $Type;

    # check needed objects
    for my $Needed (qw( DebuggerObject WebserviceID )) {
        if ( !$Param{$Needed} ) {
            return {
                Success      => 0,
                ErrorMessage => "Got no $Needed!",
            };
        }

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

    $Self->{Config}    = $Kernel::OM->Get('Kernel::Config')->Get('GenericInterface::Operation::Link');
    $Self->{Operation} = $Param{Operation};

    return $Self;
}

=head2 Run()

perform a link ticket to target Operation.

    my $Result = $OperationObject->Run(
        Data => {
            UserLogin         => 'some agent login',                            # UserLogin or CustomerUserLogin or SessionID is
                                                                                #   required
            SessionID         => 123,

            Password  => 'some password',                                       # if UserLogin or customerUserLogin is sent then
                                                                                #   Password is required

            TicketID     => 123,                                                # TicketID or TicketNumber is required
            TicketNumber => '2004040510440485',

            TargetObject => 'FAQ',           # Ticket, ConfigItem

            TargetID     => '5',             # Id of target
            Type         => 'ParentChild',   # defaults to Normal
       },
    );

    $Result = {
        Success         => 1,                       # 0 or 1
        ErrorMessage    => '',                      # in case of error
        Data    => {
            Success   => 1,
        }
    };

=cut

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

    my $Result = $Self->Init(
        WebserviceID => $Self->{WebserviceID},
    );

    if ( !$Result->{Success} ) {
        $Self->ReturnError(
            ErrorCode    => 'Webservice.InvalidConfiguration',
            ErrorMessage => $Result->{ErrorMessage},
        );
    }

    # check needed stuff
    if ( !IsHashRefWithData( $Param{Data} ) ) {
        return $Self->ReturnError(
            ErrorCode    => 'TicketLink.EmptyRequest',
            ErrorMessage => "TicketLink: The request data is invalid!",
        );
    }

    if ( !$Param{Data}->{TicketID} && !$Param{Data}->{TicketNumber} ) {
        return $Self->ReturnError(
            ErrorCode    => 'TicketLink.MissingParameter',
            ErrorMessage => "TicketLink: TicketID or TicketNumber is required!",
        );
    }

    if ( !$Param{Data}->{TargetType} || !$Param{Data}->{TargetID} ) {
        return $Self->ReturnError(
            ErrorCode    => 'TicketLink.MissingParameter',
            ErrorMessage => "TicketLink: TargetType and TargetID are required!",
        );
    }

    my $LinkType = $Param{Data}->{LinkType} || 'Normal';

    if (
        !$Param{Data}->{UserLogin}
        && !$Param{Data}->{SessionID}
        )
    {
        return $Self->ReturnError(
            ErrorCode    => 'TicketLink.MissingParameter',
            ErrorMessage => "TicketLink: UserLogin or SessionID is required!",
        );
    }

    if ( $Param{Data}->{UserLogin} ) {
        if ( !$Param{Data}->{Password} ) {
            return $Self->ReturnError(
                ErrorCode    => 'TicketLink.MissingParameter',
                ErrorMessage => "TicketLink: Password or SessionID is required!",
            );
        }
    }

    # authenticate user
    my ( $UserID, $UserType ) = $Self->Auth(
        %Param,
    );

    if ( !$UserID ) {
        return $Self->ReturnError(
            ErrorCode    => 'TicketLink.AuthFail',
            ErrorMessage => "TicketLink: User could not be authenticated!",
        );
    }

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

    # check TicketID
    my $TicketID;
    if ( $Param{Data}->{TicketNumber} ) {
        $TicketID = $TicketObject->TicketIDLookup(
            TicketNumber => $Param{Data}->{TicketNumber},
            UserID       => $UserID,
        );

    }
    else {
        $TicketID = $Param{Data}->{TicketID};
    }

    if ( !($TicketID) ) {
        return $Self->ReturnError(
            ErrorCode    => 'TicketLink.AccessDenied',
            ErrorMessage => "TicketLink: User does not have access to the ticket!",
        );
    }

    my %TicketData = $TicketObject->TicketGet(
        TicketID      => $TicketID,
        DynamicFields => 0,
        UserID        => $UserID,
    );

    if ( !IsHashRefWithData( \%TicketData ) ) {
        return $Self->ReturnError(
            ErrorCode    => 'TicketLink.AccessDenied',
            ErrorMessage => "TicketLink: User does not have access to the ticket!",
        );
    }

    # check basic needed permissions
    my $Access;
    if ( $UserType eq 'User' ) {

        $Access = $TicketObject->TicketPermission(
            Type     => 'rw',
            TicketID => $TicketID,
            UserID   => $UserID,
        );
    }
    else {
        $Access = $TicketObject->TicketCustomerPermission(
            Type     => 'rw',
            TicketID => $TicketID,
            UserID   => $UserID,
        );
    }
    if ( !$Access ) {
        return {
            ErrorCode    => 'TicketLink.AccessDenied',
            ErrorMessage => "TicketLink: Does not have permissions to link this ticket!",
        };
    }

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

    $Access = $LinkObject->ObjectPermission(
        Object => $Param{Data}->{TargetType},
        Key    => $Param{Data}->{TargetID},
        UserID => 1,
    );
    if ( !$Access ) {
        return {
            ErrorCode    => 'TicketLink.AccessDenied',
            ErrorMessage => "TicketLink: Does not have permissions to link to this object!",
        };
    }

    $Result = $LinkObject->LinkAdd(
        TargetObject => 'Ticket',
        TargetKey    => $TicketID,
        SourceObject => $Param{Data}->{TargetType},
        SourceKey    => $Param{Data}->{TargetID},
        Type         => $LinkType,
        State        => 'Valid',
        UserID       => $UserID,
    );

    return {
        Success => $Result,
        Data    => {
            Success => $Result,
        }
    };
}

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/
# --
# 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::GenericInterface::Operation::Ticket::UnLink;

use v5.24;
use strict;
use warnings;

use parent qw(
    Kernel::GenericInterface::Operation::Ticket::TicketUpdate
);

# core modules
use Scalar::Util qw(reftype);
use MIME::Base64 qw(encode_base64);

# CPAN modules

# OTOBO modules
use Kernel::System::VariableCheck qw(IsArrayRefWithData IsHashRefWithData IsString IsStringWithData);

our $ObjectManagerDisabled = 1;

=head1 NAME

Kernel::GenericInterface::Operation::Ticket::UnLink - Remove Link Ticket to Objects

=head1 PUBLIC INTERFACE

=head2 new()

usually, you want to create an instance of this
by using C<Kernel::GenericInterface::Operation->new();>.

=cut

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

    my $Self = bless {}, $Type;

    # check needed objects
    for my $Needed (qw( DebuggerObject WebserviceID )) {
        if ( !$Param{$Needed} ) {
            return {
                Success      => 0,
                ErrorMessage => "Got no $Needed!",
            };
        }

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

    $Self->{Config}    = $Kernel::OM->Get('Kernel::Config')->Get('GenericInterface::Operation::Link');
    $Self->{Operation} = $Param{Operation};

    return $Self;
}

=head2 Run()

perform unlink Operation removing a link from a ticket to some target.

    my $Result = $OperationObject->Run(
        Data => {
            UserLogin         => 'some agent login',                            # UserLogin or CustomerUserLogin or SessionID is
                                                                                #   required
            SessionID         => 123,

            Password  => 'some password',                                       # if UserLogin or customerUserLogin is sent then
                                                                                #   Password is required

            TicketID     => 123,                                                # TicketID or TicketNumber is required
            TicketNumber => '2004040510440485',

            TargetObject => 'FAQ',           # Ticket, ConfigItem

            TargetID     => '5',             # Id of target
            Type         => 'ParentChild',   # defaults to Normal
       },
    );

    $Result = {
        Success         => 1,                       # 0 or 1
        ErrorMessage    => '',                      # in case of error
        Data    => {
            Success   => 1,
        }
    };

=cut

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

    my $Result = $Self->Init(
        WebserviceID => $Self->{WebserviceID},
    );

    if ( !$Result->{Success} ) {
        $Self->ReturnError(
            ErrorCode    => 'Webservice.InvalidConfiguration',
            ErrorMessage => $Result->{ErrorMessage},
        );
    }

    # check needed stuff
    if ( !IsHashRefWithData( $Param{Data} ) ) {
        return $Self->ReturnError(
            ErrorCode    => 'TicketUnLink.EmptyRequest',
            ErrorMessage => "TicketUnLink: The request data is invalid!",
        );
    }

    if ( !$Param{Data}->{TicketID} && !$Param{Data}->{TicketNumber} ) {
        return $Self->ReturnError(
            ErrorCode    => 'TicketUnLink.MissingParameter',
            ErrorMessage => "TicketUnLink: TicketID or TicketNumber is required!",
        );
    }

    if ( !$Param{Data}->{TargetType} || !$Param{Data}->{TargetID} ) {
        return $Self->ReturnError(
            ErrorCode    => 'TicketUnLink.MissingParameter',
            ErrorMessage => "TicketUnLink: TargetType and TargetID are required!",
        );
    }

    my $LinkType = $Param{Data}->{LinkType} || 'Normal';

    if (
        !$Param{Data}->{UserLogin}
        && !$Param{Data}->{SessionID}
        )
    {
        return $Self->ReturnError(
            ErrorCode    => 'TicketUnLink.MissingParameter',
            ErrorMessage => "TicketUnLink: UserLogin or SessionID is required!",
        );
    }

    if ( $Param{Data}->{UserLogin} ) {
        if ( !$Param{Data}->{Password} ) {
            return $Self->ReturnError(
                ErrorCode    => 'TicketUnLink.MissingParameter',
                ErrorMessage => "TicketUnLink: Password or SessionID is required!",
            );
        }
    }

    # authenticate user
    my ( $UserID, $UserType ) = $Self->Auth(
        %Param,
    );

    if ( !$UserID ) {
        return $Self->ReturnError(
            ErrorCode    => 'TicketUnLink.AuthFail',
            ErrorMessage => "TicketUnLink: User could not be authenticated!",
        );
    }

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

    # check TicketID
    my $TicketID;
    if ( $Param{Data}->{TicketNumber} ) {
        $TicketID = $TicketObject->TicketIDLookup(
            TicketNumber => $Param{Data}->{TicketNumber},
            UserID       => $UserID,
        );

    }
    else {
        $TicketID = $Param{Data}->{TicketID};
    }

    if ( !($TicketID) ) {
        return $Self->ReturnError(
            ErrorCode    => 'TicketUnLink.AccessDenied',
            ErrorMessage => "TicketUnLink: User does not have access to the ticket!",
        );
    }

    my %TicketData = $TicketObject->TicketGet(
        TicketID      => $TicketID,
        DynamicFields => 0,
        UserID        => $UserID,
    );

    if ( !IsHashRefWithData( \%TicketData ) ) {
        return $Self->ReturnError(
            ErrorCode    => 'TicketUnLink.AccessDenied',
            ErrorMessage => "TicketUnLink: User does not have access to the ticket!",
        );
    }

    # check basic needed permissions
    my $Access;
    if ( $UserType eq 'User' ) {

        $Access = $TicketObject->TicketPermission(
            Type     => 'rw',
            TicketID => $TicketID,
            UserID   => $UserID,
        );
    }
    else {
        $Access = $TicketObject->TicketCustomerPermission(
            Type     => 'rw',
            TicketID => $TicketID,
            UserID   => $UserID,
        );
    }
    if ( !$Access ) {
        return {
            ErrorCode    => 'TicketUnLink.AccessDenied',
            ErrorMessage => "TicketUnLink: Does not have permissions to update this ticket!",
        };
    }

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

    $Access = $LinkObject->ObjectPermission(
        Object => $Param{Data}->{TargetType},
        Key    => $Param{Data}->{TargetID},
        UserID => 1,
    );
    if ( !$Access ) {
        return {
            ErrorCode    => 'TicketUnLink.AccessDenied',
            ErrorMessage => "TicketUnLink: Does not have permissions to link to this object!",
        };
    }

    $Result = $LinkObject->LinkDelete(
        Object2 => 'Ticket',
        Key2    => $TicketID,
        Object1 => $Param{Data}->{TargetType},
        Key1    => $Param{Data}->{TargetID},
        Type    => $LinkType,
        UserID  => $UserID,
    );

    return {
        Success => $Result,
        Data    => {
            Success => $Result,
        }
    };
}

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/
# --
# 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::GenericInterface::Operation::Ticket::QueryEmbeddings;

use v5.24;
use strict;
use warnings;

use parent qw(
    Kernel::GenericInterface::Operation::Ticket::TicketUpdate
);

# core modules
use Scalar::Util qw(reftype);
use MIME::Base64 qw(encode_base64);

# CPAN modules

# OTOBO modules
use Kernel::System::VariableCheck qw(IsArrayRefWithData IsHashRefWithData IsString IsStringWithData);

our $ObjectManagerDisabled = 1;

=head1 NAME

Kernel::GenericInterface::Operation::Ticket::QueryEmbeddings - Query AI Embeddings (Similar Items)

=head1 PUBLIC INTERFACE

=head2 new()

usually, you want to create an instance of this
by using C<Kernel::GenericInterface::Operation->new();>.

=cut

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

    my $Self = bless {}, $Type;

    # check needed objects
    for my $Needed (qw( DebuggerObject WebserviceID )) {
        if ( !$Param{$Needed} ) {
            return {
                Success      => 0,
                ErrorMessage => "Got no $Needed!",
            };
        }

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

    $Self->{Config}    = $Kernel::OM->Get('Kernel::Config')->Get('GenericInterface::Operation::QueryEmbeddings');
    $Self->{Operation} = $Param{Operation};

    return $Self;
}

=head2 Run()

perform query-vector-db for similar items Operation.

    my $Result = $OperationObject->Run(
        Data => {
            UserLogin         => 'some agent login',                            # UserLogin or CustomerUserLogin or SessionID is
                                                                                #   required
            SessionID         => 123,

            Password  => 'some password',                                       # if UserLogin or customerUserLogin is sent then
                                                                                #   Password is required

            TicketID     => 123,                                                # TicketID or TicketNumber is required
            TicketNumber => '2004040510440485',

            Collection  => 'faqs',
            Labels      => [],
            FullText    => 0|1,
            Limit       => 3, # default
            Query       => 'searchterm',
       },
    );

    $Result = {
        Success         => 1,                       # 0 or 1
        ErrorMessage    => '',                      # in case of error
        Data            => [
            {
                'id' => '13f89461-cb36-489e-b294-e85d8dc67ca2',
                'metadata' => {
                    'fulltext' => '<the FAQ solution fulltext>',
                    'label' => 'default',
                    'source_id' => '1'      # FAQ ItemID
                },
                'page_content' => '<the FAQ title, sypthom and problem fields>',
                'type' => 'Document'
            },
        ],
    };

=cut

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

    my $Result = $Self->Init(
        WebserviceID => $Self->{WebserviceID},
    );

    if ( !$Result->{Success} ) {
        $Self->ReturnError(
            ErrorCode    => 'Webservice.InvalidConfiguration',
            ErrorMessage => $Result->{ErrorMessage},
        );
    }

    # check needed stuff
    if ( !IsHashRefWithData( $Param{Data} ) ) {
        return $Self->ReturnError(
            ErrorCode    => 'QueryEmbeddings.EmptyRequest',
            ErrorMessage => "QueryEmbeddings: The request data is invalid!",
        );
    }

    if ( !$Param{Data}->{TicketID} && !$Param{Data}->{TicketNumber} ) {
        return $Self->ReturnError(
            ErrorCode    => 'QueryEmbeddings.MissingParameter',
            ErrorMessage => "QueryEmbeddings: TicketID or TicketNumber is required!",
        );
    }

    if ( !$Param{Data}->{Collection} ) {
        return $Self->ReturnError(
            ErrorCode    => 'QueryEmbeddings.MissingParameter',
            ErrorMessage => "QueryEmbeddings: Collection is required!",
        );
    }

    my $LinkType = $Param{Data}->{LinkType} || 'Normal';

    if (
        !$Param{Data}->{UserLogin}
        && !$Param{Data}->{SessionID}
        )
    {
        return $Self->ReturnError(
            ErrorCode    => 'QueryEmbeddings.MissingParameter',
            ErrorMessage => "QueryEmbeddings: UserLogin or SessionID is required!",
        );
    }

    if ( $Param{Data}->{UserLogin} ) {
        if ( !$Param{Data}->{Password} ) {
            return $Self->ReturnError(
                ErrorCode    => 'QueryEmbeddings.MissingParameter',
                ErrorMessage => "QueryEmbeddings: Password or SessionID is required!",
            );
        }
    }

    # authenticate user
    my ( $UserID, $UserType ) = $Self->Auth(
        %Param,
    );

    if ( !$UserID ) {
        return $Self->ReturnError(
            ErrorCode    => 'QueryEmbeddings.AuthFail',
            ErrorMessage => "QueryEmbeddings: User could not be authenticated!",
        );
    }

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

    # check TicketID
    my $TicketID;
    if ( $Param{Data}->{TicketNumber} ) {
        $TicketID = $TicketObject->TicketIDLookup(
            TicketNumber => $Param{Data}->{TicketNumber},
            UserID       => $UserID,
        );

    }
    else {
        $TicketID = $Param{Data}->{TicketID};
    }

    if ( !($TicketID) ) {
        return $Self->ReturnError(
            ErrorCode    => 'QueryEmbeddings.AccessDenied',
            ErrorMessage => "QueryEmbeddings: User does not have access to the ticket!",
        );
    }

    my %TicketData = $TicketObject->TicketGet(
        TicketID      => $TicketID,
        DynamicFields => 0,
        UserID        => $UserID,
    );

    if ( !IsHashRefWithData( \%TicketData ) ) {
        return $Self->ReturnError(
            ErrorCode    => 'QueryEmbeddings.AccessDenied',
            ErrorMessage => "QueryEmbeddings: User does not have access to the ticket!",
        );
    }

    # check basic needed permissions
    my $Access = $Self->CheckAccessPermissions(
        TicketID => $TicketID,
        UserID   => $UserID,
        UserType => $UserType,
    );

    if ( !$Access ) {
        return $Self->ReturnError(
            ErrorCode    => 'QueryEmbeddings.AccessDenied',
            ErrorMessage => "QueryEmbeddings: User does not have access to the ticket!",
        );
    }

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

    if ( !$Param{Data}->{ArticleID} ) {

        my @Articles = $ArticleObject->ArticleList(
            TicketID   => $TicketID,
            SenderType => 'customer',
            OnlyLast   => 1,
        );
        if (@Articles) {
            $Param{Data}->{ArticleID} = $Articles[0]{ArticleID};
        }
        else {
            return $Self->ReturnError(
                ErrorCode    => 'QueryEmbeddings.AccessDenied',
                ErrorMessage => "QueryEmbeddings: need ArticleID!",
            );
        }
    }

    my $ArticleBackendObject = $ArticleObject->BackendForArticle(
        TicketID  => $TicketID,
        ArticleID => $Param{Data}->{ArticleID},
    );

    if ( !$ArticleBackendObject ) {
        return $Self->ReturnError(
            ErrorCode    => 'QueryEmbeddings.AccessDenied',
            ErrorMessage => "QueryEmbeddings: Article unavailable!",
        );
    }

    my %Article = $ArticleBackendObject->ArticleGet(
        TicketID  => $TicketID,
        ArticleID => $Param{Data}->{ArticleID},
    );

    my $Query = $Param{Data}->{Query} // ( ( $Article{Subject} // '' ) . '\n' . ( $Article{Body} // '' ) );

    my $ConfigObject      = $Kernel::OM->Get('Kernel::Config');
    my $QueueToRAGMapping = $ConfigObject->Get('OTOBOAI::QueueToRAGMapping') // {};
    my $RAG               = $QueueToRAGMapping->{ $TicketData{Queue} }       // $ConfigObject->Get('OTOBOAI::DefaultRAG');

    my $WebserviceObject = $Kernel::OM->Get('Kernel::System::GenericInterface::Webservice');
    my $AIWebservice     = $WebserviceObject->WebserviceGet(
        Name => 'OTOBO-AI',
    );

    if ( !$AIWebservice ) {

        return $Self->ReturnError(
            ErrorCode    => 'QueryEmbeddings.WebserviceUnavail',
            ErrorMessage => "QueryEmbeddings: Webservice Invoker not found!",
        );
    }

    my $WebserviceID = $AIWebservice->{ID};

    $Result = $Kernel::OM->Get('Kernel::GenericInterface::Requester')->Run(
        WebserviceID => $WebserviceID,
        Invoker      => 'QueryEmbeddings',
        Asynchronous => 0,
        Data         => {
            Collection => $Param{Data}->{Collection},
            Labels     => [$RAG],
            Fulltext   => $Param{Data}->{Fulltext},
            Limit      => $Param{Data}->{Limit},
            Query      => $Query,
        }
    );

    return $Result,;
}

1;
 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 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjYgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgpwYWNrYWdlIEtlcm5lbDo6U3lzdGVtOjpDb25zb2xlOjpDb21tYW5kOjpNYWludDo6QUk6OlF1ZXJ5RW1iZWRkaW5nczsKCnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKCnVzZSBLZXJuZWw6OlN5c3RlbTo6VmFyaWFibGVDaGVjayBxdyg6YWxsKTsKCnVzZSBwYXJlbnQgcXcoS2VybmVsOjpTeXN0ZW06OkNvbnNvbGU6OkJhc2VDb21tYW5kKTsKCiMjIG5vZmlsdGVyKFRpZHlBbGw6OlBsdWdpbjo6T1RPQk86OlBlcmw6OkZvcmVhY2hUb0ZvcikKCiMgSW5mb3JtIHRoZSBvYmplY3QgbWFuYWdlciBhYm91dCB0aGUgaGFyZCBkZXBlbmRlbmNpZXMuCiMgVGhpcyBtb2R1bGUgbXVzdCBiZSBkaXNjYXJkZWQgd2hlbiBvbmUgb2YgdGhlIGhhcmQgZGVwZW5kZW5jaWVzIGhhcyBiZWVuIGRpc2NhcmRlZC4Kb3VyIEBPYmplY3REZXBlbmRlbmNpZXMgPSAoCiAgICAnS2VybmVsOjpTeXN0ZW06OkdlbmVyaWNJbnRlcmZhY2U6OldlYnNlcnZpY2UnLAogICAgJ0tlcm5lbDo6U3lzdGVtOjpNYWluJywKICAgICdLZXJuZWw6OlN5c3RlbTo6T3RvYm9BSScsCiAgICAnS2VybmVsOjpTeXN0ZW06OlRpY2tldDo6QXJ0aWNsZScsCiAgICAnS2VybmVsOjpHZW5lcmljSW50ZXJmYWNlOjpSZXF1ZXN0ZXInLAopOwoKc3ViIENvbmZpZ3VyZSB7CiAgICBteSAoICRTZWxmLCAlUGFyYW0gKSA9IEBfOwoKICAgICRTZWxmLT5EZXNjcmlwdGlvbignUmV0cmlldmUgYW4gQUkgZ2VuZXJhdGVkIEFuc3dlciBmcm9tIHRoZSBvdG9iby1haS1zZXJ2aWNlcyBjb250YWluZXIuJyk7CiAgICAkU2VsZi0+QWRkT3B0aW9uKAogICAgICAgIE5hbWUgICAgICAgID0+ICdjb2xsZWN0aW9uJywKICAgICAgICBEZXNjcmlwdGlvbiA9PiAnZmFxc3x0aWNrZXRfcGFpcnN8dGlja2V0X2NodW5ja3N8ZG9jcycsCiAgICAgICAgUmVxdWlyZWQgICAgPT4gMSwKICAgICAgICBIYXNWYWx1ZSAgICA9PiAxLAogICAgICAgIFZhbHVlUmVnZXggID0+IHFyL14uKyQvc214LAogICAgKTsKICAgICRTZWxmLT5BZGRPcHRpb24oCiAgICAgICAgTmFtZSAgICAgICAgPT4gJ3F1ZXJ5JywKICAgICAgICBEZXNjcmlwdGlvbiA9PiAnc2VhcmNodGVybScsCiAgICAgICAgUmVxdWlyZWQgICAgPT4gMSwKICAgICAgICBIYXNWYWx1ZSAgICA9PiAxLAogICAgICAgIFZhbHVlUmVnZXggID0+IHFyL14uKyQvc214LAogICAgKTsKICAgICRTZWxmLT5BZGRPcHRpb24oCiAgICAgICAgTmFtZSAgICAgICAgPT4gJ2Z1bGx0ZXh0JywKICAgICAgICBEZXNjcmlwdGlvbiA9PiAncmV0cmlldmUgZnVsbHRleHQnLAogICAgICAgIEhhc1ZhbHVlICAgID0+IDAsCiAgICAgICAgUmVxdWlyZWQgICAgPT4gMCwKICAgICk7CiAgICAkU2VsZi0+QWRkT3B0aW9uKAogICAgICAgIE5hbWUgICAgICAgID0+ICdsYWJlbCcsCiAgICAgICAgRGVzY3JpcHRpb24gPT4gJ2RlZmF1bHQnLAogICAgICAgIFJlcXVpcmVkICAgID0+IDAsCiAgICAgICAgSGFzVmFsdWUgICAgPT4gMSwKICAgICAgICBWYWx1ZVJlZ2V4ICA9PiBxci9eLiskL3NteCwKICAgICAgICBNdWx0aXBsZSAgICA9PiAxLAogICAgKTsKCiAgICByZXR1cm47Cn0KCnN1YiBQcmVSdW4gewogICAgbXkgKCAkU2VsZiwgJVBhcmFtICkgPSBAXzsKCiAgICAjIGNoZWNrIHdoZXRoZXIgb3RvYm8tYWkgd2ViIHNlcnZpY2UgaXMgZW5hYmxlZCBhbmQgaWYgbm90LCBhY3RpdmF0ZSBpdAogICAgbXkgJFdlYnNlcnZpY2VPYmplY3QgPSAkS2VybmVsOjpPTS0+R2V0KCdLZXJuZWw6OlN5c3RlbTo6R2VuZXJpY0ludGVyZmFjZTo6V2Vic2VydmljZScpOwoKICAgIG15ICRBSVdlYnNlcnZpY2UgPSAkV2Vic2VydmljZU9iamVjdC0+V2Vic2VydmljZUdldCgKICAgICAgICBOYW1lID0+ICdPVE9CTy1BSScsCiAgICApOwoKICAgIGlmICggISRBSVdlYnNlcnZpY2UgKSB7CiAgICAgICAgJFNlbGYtPlByaW50KCI8cmVkPk9UT0JPLUFJIHdlYnNlcnZpY2Ugbm90IGZvdW5kISBVbmFibGUgdG8gY29udGludWUuPC9yZWQ+XG4iKTsKICAgICAgICBkaWU7CiAgICB9CgogICAgIyBTZXQgdGhlIHdlYnNlcnZpY2UgaWQKICAgICRTZWxmLT57V2Vic2VydmljZUlEfSA9ICRBSVdlYnNlcnZpY2UtPntJRH07CgogICAgaWYgKCAkQUlXZWJzZXJ2aWNlLT57VmFsaWRJRH0gIT0gMSApIHsKICAgICAgICAkU2VsZi0+UHJpbnQoCiAgICAgICAgICAgICI8eWVsbG93Pk9UT0JPLUFJIHdlYnNlcnZpY2UgaXMgbm93IGFjdGl2YXRlZC4gSWYgeW91IGRvbid0IHdhbnQgdG8ga2VlcCBpdCBlbmFibGVkLCBwbGVhc2UgZGlzYWJsZSBpdCBtYW51YWxseSBpbiB0aGUgYWRtaW4gaW50ZXJmYWNlLCBhZnRlciB0aGUgaW1wb3J0IGlzIGNvbXBsZXRlLjwveWVsbG93PlxuIgogICAgICAgICk7CiAgICAgICAgbXkgJFN1Y2Nlc3MgPSAkV2Vic2VydmljZU9iamVjdC0+V2Vic2VydmljZVVwZGF0ZSgKICAgICAgICAgICAgJXskQUlXZWJzZXJ2aWNlfSwKICAgICAgICAgICAgVmFsaWRJRCA9PiAxLAogICAgICAgICAgICBVc2VySUQgID0+IDEsCiAgICAgICAgKTsKCiAgICAgICAgaWYgKCAhJFN1Y2Nlc3MgKSB7CiAgICAgICAgICAgICRTZWxmLT5QcmludCgiPHJlZD5PVE9CTy1BSSB3ZWJzZXJ2aWNlIGNvdWxkIG5vdCBiZSBhY3RpdmF0ZWQhIFVuYWJsZSB0byBjb250aW51ZS48L3JlZD5cbiIpOwogICAgICAgICAgICBkaWU7CiAgICAgICAgfQogICAgfQoKICAgIHJldHVybjsKfQoKc3ViIFJ1biB7CiAgICBteSAoICRTZWxmLCAlUGFyYW0gKSA9IEBfOwoKICAgIG15ICRPdG9ib0FJT2JqZWN0ID0gJEtlcm5lbDo6T00tPkdldCgnS2VybmVsOjpTeXN0ZW06Ok90b2JvQUknKTsKICAgIG15ICRDb2xsZWN0aW9uICAgID0gJFNlbGYtPkdldE9wdGlvbignY29sbGVjdGlvbicpOwogICAgbXkgJFF1ZXJ5ICAgICAgICAgPSAkU2VsZi0+R2V0T3B0aW9uKCdxdWVyeScpOwogICAgbXkgJExhYmVscyAgICAgICAgPSAkU2VsZi0+R2V0T3B0aW9uKCdsYWJlbCcpICAgIC8vIFsnZGVmYXVsdCddOwogICAgbXkgJEZ1bGx0ZXh0ICAgICAgPSAkU2VsZi0+R2V0T3B0aW9uKCdmdWxsdGV4dCcpIC8vIDA7CgogICAgbXkgJFJlc3VsdCA9ICRLZXJuZWw6Ok9NLT5HZXQoJ0tlcm5lbDo6R2VuZXJpY0ludGVyZmFjZTo6UmVxdWVzdGVyJyktPlJ1bigKICAgICAgICBXZWJzZXJ2aWNlSUQgPT4gJFNlbGYtPntXZWJzZXJ2aWNlSUR9LAogICAgICAgIEludm9rZXIgICAgICA9PiAnUXVlcnlFbWJlZGRpbmdzJywKICAgICAgICBBc3luY2hyb25vdXMgPT4gMCwKICAgICAgICBEYXRhICAgICAgICAgPT4gewogICAgICAgICAgICBDb2xsZWN0aW9uID0+ICRDb2xsZWN0aW9uLAogICAgICAgICAgICBRdWVyeSAgICAgID0+ICRRdWVyeSwKICAgICAgICAgICAgTGFiZWxzICAgICA9PiAkTGFiZWxzLAogICAgICAgICAgICBGdWxsdGV4dCAgID0+ICRGdWxsdGV4dCwKICAgICAgICB9CiAgICApOwoKICAgIG15ICRNYWluT2JqZWN0ID0gJEtlcm5lbDo6T00tPkdldCgnS2VybmVsOjpTeXN0ZW06Ok1haW4nKTsKICAgIG15ICREdW1wICAgICAgID0gJE1haW5PYmplY3QtPkR1bXAoJFJlc3VsdCk7CgogICAgJFNlbGYtPlByaW50KCIkRHVtcFxuIik7CgogICAgcmV0dXJuICRTZWxmLT5FeGl0Q29kZU9rKCk7Cn0KCjE7Cg== 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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-2026 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::Modules::AdminDynamicFieldTextAreaAI;

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

# core modules

# CPAN modules

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

our $ObjectManagerDisabled = 1;

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

    my $Self = bless {%Param}, $Type;

    # Some setup
    $Self->{TemplateFile} = 'AdminDynamicFieldTextAreaAI';

    # set up the field type specific settings
    my @FieldTypeSettings;
    {
        my $FieldType = $Kernel::OM->Get('Kernel::System::Web::Request')->GetParam( Param => 'FieldType' );
        if ($FieldType) {
            my $DriverObject = $Kernel::OM->Get( 'Kernel::System::DynamicField::Driver::' . $FieldType );
            @FieldTypeSettings = $DriverObject->GetFieldTypeSettings();
        }
    }
    $Self->{FieldTypeSettings} = \@FieldTypeSettings;

    return $Self;
}

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

    # Store last entity screen.
    $Kernel::OM->Get('Kernel::System::AuthSession')->UpdateSessionID(
        SessionID => $Self->{SessionID},
        Key       => 'LastScreenEntity',
        Value     => $Self->{RequestedURL},
    );

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

    if ( $Self->{Subaction} eq 'Add' ) {
        return $Self->_Add(
            %Param,
        );
    }

    if ( $Self->{Subaction} eq 'AddAction' ) {

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

        return $Self->_AddAction(
            %Param,
        );
    }

    if ( $Self->{Subaction} eq 'Change' ) {
        return $Self->_Change(
            %Param,
        );
    }

    if ( $Self->{Subaction} eq 'ChangeAction' ) {

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

        return $Self->_ChangeAction(
            %Param,
        );
    }

    return $LayoutObject->ErrorScreen(
        Message => Translatable('Undefined subaction.'),
    );
}

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

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

    my %GetParam;

    # check if we clone from an existing field
    my $CloneFieldID = $ParamObject->GetParam( Param => "CloneFieldID" );
    if ($CloneFieldID) {
        my $FieldConfig = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldGet(
            ID => $CloneFieldID,
        );

        # if we found a field config, copy its content for usage in _ShowScreen
        if ( IsHashRefWithData($FieldConfig) ) {

            # copy standard stuff
            for my $Key (qw(ObjectType FieldType Label Name ValidID)) {
                $GetParam{$Key} = $FieldConfig->{$Key};
            }

            # iterate over special stuff and copy in-depth content as flat list
            CONFIGKEY:
            for my $ConfigKey ( keys $FieldConfig->{Config}->%* ) {
                next CONFIGKEY if $ConfigKey eq 'PartOfSet';

                my $DFDetails = $FieldConfig->{Config};
                if ( IsHashRefWithData( $DFDetails->{$ConfigKey} ) ) {
                    my $ConfigContent = $DFDetails->{$ConfigKey};
                    for my $ContentKey ( keys $ConfigContent->%* ) {
                        $GetParam{$ContentKey} = $ConfigContent->{$ContentKey};
                    }
                }
                else {
                    $GetParam{$ConfigKey} = $DFDetails->{$ConfigKey};
                }
            }
        }
        $GetParam{CloneFieldID} = $CloneFieldID;
    }

    for my $Needed (qw(ObjectType FieldType FieldOrder)) {
        $GetParam{$Needed} //= $ParamObject->GetParam( Param => $Needed );
        if ( !$GetParam{$Needed} ) {
            return $LayoutObject->ErrorScreen(
                Message => $LayoutObject->{LanguageObject}->Translate( 'Need %s', $Needed ),
            );
        }
    }

    for my $FilterParam (qw(ObjectTypeFilter NamespaceFilter)) {
        $GetParam{$FilterParam} = $ParamObject->GetParam( Param => $FilterParam );
    }

    # get the object type and field type display name
    my $ConfigObject   = $Kernel::OM->Get('Kernel::Config');
    my $ObjectTypeName = $ConfigObject->Get('DynamicFields::ObjectType')->{ $GetParam{ObjectType} }->{DisplayName} || '';
    my $FieldTypeName  = $ConfigObject->Get('DynamicFields::Driver')->{ $GetParam{FieldType} }->{DisplayName}      || '';

    # check namespace validity
    my $Namespaces = $ConfigObject->Get('DynamicField::Namespaces');
    my $Namespace  = '';
    if ( IsArrayRefWithData($Namespaces) && $GetParam{NamespaceFilter} ) {
        $Namespace = ( grep { $_ eq $GetParam{NamespaceFilter} } $Namespaces->@* ) ? $GetParam{NamespaceFilter} : '';
    }

    return $Self->_ShowScreen(
        %Param,
        %GetParam,
        Mode           => 'Add',
        BreadcrumbText => $LayoutObject->{LanguageObject}->Translate( 'Add %s field', $LayoutObject->{LanguageObject}->Translate($FieldTypeName) ),
        ObjectTypeName => $ObjectTypeName,
        FieldTypeName  => $FieldTypeName,
        Namespace      => $Namespace,
    );
}

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

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

    my %Errors;
    my %GetParam;
    for my $Needed (qw(Name Label FieldOrder)) {
        $GetParam{$Needed} = $ParamObject->GetParam( Param => $Needed );
        if ( !$GetParam{$Needed} ) {
            $Errors{ $Needed . 'ServerError' }        = 'ServerError';
            $Errors{ $Needed . 'ServerErrorMessage' } = Translatable('This field is required.');
        }
    }

    my $DynamicFieldObject = $Kernel::OM->Get('Kernel::System::DynamicField');

    if ( $GetParam{FieldOrder} ) {

        # check if field order is numeric and positive
        if ( $GetParam{FieldOrder} !~ m{\A (?: \d )+ \z}xms ) {

            # add server error error class
            $Errors{FieldOrderServerError}        = 'ServerError';
            $Errors{FieldOrderServerErrorMessage} = Translatable('The field must be numeric.');
        }
    }

    for my $ConfigParam (
        qw(ObjectType ObjectTypeName FieldType FieldTypeName ValidID Namespace)
        )
    {
        $GetParam{$ConfigParam} = $ParamObject->GetParam( Param => $ConfigParam );
    }

    # extract field type specific parameters, e.g. MultiValue
    SETTING:
    for my $Setting ( $Self->{FieldTypeSettings}->@* ) {

        # skip custom inputs which are handled separately
        # currently only used for reference filter list
        next SETTING if !$Setting->{InputType};

        my $Name = $Setting->{ConfigParamName};
        if ( $Setting->{Multiple} ) {
            $GetParam{$Name}->@* = $ParamObject->GetArray( Param => $Name );
        }
        else {
            $GetParam{$Name} = $ParamObject->GetParam( Param => $Name );
        }

        # validate input if necessary
        if ( $Setting->{Mandatory} ) {
            if ( !$GetParam{$Name} || ( $Setting->{Multiple} && !$GetParam{$Name}->@* ) ) {
                $Errors{ $Name . 'ServerError' }        = 'ServerError';
                $Errors{ $Name . 'ServerErrorMessage' } = Translatable('This field is required.');
            }
        }
    }

    for my $FilterParam (qw(ObjectTypeFilter NamespaceFilter)) {
        $GetParam{$FilterParam} = $ParamObject->GetParam( Param => $FilterParam );
    }

    if ( $GetParam{Name} ) {

        # check if name is alphanumeric
        if ( $GetParam{Name} !~ m{\A (?: [a-zA-Z] | \d )+ \z}xms ) {

            # add server error error class
            $Errors{NameServerError} = 'ServerError';
            $Errors{NameServerErrorMessage} =
                Translatable('The field does not contain only ASCII letters and numbers.');
        }

        $GetParam{Name} = $GetParam{Namespace} ? $GetParam{Namespace} . '-' . $GetParam{Name} : $GetParam{Name};

        # check if name is duplicated
        my %DynamicFieldsList = %{
            $DynamicFieldObject->DynamicFieldList(
                Valid      => 0,
                ResultType => 'HASH',
            )
        };

        %DynamicFieldsList = reverse %DynamicFieldsList;

        if ( $DynamicFieldsList{ $GetParam{Name} } ) {

            # add server error error class
            $Errors{NameServerError}        = 'ServerError';
            $Errors{NameServerErrorMessage} = Translatable('There is another field with the same name.');
        }
    }

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

    # uncorrectable errors
    if ( !$GetParam{ValidID} ) {
        return $LayoutObject->ErrorScreen(
            Message => Translatable('Need ValidID'),
        );
    }

    # return to add screen if errors
    if (%Errors) {
        return $Self->_ShowScreen(
            %Param,
            %Errors,
            %GetParam,
            Mode => 'Add',
        );
    }

    # set specific config
    my %FieldConfig = ();

    # extract field type specific parameters, e.g. MultiValue
    SETTING:
    for my $Setting ( $Self->{FieldTypeSettings}->@* ) {

        # skip custom inputs which are handled separately
        # currently only used for reference filter list
        next SETTING if !$Setting->{InputType};

        my $Name = $Setting->{ConfigParamName};
        $FieldConfig{$Name} = $GetParam{$Name};
    }

    # create a new field
    my $FieldID = $DynamicFieldObject->DynamicFieldAdd(
        Name       => $GetParam{Name},
        Label      => $GetParam{Label},
        FieldOrder => $GetParam{FieldOrder},
        FieldType  => $GetParam{FieldType},
        ObjectType => $GetParam{ObjectType},
        Config     => \%FieldConfig,
        ValidID    => $GetParam{ValidID},
        UserID     => $Self->{UserID},
    );

    if ( !$FieldID ) {
        return $LayoutObject->ErrorScreen(
            Message => Translatable('Could not create the new field'),
        );
    }

    my $RedirectString = "Action=AdminDynamicField";

    if ( IsStringWithData( $GetParam{ObjectTypeFilter} ) ) {
        $RedirectString .= ";ObjectTypeFilter=" . $LayoutObject->Output(
            Template => '[% Data.Filter | uri %]',
            Data     => {
                Filter => $GetParam{ObjectTypeFilter},
            },
        );
    }
    if ( IsStringWithData( $GetParam{NamespaceFilter} ) ) {
        $RedirectString .= ";NamespaceFilter=" . $LayoutObject->Output(
            Template => '[% Data.Filter | uri %]',
            Data     => {
                Filter => $GetParam{NamespaceFilter},
            },
        );
    }

    return $LayoutObject->Redirect( OP => $RedirectString );
}

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

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

    my %GetParam;
    for my $Needed (qw(ObjectType FieldType)) {
        $GetParam{$Needed} = $ParamObject->GetParam( Param => $Needed );
        if ( !$GetParam{$Needed} ) {
            return $LayoutObject->ErrorScreen(
                Message => $LayoutObject->{LanguageObject}->Translate( 'Need %s', $Needed ),
            );
        }
    }

    for my $FilterParam (qw(ObjectTypeFilter NamespaceFilter)) {
        $GetParam{$FilterParam} = $ParamObject->GetParam( Param => $FilterParam );
    }

    # get the object type and field type display name
    my $ConfigObject   = $Kernel::OM->Get('Kernel::Config');
    my $ObjectTypeName = $ConfigObject->Get('DynamicFields::ObjectType')->{ $GetParam{ObjectType} }->{DisplayName} || '';
    my $FieldTypeName  = $ConfigObject->Get('DynamicFields::Driver')->{ $GetParam{FieldType} }->{DisplayName}      || '';

    my $FieldID = $ParamObject->GetParam( Param => 'ID' );
    if ( !$FieldID ) {
        return $LayoutObject->ErrorScreen(
            Message => Translatable('Need ID'),
        );
    }

    # get dynamic field data
    my $DynamicFieldData = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldGet(
        ID => $FieldID,
    );

    # check for valid dynamic field configuration
    if ( !IsHashRefWithData($DynamicFieldData) ) {
        return $LayoutObject->ErrorScreen(
            Message =>
                $LayoutObject->{LanguageObject}->Translate( 'Could not get data for dynamic field %s', $FieldID ),
        );
    }

    my %Config;

    # extract configuration
    if ( IsHashRefWithData( $DynamicFieldData->{Config} ) ) {
        %Config = $DynamicFieldData->{Config}->%*;
    }

    return $Self->_ShowScreen(
        %Param,
        %GetParam,
        $DynamicFieldData->%*,
        %Config,
        ID             => $FieldID,
        Mode           => 'Change',
        BreadcrumbText => $LayoutObject->{LanguageObject}->Translate( 'Change %s field', $LayoutObject->{LanguageObject}->Translate($FieldTypeName) ),
        ObjectTypeName => $ObjectTypeName,
        FieldTypeName  => $FieldTypeName,
    );
}

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

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

    my %Errors;
    my %GetParam;
    for my $Needed (qw(Name Label FieldOrder)) {
        $GetParam{$Needed} = $ParamObject->GetParam( Param => $Needed );
        if ( !$GetParam{$Needed} ) {
            $Errors{ $Needed . 'ServerError' }        = 'ServerError';
            $Errors{ $Needed . 'ServerErrorMessage' } = Translatable('This field is required.');
        }
    }

    my $FieldID = $ParamObject->GetParam( Param => 'ID' );
    if ( !$FieldID ) {
        return $LayoutObject->ErrorScreen(
            Message => Translatable('Need ID'),
        );
    }

    my $DynamicFieldObject = $Kernel::OM->Get('Kernel::System::DynamicField');

    # get dynamic field data
    my $DynamicFieldData = $DynamicFieldObject->DynamicFieldGet(
        ID => $FieldID,
    );

    # check for valid dynamic field configuration
    if ( !IsHashRefWithData($DynamicFieldData) ) {
        return $LayoutObject->ErrorScreen(
            Message =>
                $LayoutObject->{LanguageObject}->Translate( 'Could not get data for dynamic field %s', $FieldID ),
        );
    }

    if ( $GetParam{FieldOrder} ) {

        # check if field order is numeric and positive
        if ( $GetParam{FieldOrder} !~ m{\A (?: \d )+ \z}xms ) {

            # add server error error class
            $Errors{FieldOrderServerError}        = 'ServerError';
            $Errors{FieldOrderServerErrorMessage} = Translatable('The field must be numeric.');
        }
    }

    for my $ConfigParam (
        qw(ObjectType ObjectTypeName FieldType FieldTypeName ValidID Namespace)
        )
    {
        $GetParam{$ConfigParam} = $ParamObject->GetParam( Param => $ConfigParam );
    }

    # extract field type specific parameters, e.g. MultiValue
    SETTING:
    for my $Setting ( $Self->{FieldTypeSettings}->@* ) {

        # skip custom inputs which are handled separately
        # currently only used for reference filter list
        next SETTING if !$Setting->{InputType};

        my $Name = $Setting->{ConfigParamName};
        if ( $Setting->{Multiple} ) {
            $GetParam{$Name}->@* = $ParamObject->GetArray( Param => $Name );
        }
        else {
            $GetParam{$Name} = $ParamObject->GetParam( Param => $Name );
        }

        # validate input if necessary
        if ( $Setting->{Mandatory} ) {
            if ( !defined $GetParam{$Name} || ( $Setting->{Multiple} && !$GetParam{$Name}->@* ) ) {
                $Errors{ $Name . 'ServerError' }        = 'ServerError';
                $Errors{ $Name . 'ServerErrorMessage' } = Translatable('This field is required.');
            }
        }
    }

    for my $FilterParam (qw(ObjectTypeFilter NamespaceFilter)) {
        $GetParam{$FilterParam} = $ParamObject->GetParam( Param => $FilterParam );
    }

    if ( $GetParam{Name} ) {

        # check if name is lowercase
        if ( $GetParam{Name} !~ m{\A (?: [a-zA-Z] | \d )+ \z}xms ) {

            # add server error error class
            $Errors{NameServerError} = 'ServerError';
            $Errors{NameServerErrorMessage} =
                Translatable('The field does not contain only ASCII letters and numbers.');
        }

        $GetParam{Name} = $GetParam{Namespace} ? $GetParam{Namespace} . '-' . $GetParam{Name} : $GetParam{Name};

        # check if name is duplicated
        my %DynamicFieldsList = %{
            $DynamicFieldObject->DynamicFieldList(
                Valid      => 0,
                ResultType => 'HASH',
            )
        };

        %DynamicFieldsList = reverse %DynamicFieldsList;

        if (
            $DynamicFieldsList{ $GetParam{Name} } &&
            $DynamicFieldsList{ $GetParam{Name} } ne $FieldID
            )
        {

            # add server error class
            $Errors{NameServerError}        = 'ServerError';
            $Errors{NameServerErrorMessage} = Translatable('There is another field with the same name.');
        }

        # if it's an internal field, it's name should not change
        if (
            $DynamicFieldData->{InternalField} &&
            $DynamicFieldsList{ $GetParam{Name} } ne $FieldID
            )
        {

            # add server error class
            $Errors{NameServerError}        = 'ServerError';
            $Errors{NameServerErrorMessage} = Translatable('The name for this field should not change.');
            $Param{InternalField}           = $DynamicFieldData->{InternalField};
        }
    }

    # uncorrectable errors
    if ( !$GetParam{ValidID} ) {
        return $LayoutObject->ErrorScreen(
            Message => Translatable('Need ValidID'),
        );
    }

    # Check if dynamic field is present in SysConfig setting
    my $UpdateEntity              = $ParamObject->GetParam( Param => 'UpdateEntity' ) || '';
    my $SysConfigObject           = $Kernel::OM->Get('Kernel::System::SysConfig');
    my %DynamicFieldOldData       = %{$DynamicFieldData};
    my @IsDynamicFieldInSysConfig = $SysConfigObject->ConfigurationEntityCheck(
        EntityType => 'DynamicField',
        EntityName => $DynamicFieldData->{Name},
    );
    if (@IsDynamicFieldInSysConfig) {

        # An entity present in SysConfig couldn't be invalidated.
        if (
            $Kernel::OM->Get('Kernel::System::Valid')->ValidLookup( ValidID => $GetParam{ValidID} )
            ne 'valid'
            )
        {
            $Errors{ValidIDInvalid}         = 'ServerError';
            $Errors{ValidOptionServerError} = 'InSetting';
        }

        # In case changing name an authorization (UpdateEntity) should be sent
        elsif ( $DynamicFieldData->{Name} ne $GetParam{Name} && !$UpdateEntity ) {
            $Errors{NameInvalid}              = 'ServerError';
            $Errors{InSettingNameServerError} = 1;
        }
    }

    # return to change screen if errors
    if (%Errors) {
        return $Self->_ShowScreen(
            %Param,
            %Errors,
            %GetParam,
            ID   => $FieldID,
            Mode => 'Change',
        );
    }

    # set specific config
    my %FieldConfig = ();

    # extract field type specific parameters, e.g. MultiValue
    SETTING:
    for my $Setting ( $Self->{FieldTypeSettings}->@* ) {

        # skip custom inputs which are handled separately
        # currently only used for reference filter list
        next SETTING if !$Setting->{InputType};

        my $Name = $Setting->{ConfigParamName};
        $FieldConfig{$Name} = $GetParam{$Name};
    }

    # update dynamic field (FieldType and ObjectType cannot be changed; use old values)
    my $UpdateSuccess = $DynamicFieldObject->DynamicFieldUpdate(
        ID         => $FieldID,
        Name       => $GetParam{Name},
        Label      => $GetParam{Label},
        FieldOrder => $GetParam{FieldOrder},
        FieldType  => $DynamicFieldData->{FieldType},
        ObjectType => $DynamicFieldData->{ObjectType},
        Config     => \%FieldConfig,
        ValidID    => $GetParam{ValidID},
        UserID     => $Self->{UserID},
    );

    if ( !$UpdateSuccess ) {
        return $LayoutObject->ErrorScreen(
            Message => $LayoutObject->{LanguageObject}->Translate( 'Could not update the field %s', $GetParam{Name} ),
        );
    }

    if (
        @IsDynamicFieldInSysConfig
        && $DynamicFieldOldData{Name} ne $GetParam{Name}
        && $UpdateEntity
        )
    {
        SETTING:
        for my $SettingName (@IsDynamicFieldInSysConfig) {

            my %Setting = $SysConfigObject->SettingGet(
                Name => $SettingName,
            );

            next SETTING if !IsHashRefWithData( \%Setting );

            $Setting{EffectiveValue} =~ s/$DynamicFieldOldData{Name}/$GetParam{Name}/g;

            my $ExclusiveLockGUID = $SysConfigObject->SettingLock(
                Name   => $Setting{Name},
                Force  => 1,
                UserID => $Self->{UserID}
            );
            $Setting{ExclusiveLockGUID} = $ExclusiveLockGUID;

            $SysConfigObject->SettingUpdate(
                %Setting,
                UserID => $Self->{UserID},
            );
        }

        $SysConfigObject->ConfigurationDeploy(
            Comments      => "DynamicField name change",
            DirtySettings => \@IsDynamicFieldInSysConfig,
            UserID        => $Self->{UserID},
            Force         => 1,
        );
    }

    my $FilterString = '';

    if ( IsStringWithData( $GetParam{ObjectTypeFilter} ) ) {
        $FilterString .= ";ObjectTypeFilter=" . $LayoutObject->Output(
            Template => '[% Data.Filter | uri %]',
            Data     => {
                Filter => $GetParam{ObjectTypeFilter},
            },
        );
    }
    if ( IsStringWithData( $GetParam{NamespaceFilter} ) ) {
        $FilterString .= ";NamespaceFilter=" . $LayoutObject->Output(
            Template => '[% Data.Filter | uri %]',
            Data     => {
                Filter => $GetParam{NamespaceFilter},
            },
        );
    }

    # if the user would like to continue editing the dynamic field, just redirect to the change screen
    if (
        defined $ParamObject->GetParam( Param => 'ContinueAfterSave' )
        && ( $ParamObject->GetParam( Param => 'ContinueAfterSave' ) eq '1' )
        )
    {
        return $LayoutObject->Redirect(
            OP =>
                "Action=$Self->{Action};Subaction=Change;ObjectType=$DynamicFieldData->{ObjectType};FieldType=$DynamicFieldData->{FieldType};ID=$FieldID$FilterString"
        );
    }
    else {

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

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

    my $Namespace = $Param{Namespace};
    $Param{DisplayFieldName} = 'New';

    if ( $Param{Mode} eq 'Change' || $Param{Name} ) {

        if ( !$Param{CloneFieldID} ) {
            $Param{ShowWarning}      = 'ShowWarning';
            $Param{DisplayFieldName} = $Param{Name};
        }

        # check for namespace
        if ( $Param{Name} =~ /(.*)-(.*)/ ) {
            $Namespace = $1;
            $Param{PlainFieldName} = $2 unless $Param{CloneFieldID};
        }
        else {
            $Param{PlainFieldName} = $Param{Name};
        }
    }

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

    # header
    my $Output = join '',
        $LayoutObject->Header,
        $LayoutObject->NavigationBar;

    my $DynamicFieldObject = $Kernel::OM->Get('Kernel::System::DynamicField');

    # get all fields
    my $DynamicFieldList = $DynamicFieldObject->DynamicFieldListGet(
        Valid => 0,
    );

    # get the list of order numbers (is already sorted).
    my @DynamicfieldOrderList;
    my %DynamicfieldNamesList;
    for my $Dynamicfield ( @{$DynamicFieldList} ) {
        push @DynamicfieldOrderList, $Dynamicfield->{FieldOrder};
        $DynamicfieldNamesList{ $Dynamicfield->{FieldOrder} } = $Dynamicfield->{Label};
    }

    # when adding we need to create an extra order number for the new field
    if ( $Param{Mode} eq 'Add' ) {

        # get the last element from the order list and add 1
        my $LastOrderNumber = $DynamicfieldOrderList[-1];
        $LastOrderNumber++;

        # add this new order number to the end of the list
        push @DynamicfieldOrderList, $LastOrderNumber;
    }

    # show the names of the other fields to ease ordering
    my %OrderNamesList;
    my $CurrentlyText = $LayoutObject->{LanguageObject}->Translate('Currently') . ': ';
    for my $OrderNumber ( sort @DynamicfieldOrderList ) {
        $OrderNamesList{$OrderNumber} = $OrderNumber;
        if ( $DynamicfieldNamesList{$OrderNumber} && $OrderNumber ne $Param{FieldOrder} ) {
            $OrderNamesList{$OrderNumber} = $OrderNumber . ' - '
                . $CurrentlyText
                . $DynamicfieldNamesList{$OrderNumber};
        }
    }

    my $DynamicFieldOrderStrg = $LayoutObject->BuildSelection(
        Data          => \%OrderNamesList,
        Name          => 'FieldOrder',
        SelectedValue => $Param{FieldOrder} || 1,
        PossibleNone  => 0,
        Translation   => 0,
        Sort          => 'NumericKey',
        Class         => 'Modernize W75pc Validate_Number',
    );

    # Add field type specific inputs. Currently only Selections are supported.
    # Selections may be set up in a declarative way.
    SETTING:
    for my $Setting ( $Self->{FieldTypeSettings}->@* ) {
        next SETTING unless $Setting->{InputType};

        if ( $Setting->{InputType} eq 'Selection' ) {
            my $Name       = $Setting->{ConfigParamName};
            my @CssClasses = qw(Modernize W50pc);
            push @CssClasses, $Setting->{Mandatory}           ? 'Validate_Required' : ();
            push @CssClasses, $Param{ $Name . 'ServerError' } ? 'ServerError'       : ();
            my $FieldStrg = $LayoutObject->BuildSelection(
                Name           => $Name,
                Data           => $Setting->{SelectionData},
                PossibleNone   => ( $Setting->{PossibleNone} // 0 ),
                Disabled       => ( $Setting->{Disabled}     // 0 ),
                SelectedID     => $Param{$Name} || '0',
                Class          => ( join ' ', @CssClasses ),
                Multiple       => ( $Setting->{Multiple}    // 0 ),
                TreeView       => ( $Setting->{TreeView}    // 0 ),
                Sort           => ( $Setting->{Sort}        // 0 ),
                SortReverse    => ( $Setting->{SortReverse} // 0 ),
                SortIndividual => $Setting->{SortIndividual},
            );
            $LayoutObject->Block(
                Name => 'ConfigParamRow',
                Data => {
                    ConfigParamName    => $Name,
                    Label              => $Setting->{Label},
                    FieldStrg          => $FieldStrg,
                    Explanation        => $Setting->{Explanation},
                    ServerErrorMessage => $Param{ $Name . 'ServerErrorMessage' },
                },
            );

            next SETTING;
        }

        # more input types might be supported in future
    }

    my $NamespaceList = $Kernel::OM->Get('Kernel::Config')->Get('DynamicField::Namespaces');
    if ( IsArrayRefWithData($NamespaceList) ) {
        my $NamespaceStrg = $LayoutObject->BuildSelection(
            Data          => $NamespaceList,
            Name          => 'Namespace',
            SelectedValue => $Namespace || '',
            PossibleNone  => 1,
            Translation   => 0,
            Sort          => 'AlphanumericValue',
            Class         => 'Modernize W75pc',
        );

        $LayoutObject->Block(
            Name => 'DynamicFieldNamespace',
            Data => {
                NamespaceStrg => $NamespaceStrg,
            },
        );
    }

    my %ValidList = $Kernel::OM->Get('Kernel::System::Valid')->ValidList();

    # create the Validity select
    my $ValidityStrg = $LayoutObject->BuildSelection(
        Data         => \%ValidList,
        Name         => 'ValidID',
        SelectedID   => $Param{ValidID} || 1,
        PossibleNone => 0,
        Translation  => 1,
        Class        => 'Modernize W50pc',
    );

    # Internal fields can not be deleted and name should not change.
    my $ReadonlyInternalField = '';
    if ( $Param{InternalField} ) {
        $LayoutObject->Block(
            Name => 'InternalField',
            Data => {%Param},
        );
        $ReadonlyInternalField = 'readonly';
    }

    # get the field id
    my $FieldID = $Kernel::OM->Get('Kernel::System::Web::Request')->GetParam( Param => 'ID' );

    # only if the dynamic field exists and should be edited,
    # not if the field is added for the first time
    if ($FieldID) {

        my $DynamicField = $DynamicFieldObject->DynamicFieldGet(
            ID => $FieldID,
        );

        my $DynamicFieldName = $DynamicField->{Name};

        # Add warning in case the DynamicField belongs a SysConfig setting.
        my $SysConfigObject = $Kernel::OM->Get('Kernel::System::SysConfig');

        # In case dirty setting disable form
        my $IsDirtyConfig = 0;
        my @IsDirtyResult = $SysConfigObject->ConfigurationDirtySettingsList();
        my %IsDirtyList   = map { $_ => 1 } @IsDirtyResult;

        my @IsDynamicFieldInSysConfig = $SysConfigObject->ConfigurationEntityCheck(
            EntityType => 'DynamicField',
            EntityName => $DynamicFieldName // '',
        );

        if (@IsDynamicFieldInSysConfig) {
            $LayoutObject->Block(
                Name => 'DynamicFieldInSysConfig',
                Data => {
                    OldName => $DynamicFieldName,
                },
            );
            for my $SettingName (@IsDynamicFieldInSysConfig) {
                $LayoutObject->Block(
                    Name => 'DynamicFieldInSysConfigRow',
                    Data => {
                        SettingName => $SettingName,
                    },
                );

                # Verify if dirty setting
                if ( $IsDirtyList{$SettingName} ) {
                    $IsDirtyConfig = 1;
                }

            }
        }

        if ($IsDirtyConfig) {
            $LayoutObject->Block(
                Name => 'DynamicFieldInSysConfigDirty',

            );
        }

    }

    my $FilterStrg = '';
    if ( IsStringWithData( $Param{ObjectTypeFilter} ) ) {
        $FilterStrg .= ";ObjectTypeFilter=" . $LayoutObject->Output(
            Template => '[% Data.Filter | uri %]',
            Data     => {
                Filter => $Param{ObjectTypeFilter},
            },
        );
    }

    if ( IsArrayRefWithData($NamespaceList) ) {
        if ( IsStringWithData( $Param{NamespaceFilter} ) ) {
            $FilterStrg .= ";NamespaceFilter=" . $LayoutObject->Output(
                Template => '[% Data.Filter | uri %]',
                Data     => {
                    Filter => $Param{NamespaceFilter},
                },
            );
        }
    }

    # generate output
    return join '',
        $Output,
        $LayoutObject->Output(
            TemplateFile => $Self->{TemplateFile},
            Data         => {
                %Param,
                FilterStrg            => $FilterStrg,
                ValidityStrg          => $ValidityStrg,
                DynamicFieldOrderStrg => $DynamicFieldOrderStrg,
                ReadonlyInternalField => $ReadonlyInternalField,
            },
        ),
        $LayoutObject->Footer;
}

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-2026 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/>.
# --

<div class="MainBox ARIARoleMain LayoutFixedSidebar SidebarFirst">
    <h1 class="InvisibleText">
        [% Translate("Dynamic Fields") | html %] - [% Translate(Data.ObjectTypeName) | html %]:
        [% USE Title = String(Data.BreadcrumbText) %]
        [% Title | html %]
    </h1>

    [% BreadcrumbPath = [
            {
                Name => Translate('Dynamic Fields Management'),
                Link => 'AdminDynamicField' _ Data.FilterStrg,
            },
        ]
    %]

    [% USE BreadcrumbName = String(Translate(Data.ObjectTypeName)) %]

    [% SWITCH Data.Mode %]
        [% CASE 'Add' %]
            [% BreadcrumbPath.push({ Name => BreadcrumbName.append( ': ', Title ) }) %]
        [% CASE 'Change' %]
            [% BreadcrumbPath.push({ Name => BreadcrumbName.append( ': ', Title, ' - ', Data.Name ) }) %]
    [% END %]

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

    <div class="Clear"></div>

    <div class="SidebarColumn">
        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("Actions") | html %]</h2>
            </div>
            <div class="Content">
                <ul class="ActionList">
                    <li>
                        <a href="[% Env("Baselink") %]Action=AdminDynamicField[% Data.FilterStrg %]" class="CallForAction Fullsize Center"><span><i class="fa fa-caret-left"></i>[% Translate("Go back to overview") | html %]</span></a>
                    </li>
                </ul>
            </div>
        </div>
    </div>

    <div class="ContentColumn">
        <form id="EntityUpdate" action="[% Env("CGIHandle") %]" method="post" class="Validate PreventMultipleSubmits">
            <input type="hidden" name="Action" value="AdminDynamicFieldTextAreaAI">
            <input type="hidden" name="Subaction" value="[% Data.Mode | html %]Action">
            <input type="hidden" name="ObjectType" value="[% Data.ObjectType | html %]">
            <input type="hidden" name="FieldType" value="[% Data.FieldType | html %]">
            <input type="hidden" name="ObjectTypeFilter" value="[% Data.ObjectTypeFilter | html %]">
            <input type="hidden" name="NamespaceFilter" value="[% Data.NamespaceFilter | html %]">
            <input type="hidden" name="ID" value="[% Data.ID | html %]">
            <input type="hidden" name="ContinueAfterSave" id="ContinueAfterSave" value=""/>

            <div class="WidgetSimple">
                <div class="Header">
                    <h2>[% Translate("General") | html %]</h2>
                </div>
                <div class="Content">
                    <div class="LayoutGrid ColumnsWithSpacing">
                        <div class="Size1of2">
                            <fieldset class="TableLike">
                                <label class="Mandatory" for="Name"><span class="Marker">*</span> [% Translate("Name") | html %]:</label>
                                <div class="Field">
                                    <input id="Name" class="W50pc [% Data.NameServerError | html %] [% Data.ShowWarning | html %]  Validate_Alphanumeric" type="text" maxlength="200" value="[% Data.PlainFieldName | html %]" name="Name" [% Data.ReadonlyInternalField | html %]>
                                    <div id="NameError" class="TooltipErrorMessage"><p>[% Translate("This field is required, and the value should be alphabetic and numeric characters only.") | html %]</p></div>
                                    <div id="NameServerError" class="TooltipErrorMessage"><p>[% Translate(Data.NameServerErrorMessage) | html %]</p></div>
                                    <p class="FieldExplanation">[% Translate("Must be unique and only accept alphabetic and numeric characters.") | html %]</p>
                                    <p class="Warning Hidden">[% Translate("Changing this value will require manual changes in the system.") | html %]</p>
                                </div>
                                <div class="Clear"></div>

                                <label class="Mandatory" for="Label"><span class="Marker">*</span> [% Translate("Label") | html %]:</label>
                                <div class="Field">
                                    <input id="Label" class="W50pc [% Data.LabelServerError | html %] Validate_Required" type="text" maxlength="200" value="[% Data.Label | html %]" name="Label"/>
                                    <div id="LabelError" class="TooltipErrorMessage"><p>[% Translate("This field is required.") | html %]</p></div>
                                    <div id="LabelServerError" class="TooltipErrorMessage"><p>[% Translate(Data.LabelServerErrorMessage) | html %]</p></div>
                                    <p class="FieldExplanation">[% Translate("This is the name to be shown on the screens where the field is active.") | html %]</p>
                                </div>
                                <div class="Clear"></div>

                                <label class="Mandatory" for="FieldOrder"><span class="Marker">*</span> [% Translate("Field order") | html %]:</label>
                                <div class="Field">
                                    [% Data.DynamicFieldOrderStrg %]
                                    <div id="FieldOrderError" class="TooltipErrorMessage"><p>[% Translate("This field is required and must be numeric.") | html %]</p></div>
                                    <div id="FieldOrderServerError" class="TooltipErrorMessage"><p>[% Translate(Data.FieldOrderServerErrorMessage) | html %]</p></div>
                                    <p class="FieldExplanation">[% Translate("This is the order in which this field will be shown on the screens where is active.") | html %]</p>
                                </div>
                                <div class="Clear"></div>

[% RenderBlockStart("DynamicFieldNamespace") %]
                                <label for="Namespace">[% Translate("Namespace") | html %]:</label>
                                <div class="Field">
                                    [% Data.NamespaceStrg %]
                                    <p class="FieldExplanation">[% Translate("This is the namespace in which this field will be used as prefix with the name.") | html %]</p>
                                </div>
                                <div class="Clear"></div>
[% RenderBlockEnd("DynamicFieldNamespace") %]

                                <label for="TooltipValue">[% Translate("Tooltip message:") | html %]</label>
                                <div class="Field">
                                    <textarea id="TooltipValue" class="W75pc" rows="3" cols="80" name="Tooltip">[% Data.Tooltip | html %]</textarea>
                                    <p class="FieldExplanation">[% Translate("This is the tooltip message shown inside the customer interface.") | html %]</p>
                                </div>
                                <div class="Clear"></div>
                            </fieldset>
                        </div>
                        <div class="Size1of2">
                            <fieldset class="TableLike">
                                <label for="ValidID">[% Translate("Validity") | html %]:</label>
                                <div class="Field">
                                    [% Data.ValidityStrg %]
                                    <div id="ValidIDError" class="TooltipErrorMessage">
                                        <p>[% Translate("This field is required.") | html %]</p>
                                    </div>
                                    <div id="ValidIDServerError" class="TooltipErrorMessage">
                                        <p>
[% RenderBlockStart("RequiredValidOptionServerError") %]
                                            [% Translate("This field is required.") | html %]
[% RenderBlockEnd("RequiredValidOptionServerError") %]
[% RenderBlockStart("InSettingValidOptionServerError") %]
                                            [% Translate("Is not possible to invalidate this entry, all config settings have to be changed beforehand.") | html %]
[% RenderBlockEnd("InSettingValidOptionServerError") %]
                                        </p>
                                    </div>
                                </div>
                                <div class="Clear"></div>

                                <div class="SpacingTop"></div>
                                <label for="FieldTypeName">[% Translate("Field type") | html %]:</label>
                                <div class="Field">
                                    <input id="FieldTypeName" readonly class="W50pc" type="text" maxlength="200" value="[% Translate(Data.FieldTypeName) | html %]" name="FieldTypeName"/>
                                    <div class="Clear"></div>
                                </div>

                                <div class="SpacingTop"></div>
                                <label for="ObjectTypeName">[% Translate("Object type") | html %]:</label>
                                <div class="Field">
                                    <input id="ObjectTypeName" readonly class="W50pc" type="text" maxlength="200" value="[% Translate(Data.ObjectTypeName) | html %]" name="ObjectTypeName"/>
                                    <div class="Clear"></div>
                                </div>

[% RenderBlockStart("InternalField") %]
                                <div class="SpacingTop"></div>
                                <label for="InternalField">[% Translate("Internal field") | html %]:</label>
                                <div class="Field">
                                    <input id="InternalField" readonly class="W50pc" type="text" maxlength="1" value="[% Data.InternalField | html %]" name="InternalField"/>
                                    <p class="FieldExplanation">
                                        [% Translate("This field is protected and can't be deleted.") | html %]
                                    </p>
                                    <div class="Clear"></div>
                                </div>
[% RenderBlockEnd("InternalField") %]
                            </fieldset>
[% RenderBlockStart("DynamicFieldInSysConfig") %]
                            <input type="hidden" name="OldName" id="OldName" value="[% Data.OldName | html %]"/>
                            <input type="hidden" name="UpdateEntity" id="UpdateEntity" value=""/>
                            <div id="EntityInSetting" class="Hidden">
                                <div class="TextDialog">
                                    <h1>[% Translate("This dynamic field is used in the following config settings:") | html %]</h1>
                                    <ul>
[% RenderBlockStart("DynamicFieldInSysConfigRow") %]
                                        <li class="InSysConfigSetting">[% Data.SettingName %]</li>
[% RenderBlockEnd("DynamicFieldInSysConfigRow") %]
                                    </ul>
                                    <p class="FieldExplanation"></p>
                                </div>
                            </div>
[% RenderBlockEnd("DynamicFieldInSysConfig") %]
[% RenderBlockStart("DynamicFieldInSysConfigDirty") %]
                            <input type="hidden" name="SysConfigDirty" id="SysConfigDirty" value="1"/>
[% RenderBlockEnd("DynamicFieldInSysConfigDirty") %]
                        </div>
                    </div>
                </div>
            </div>
            <div class="WidgetSimple">
                <div class="Header">
                    <h2>[% Translate(Data.FieldTypeName) | html %] [% Translate("Field Settings") | html %]</h2>
                </div>
                <div class="Content">
                    <fieldset class="TableLike">
[% RenderBlockStart("ColsRowsValues") %]
                        <label for="Rows">[% Translate("Number of rows") | html %]:</label>
                        <div class="Field">
                            <input id="Rows" class="W25pc Validate_Number [% Data.RowsServerError %]" type="text" maxlength="3" value="[% Data.Rows | html %]" name="Rows"/>
                            <div id="RowsError" class="TooltipErrorMessage"><p>[% Translate("This field must be numeric.") | html %]</p></div>
                            <div id="RowsServerError" class="TooltipErrorMessage"><p>[% Translate(Data.RowsServerErrorMessage) | html %]</p></div>
                            <p class="FieldExplanation">[% Translate("Specify the height (in lines) for this field in the edit mode.") | html %]</p>
                        </div>
                        <div class="Clear"></div>
                        <label for="Cols">[% Translate("Number of cols") | html %]:</label>
                        <div class="Field">
                            <input id="Cols" class="W25pc Validate_Number [% Data.ColsServerError %]" type="text" maxlength="3" value="[% Data.Cols | html %]" name="Cols"/>
                            <div id="ColsError" class="TooltipErrorMessage"><p>[% Translate("This field must be numeric.") | html %]</p></div>
                            <div id="ColsServerError" class="TooltipErrorMessage"><p>[% Translate(Data.ColsServerErrorMessage) | html %]</p></div>
                            <p class="FieldExplanation">[% Translate("Specify the width (in characters) for this field in the edit mode.") | html %]</p>
                        </div>
                        <div class="Clear"></div>
[% RenderBlockEnd("ColsRowsValues") %]

[% RenderBlockStart("ConfigParamRow") %]
                        <label for="[% Data.ConfigParamName | html %]">[% Translate(Data.Label) | html %]</label>
                        <div class="Field">
                            [% Data.FieldStrg %]
                            <div id="[% Data.ConfigParamName | html %]Error" class="TooltipErrorMessage"><p>[% Translate("This field is required, and the value should be alphabetic and numeric characters only.") | html %]</p></div>
                            <div id="[% Data.ConfigParamName | html %]ServerError" class="TooltipErrorMessage"><p>[% Translate(Data.ServerErrorMessage) | html %]</p></div>
                            <p class="FieldExplanation">[% Translate(Data.Explanation) | html %]</p>
                        </div>
                        <div class="Clear"></div>
[% RenderBlockEnd("ConfigParamRow") %]

                    </fieldset>
                </div>
            </div>
            <fieldset class="TableLike">
                <div class="Field SpacingTop">
                    [% IF Data.Mode == 'Change' %]
                    <button class="Primary CallForAction" id="SubmitAndContinue" type="button" value="[% Translate("Save") | html %]"><span>[% Translate("Save") | html %]</span></button>
                    [% Translate("or") | html %]
                    <button class="Primary CallForAction" id="Submit" type="submit" value="[% Translate("Save") | html %]"><span>[% Translate("Save and finish") | html %]</span></button>
                    [% ELSE %]
                    <button class="Primary CallForAction" id="Submit" type="submit" value="[% Translate("Save") | html %]"><span>[% Translate("Save") | html %]</span></button>
                    [% END %]
                    [% Translate("or") | html %]
                    <a href="[% Env("Baselink") %]Action=AdminDynamicField[% Data.FilterStrg %]">[% Translate("Cancel") | html %]</a>
                </div>
                <div class="Clear"></div>
            </fieldset>
        </form>
    </div>
</div>
 IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjYgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCgo8dGV4dGFyZWEgY2xhc3M9IlslIERhdGEuRmllbGRDbGFzcyAlXSIgaWQ9IlslIERhdGEuRmllbGROYW1lICVdIiBuYW1lPSJbJSBEYXRhLkZpZWxkTmFtZSAlXSIgdGl0bGU9IlslIERhdGEuRmllbGRMYWJlbEVzY2FwZWQgJV0iIHJvd3M9IlslIERhdGEuUm93c051bWJlciAlXSIgY29scz0iWyUgRGF0YS5Db2xzTnVtYmVyICVdIiBkYXRhLW1heGxlbmd0aD0iWyUgRGF0YS5NYXhMZW5ndGggJV0iIHJlYWRvbmx5PlslIERhdGEuVmFsdWVFc2NhcGVkICVdPC90ZXh0YXJlYT4KPGRpdiBpZD0iWyUgRGF0YS5EaXZJRCAlXSIgY2xhc3M9IlRvb2x0aXBFcnJvck1lc3NhZ2UiPgogICAgPHA+CiAgICAgICAgWyUgRGF0YS5FcnJvck1lc3NhZ2UyICVdIFslIERhdGEuRXJyb3JNZXNzYWdlMyAlXQogICAgPC9wPgo8L2Rpdj4K IyAtLQojIE9UT0JPIGlzIGEgd2ViLWJhc2VkIHRpY2tldGluZyBzeXN0ZW0gZm9yIHNlcnZpY2Ugb3JnYW5pc2F0aW9ucy4KIyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDIwIE9UUlMgQUcsIGh0dHBzOi8vb3Rycy5jb20vCiMgQ29weXJpZ2h0IChDKSAyMDE5LTIwMjYgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwojIC0tCiMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKIyB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZQojIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiMgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCiMgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MKIyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQojIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiBJZiBub3QsIHNlZSA8aHR0cHM6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgojIC0tCjxmb3JtIGFjdGlvbj0iWyUgRW52KCJDR0lIYW5kbGUiKSAlXSIgbWV0aG9kPSJwb3N0IiBlbmN0eXBlPSJtdWx0aXBhcnQvZm9ybS1kYXRhIiBuYW1lPSJDb21wb3NlUmVxdWVzdCIgaWQ9IkNvbXBvc2VSZXF1ZXN0IiBjbGFzcz0iVmFsaWRhdGUiPgogICAgPGZpZWxkc2V0IGNsYXNzPSJUYWJsZUxpa2UgRml4ZWRMYWJlbCI+CgogICAgICAgIDxkaXYgY2xhc3M9IlJvdyIgc3R5bGU9ImdyaWQtdGVtcGxhdGUtY29sdW1uczogMWZyIj4KICAgICAgICAgICAgPGRpdiBjbGFzcz0iRmllbGRDZWxsIiBzdHlsZT0iZ3JpZC1jb2x1bW46IDEgLyBzcGFuIDEiPgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0iRmllbGQiPgogICAgICAgICAgICAgICAgICAgIDx0ZXh0YXJlYSBjbGFzcz0iT3RvYm9BSVRleHRBcmVhIiB0aXRsZT0iWW91ciBxdWVzdGlvbj8iIHBsYWNlaG9sZGVyPSJZb3VyIHF1ZXN0aW9uPyIgaWQ9IlJlcXVlc3QiIG5hbWU9IlJlcXVlc3QiIHJvd3M9IjUiIGNvbHM9IlslIENvbmZpZygiT3RvYm9BSURhc2hib2FyZDo6RnJvbnRlbmQ6OlRleHRBcmVhUXVlc3Rpb24iKSAlXSIgY2xhc3M9IlJpY2hUZXh0IFZhbGlkYXRlX1JlcXVpcmVkIFslIERhdGEuQm9keUludmFsaWQgfCBodG1sICVdIj5bJSBEYXRhLlF1ZXN0aW9uICVdPC90ZXh0YXJlYT4KICAgICAgICAgICAgICAgICAgICA8ZGl2IGlkPSJSZXF1ZXN0RXJyb3IiIGNsYXNzPSJUb29sdGlwRXJyb3JNZXNzYWdlIj48cD5bJSBUcmFuc2xhdGUoIlRoaXMgZmllbGQgaXMgcmVxdWlyZWQuIikgfCBodG1sICVdPC9wPjwvZGl2PgogICAgICAgICAgICAgICAgICAgIDxkaXYgaWQ9IlJlcXVlc3RTZXJ2ZXJFcnJvciIgY2xhc3M9IlRvb2x0aXBFcnJvck1lc3NhZ2UiPjxwPlslIFRyYW5zbGF0ZSgiVGhpcyBmaWVsZCBpcyByZXF1aXJlZC4iKSB8IGh0bWwgJV08L3A+PC9kaXY+CiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgPC9kaXY+CiAgICAgICAgPC9kaXY+CiAgICAgICAgPGRpdiBpZD0iUmVwbHlCb3giIGNsYXNzPSJSb3ciIHN0eWxlPSJncmlkLXRlbXBsYXRlLWNvbHVtbnM6IDFmciI+CiAgICAgICAgICAgIDxkaXYgY2xhc3M9IkZpZWxkQ2VsbCIgc3R5bGU9ImdyaWQtY29sdW1uOiAxIC8gc3BhbiAxIj4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9IkZpZWxkIj4KICAgICAgICAgICAgICAgICAgICA8dGV4dGFyZWEgY2xhc3M9Ik90b2JvQUlUZXh0QXJlYSIgaWQ9IlJlcGx5IiByb3dzPSIxNSIgY29scz0iWyUgQ29uZmlnKCJPdG9ib0FJRGFzaGJvYXJkOjpGcm9udGVuZDo6VGV4dEFyZWFRdWVzdGlvbiIpICVdIiByZWFkb25seSBjbGFzcz0iUmVhZG9ubHkgUmljaFRleHQiPjwvdGV4dGFyZWE+CiAgICAgICAgICAgICAgICAgICAgPGRpdiBpZD0iUmVxdWVzdEVycm9yIiBjbGFzcz0iVG9vbHRpcEVycm9yTWVzc2FnZSI+PHA+WyUgVHJhbnNsYXRlKCJUaGlzIGZpZWxkIGlzIHJlcXVpcmVkLiIpIHwgaHRtbCAlXTwvcD48L2Rpdj4KICAgICAgICAgICAgICAgICAgICA8ZGl2IGlkPSJSZXF1ZXN0U2VydmVyRXJyb3IiIGNsYXNzPSJUb29sdGlwRXJyb3JNZXNzYWdlIj48cD5bJSBUcmFuc2xhdGUoIlRoaXMgZmllbGQgaXMgcmVxdWlyZWQuIikgfCBodG1sICVdPC9wPjwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY+CiAgICAgICAgICAgIDwvZGl2PgogICAgICAgIDwvZGl2PgogICAgICAgIDxkaXYgY2xhc3M9IkZpZWxkIFNwYWNpbmdUb3AiPgogICAgICAgICAgICA8YnV0dG9uIGlkPSJTdWJtaXRRdWVzdGlvbiIgY2xhc3M9IkNhbGxGb3JBY3Rpb24gUHJpbWFyeSIgYWNjZXNza2V5PSJnIiB0aXRsZT0iWyUgVHJhbnNsYXRlKCJTZW5kIHF1ZXN0aW9uIikgfCBodG1sICVdIChnKSIgdmFsdWU9IlslIFRyYW5zbGF0ZSgiU2VuZCByZXF1ZXN0IikgfCBodG1sICVdIiA+CiAgICAgICAgICAgICAgICA8c3Bhbj48c3Bhbj48aSBjbGFzcz0ib29vZm8gb29vZm8tYWRkIj48L2k+WyUgVHJhbnNsYXRlKCJTZW5kIHJlcXVlc3QiKSB8IGh0bWwgJV08L3NwYW4+CiAgICAgICAgICAgIDwvYnV0dG9uPgogICAgICAgICAgICA8YnV0dG9uIGlkPSJDYW5jZWxRdWVzdGlvbiIgY2xhc3M9IkNhbGxGb3JBY3Rpb24gUHJpbWFyeSIgYWNjZXNza2V5PSJnIiB0aXRsZT0iWyUgVHJhbnNsYXRlKCJTZW5kIHF1ZXN0aW9uIikgfCBodG1sICVdIChnKSIgdmFsdWU9IlslIFRyYW5zbGF0ZSgiQ2FuY2VsIikgfCBodG1sICVdIiA+CiAgICAgICAgICAgICAgICA8c3Bhbj5bJSBUcmFuc2xhdGUoIkNhbmNlbCIpIHwgaHRtbCAlXTwvc3Bhbj4KICAgICAgICAgICAgPC9idXR0b24+CiAgICAgICAgICAgIDxpbWcgaWQ9Ik90b2JvQUlMb2FkZXIiIHNyYz1bJSBDb25maWcoIkZyb250ZW5kOjpXZWJQYXRoIikgJV1za2lucy9BZ2VudC9kZWZhdWx0L2ltZy9sb2FkZXIuZ2lmIGFsdD0iWyUgVHJhbnNsYXRlKCJXYWl0aW5nIHJlcGx5IikgfCBodG1sICVdIi8+CiAgICAgICAgPC9kaXY+CiAgICA8L2ZpZWxkc2V0Pgo8L2Zvcm0+Cg== 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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-2026 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::OtoboAI;

use strict;
use warnings;

# core modules

# CPAN modules

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

use parent qw(Kernel::System::AsynchronousExecutor);

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::GenericInterface::Requester',
    'Kernel::System::Cache',
    'Kernel::System::DynamicField',
    'Kernel::System::DynamicField::Backend',
    'Kernel::System::GenericInterface::Webservice',
    'Kernel::System::Log',
    'Kernel::System::Main',
    'Kernel::System::Ticket::Article',
    'Kernel::System::Ticket',
);

=head1 NAME

Kernel::System::OtoboAI - get OtoboAI GetAnswer for a Question or an ArticleID

=head1 DESCRIPTION

call OtoboAI GetAnswer synchronously or asynchronously

=head2 new()

create a OtoboAI object. Do not use it directly, instead use:

    my $OtoboAIObject = $Kernel::OM->Get('Kernel::System::OtoboAI');

=cut

sub new {

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

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

    my $StripSignatureRegEx = $Kernel::OM->Get('Kernel::Config')->Get('OTOBOAI::StripSignatureRegex');
    if ($StripSignatureRegEx) {

        my $Regex = qr/$StripSignatureRegEx/m;
        $Self->{StripSignatureRegEx} = $Regex;
    }

    return $Self;
}

=head2 GetAnswerAsync()

Get an OtoboAI Answer asynchronously.

    my $Success = $OtoboAIObject->GetAnswerAsync(
        Question => '<some ai question>',  # the question to ask the LLM
        ObjectID => $ArticleID,            # if given, construct question from Article Subject+Body
                                           # results will be stored in this Articles AIResult DynamicField
        UserID   => $UserID,               # if specified, and this was a question, populate user specfic cache key
    );

=cut

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

    if ( !$Param{ObjectID} && !$Param{Question} ) {

        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Need either ObjectID or Question param.",
        );
        return;
    }

    $Kernel::OM->Get('Kernel::System::Log')->Log(
        Priority => 'debug',
        Message  => "OtoboAI::GetAnswerAsync call initiated.",
    );

    my $Success = $Self->AsyncCall(
        ObjectName               => 'Kernel::System::OtoboAI',    # optional, if not given the object is used from where
                                                                  # this function was called
        FunctionName             => 'GetAnswer',                  # the name of the function to execute
        FunctionParams           => \%Param,                      # a ref with the required parameters for the function
        Attempts                 => 1,                            # optional, default: 1, number of tries to lock the
                                                                  #   task by the scheduler
        MaximumParallelInstances => 0,                            # optional, default: 0 (unlimited), number of same
                                                                  #   function calls from the same object that can be
                                                                  #   executed at the same time
    );

    if ( !$Success ) {

        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Initialize async call failed!",
        );
        return;
    }

    return 1;
}

=head2 GetAnswer()

Get an OtoboAI Answer synchronously. If called from GetAnswerAsync(), this will happen on a Daemon thread.

    my $Result = $OtoboAIObject->GetAnswer(
        Question  => '<some ai question>', # the question to ask the LLM
        ObjectID  => $ArticleID,           # if given, construct question from Article Subject+Body
                                           # results will be stored in this Articles AIResult DynamicField
        UserID    => $UserID,              # if specified, and this was a question, populate user specfic cache key
        Persist   => 1|0,                  # optional, default is 1. Whether to persist Result in DF (with ObjectID) or
                                           # poplate the use specific cache key
        DoScoring => 0|1,                  # ask LLM to do the extra evaluation step, used by Maint::AI::Scoring
                                           # console command
        RAG       => 'Custom1',            # (optional), default: $ConfigObject->Get('OTOBOAI::DefaultRAG'), the RAG
                                           # that should be used to generate the answer, only works for question calls
    );

    # on success
    $Result = {
        Success => 1,
        Data => {
            Answer => 'the AI answer as text',
            Score  => 'The AI evaluation score %.',  # only if scoring is activated, see SysConfig
        },
    }

    # on error
    $Result = {
        Success => 0,
        Error => "SomeErrorMsg",
    }

=cut

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

    if ( !$Param{ObjectID} && !$Param{Question} ) {

        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Need either ObjectID or Question param.",
        );
        return;
    }

    my $DoScoring = $Param{DoScoring} // 0;

    my $ErrorMessage = '';
    my $Success      = 0;

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

    # check whether otobo AI is enabled and if not, activate it
    my $WebserviceObject = $Kernel::OM->Get('Kernel::System::GenericInterface::Webservice');

    my $AIWebservice = $WebserviceObject->WebserviceGet(
        Name => 'OTOBO-AI',
    );

    if ( !$AIWebservice ) {

        $ErrorMessage = "OTOBO-AI webservice not found! Unable to continue.";
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => $ErrorMessage,
        );

        return {
            Success => $Success,
            Error   => $ErrorMessage,
        };
    }

    # Set the webservice id
    $Self->{WebserviceID} = $AIWebservice->{ID};

    # prepare the question
    my $ObjectID = $Param{ObjectID};
    my $UserID   = $Param{UserID};
    my $Persist  = $Param{Persist} // 1;
    my $Question;
    my $RAG = $Param{RAG} // $ConfigObject->Get('OTOBOAI::DefaultRAG');

    if ($ObjectID) {

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

        my $ArticleID = $ObjectID;
        my $TicketID  = $ArticleObject->TicketIDLookup(
            ArticleID => $ArticleID,
        );

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

        my $ArticleBackendObject = $ArticleObject->BackendForArticle(
            TicketID  => $TicketID,
            ArticleID => $ArticleID,
        );

        my %Article = $ArticleBackendObject->ArticleGet(
            TicketID  => $TicketID,
            ArticleID => $ArticleID,
        );

        if ( !$Article{Body} ) {
            return {
                Success      => 0,
                ErrorMessage => "No body in the article!",
            };
        }

        my $Subject = $Article{Subject} // '';
        my $Body    = $Article{Body}    // '';

        $Body     = $Self->_StripSignature( Body => $Body );
        $Question = "Subject: " . $Subject . '\n\n' . $Body;

        my $QueueToRAGMapping = $ConfigObject->Get('OTOBOAI::QueueToRAGMapping') // {};
        $RAG = $QueueToRAGMapping->{ $TicketData{Queue} } // $ConfigObject->Get('OTOBOAI::DefaultRAG');
    }
    else {

        $Question = $Param{Question};
    }

    my $Result = $Kernel::OM->Get('Kernel::GenericInterface::Requester')->Run(
        WebserviceID => $Self->{WebserviceID},
        Invoker      => 'GetAnswer',
        Asynchronous => 0,
        Data         => {
            Question  => $Question,
            DoScoring => $DoScoring,
            RAG       => $RAG,
        }
    );

    my $MainObject = $Kernel::OM->Get('Kernel::System::Main');
    my $Dump       = $MainObject->Dump($Result);

    $Kernel::OM->Get('Kernel::System::Log')->Log(
        Priority => 'debug',
        Message  => "OtoboAI GetAnswer Result: $Dump",
    );

    my $Answer = $Result->{Data}{Answer} || "";

    # set dynamic field value if ObjectID was given
    if ( $ObjectID && $Persist ) {

        # fetching dynamic field config
        my $DynamicFieldName = $Kernel::OM->Get('Kernel::Config')->Get('OTOBOAI::DynamicFieldOTOBOAI') || 'OTOBOAI';
        my $OTOBOAIDFConfig  = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldGet(
            Name => $DynamicFieldName,
        );
        if ( !IsHashRefWithData($OTOBOAIDFConfig) ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "DynamicField '$DynamicFieldName' not found on the system!",
            );
            return;
        }

        $Kernel::OM->Get('Kernel::System::DynamicField::Backend')->ValueSet(
            DynamicFieldConfig => $OTOBOAIDFConfig,
            ObjectID           => $ObjectID,
            Value              => $Answer,
            DoWrite            => 1,
            UserID             => 1,
        );
    }
    elsif ( $UserID && $Persist ) {
        my $CacheObject      = $Kernel::OM->Get('Kernel::System::Cache');
        my $MainObject       = $Kernel::OM->Get('Kernel::System::Main');
        my $QuestionMd5      = $MainObject->MD5sum( String => \$Question );
        my $CacheKeyQuestion = 'OtoboAI-Custom-Response-' . $QuestionMd5;
        my $TTL              = $Kernel::OM->Get('Kernel::Config')->Get('OtoboAIDashboard::Frontend::CacheTTL')->{Answer} || 24;
        $CacheObject->Set(
            Type  => 'OtoboAI',
            Key   => $CacheKeyQuestion,
            Value => $Answer,
            TTL   => 60 * 60 * $TTL,
        );
    }

    return {
        Success => 1,
        Data    => $Result->{Data},
    };
}

sub _StripSignature {

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

    my $Body = $Param{Body};

    my $RegEx = $Self->{StripSignatureRegEx};
    return $Body if ( !$RegEx );

    if ( $Body =~ /$RegEx/ ) {

        return substr( $Body, 0, $-[0] );
    }
    else {

        return $Body;
    }
}

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/
# --
# 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::OtoboAI::Import;

use strict;
use warnings;

use Path::Class    qw(file);
use File::Find     qw(find);
use File::Basename qw(dirname);
use JSON           qw(encode_json from_json);
use Storable       qw(dclone);

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

use parent qw(Kernel::System::AsynchronousExecutor);

our @ObjectDependencies = (
    'Kernel::System::GenericInterface::Webservice',
    'Kernel::System::Log',
    'Kernel::Config',
    'Kernel::System::Ticket',
    'Kernel::System::Ticket::Article',
    'Kernel::GenericInterface::Requester',
    'Kernel::System::Package',
    'Kernel::System::FAQ',
    'Kernel::System::HTMLUtils',
);

=head1 NAME

Kernel::System::OtoboAI::Import - ingest Tickets or FAQs

=head1 DESCRIPTION

call OtoboAI Import synchronously or asynchronously

=head2 new()

create an Import object. Do not use it directly, instead use:

    my $ImportObject = $Kernel::OM->Get('Kernel::System::OtoboAI::Import');

=cut

sub new {

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

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

    $Self->InitImport();

    return $Self;
}

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

    # check whether the AI web service is enabled and if not, activate it
    my $WebserviceObject = $Kernel::OM->Get('Kernel::System::GenericInterface::Webservice');

    my $AIWebservice = $WebserviceObject->WebserviceGet(
        Name => 'OTOBO-AI',
    );

    if ( !$AIWebservice ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "OTOBO-AI webservice not found!",
        );
        return 0;
    }

    # Set the webservice id
    $Self->{WebserviceID} = $AIWebservice->{ID};

    if ( $AIWebservice->{ValidID} != 1 ) {

        return 0;
    }

    # fetch config
    my $StripSignatureRegEx = $Kernel::OM->Get('Kernel::Config')->Get('OTOBOAI::StripSignatureRegex');
    if ($StripSignatureRegEx) {

        my $Regex = qr/$StripSignatureRegEx/m;
        $Self->{StripSignatureRegEx} = $Regex;
    }

    return 1;
}

=head2 MigrateTickets()

Synchronize the OTOBO-AI vector DB with the updated states of one or more Tickets for one or more use-cases.

returns 1 if successful or undef otherwise

    my $Success = $Object->MigrateTickets(
        TicketID => 123,                        # optional, consider only this ticket for migration
        UseCases => [                           # optional, consider only these use-cases for migration
            'default',
            'sales',
        ],
        Sample       => '/home/sample.json',    # optional, file path or directory to write a sample.json containing TicketIDs to sample
        SampleNth    => 10,                     # optional, sample size (default: 10)
        Reference    => '/home/sample.json',    # optional, path to an existing sample.json containing TicketIDs to reference
        Asynchronous => 0,                      # optional, do not manually set this, unless you are explicitly
                                                # running the Requester in an asynchronous context (default: 0)
        Console      => $ConsoleObject,         # optional, give realtime status updates on the migration process (assumes print to STDOUT)
    );

=cut

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

    return if $Self->InitImport() == 0;

    my $UseCases     = $Param{UseCases};
    my $Sample       = $Param{Sample};
    my $SampleNth    = $Param{SampleNth} || 10;
    my $Reference    = $Param{Reference};
    my $Asynchronous = $Param{Asynchronous};
    my $Console      = $Param{Console} && $Param{Console}->can('Print') ? $Param{Console} : undef;

    my $BatchSize = 100;

    # handle sample option for console command
    if ($Sample) {

        my $FullPath = $Sample;

        if ( -d $Sample ) {
            $FullPath .= "/sample.json";
        }

        $Self->{SamplePath} = $FullPath;

        my $SampleDir = dirname($FullPath);
        if ( !-d $SampleDir ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "do-sample parameter needs a valid path to an output file, but parent path " . $SampleDir . " does not exist.",
            );
            die;
        }
    }

    if ( $Reference && -e $Reference ) {

        my $RefIDsJSON = file($Reference)->slurp;
        $Self->{RefIDs} = from_json($RefIDsJSON);
    }

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

    my $OnlyVisibleForCustomer    = $Kernel::OM->Get('Kernel::Config')->Get('OTOBOAI::OnlyVisibleForCustomer') // 1;
    my $AllowedArticleSenderTypes = $Kernel::OM->Get('Kernel::Config')->Get('OTOBOAI::AllowedArticleSenderTypes');
    my $SearchRestrictionsHash    = $Kernel::OM->Get('Kernel::Config')->Get('OTOBOAI::Ticket::SearchRestrictions') // {};

    if ($Console) {
        $Console->Print("<green>Ingesting Tickets ...</green>\n");
    }

    my %TicketSample;

    SEARCHRESTRICTION:
    for my $SearchRestrictionsKey ( keys $SearchRestrictionsHash->%* )
    {
        my $SearchRestrictions = dclone( $SearchRestrictionsHash->{$SearchRestrictionsKey} );

        my $IncludeUseCase = 0;
        if ( $UseCases && scalar $UseCases->@* ) {

            $IncludeUseCase = grep { $_ eq $SearchRestrictionsKey } $UseCases->@*;
        }
        else {
            $IncludeUseCase = 1;
        }

        next SEARCHRESTRICTION if $IncludeUseCase == 0;

        my @UseCaseLabels = ( delete $SearchRestrictions->{Label} )->@*;

        if ( !exists $TicketSample{$SearchRestrictionsKey} ) {
            $TicketSample{$SearchRestrictionsKey} = [];
        }

        if ($Console) {
            $Console->Print("<yellow>Use Case: $SearchRestrictionsKey.</yellow>\n");
        }

        # remove search parameters with empty arrays as they prevent search results entirely
        for my $ArrayParam (qw(Queues Services StateTypes Types)) {
            if ( !IsArrayRefWithData( $SearchRestrictions->{$ArrayParam} ) ) {
                delete $SearchRestrictions->{$ArrayParam};
            }
        }

        # fetch all TicketIDs satisfying this search restriction
        my @TicketIDs = $TicketObject->TicketSearch(
            Result     => 'ARRAY',
            Limit      => 100_000_000,
            UserID     => 1,
            Permission => 'ro',
            TicketID   => $Param{TicketID},
            %{$SearchRestrictions},
        );

        my $Errors = 0;
        my $Count  = 0;

        # only required for console command
        my $Handled   = 0;
        my $Imported  = 0;
        my $Percent10 = ( sort { $a <=> $b } ( 10, int( scalar(@TicketIDs) / 10 ) ) )[1];
        my $Percent1  = ( sort { $a <=> $b } ( 1,  int( scalar(@TicketIDs) / 100 ) ) )[1];

        if ($Console) {
            $Console->Print(
                "<yellow>" . ( scalar @TicketIDs ) . " Tickets are considered for transfer. This can take several hours, depending on the number of tickets.</yellow>\n"
            );
        }

        BATCH:
        while ( $Count < scalar @TicketIDs ) {
            my $Until = $Count + $BatchSize - 1;
            if ( $Until > $#TicketIDs ) {
                $Until = $#TicketIDs;
            }
            my @Batch = @TicketIDs[ $Count .. $Until ];

            my @ImportTicketsQA;
            my @ImportTicketsAgentArticles;

            TICKETID:
            for my $TicketID (@Batch) {

                # show progress
                if ($Console) {
                    if ( $Count && $Count % $Percent10 == 0 ) {
                        my $Percent = int( $Count / ( scalar(@TicketIDs) / 100 ) );
                        $Console->Print(
                            "<yellow>$Count</yellow> of <yellow>"
                                . scalar(@TicketIDs)
                                . "</yellow> processed (<yellow>$Percent %</yellow> done. $Handled Tickets handled, $Imported Tickets imported).\n"
                        );
                    }
                    elsif ( scalar(@TicketIDs) > 50 && $Count % $Percent1 == 0 ) {
                        $Console->Print('. ');
                        select()->flush();    # show the dot immediately, beware this assumes ConsoleObject prints to STDOUT
                    }
                }

                $Count++;

                my @Articles = $ArticleObject->ArticleList(
                    TicketID => $TicketID,
                );

                if ($Reference) {

                    my $IsPartOfSample = grep { $_ eq "$TicketID" } $Self->{RefIDs}->{$SearchRestrictionsKey}->@*;
                    next TICKETID if ($IsPartOfSample);
                }

                next TICKETID if !@Articles;

                my %SenderLookup = map { $_ => $ArticleObject->ArticleSenderTypeLookup( SenderType => $_ ) } qw/agent customer/;

                # SelectionRule: only consider tickets started by a customer
                next TICKETID if $Articles[0]{SenderTypeID} ne $SenderLookup{customer};

                my $QuestionArticle = shift @Articles;
                my @AnswerArticles;

                if ($Sample) {

                    # keep 10% sample of tickets for testing and do NOT import them

                    if ( $Handled % $SampleNth == 0 ) {

                        $Handled++;
                        push $TicketSample{$SearchRestrictionsKey}->@*, $TicketID;
                        next TICKETID;
                    }
                }

                ARTICLE:
                for my $Article (@Articles) {

                    # SelectionRule: skip tickets where the customer sent info twice without any agent interference
                    next TICKETID if $Article->{SenderTypeID} eq $SenderLookup{customer} && !@AnswerArticles;

                    # SelectionRule: skip articles if they are not customer visible
                    if ($OnlyVisibleForCustomer) {
                        next ARTICLE if $Article->{IsVisibleForCustomer} ne 1;
                    }

                    # SelectionRule: skip articles if their sendertype is not on the whitelist (if enabled)
                    if ($AllowedArticleSenderTypes) {
                        my $Allowed = 0;
                        TYPES:
                        for my $Type ( $AllowedArticleSenderTypes->@* ) {
                            if ( $SenderLookup{$Type} == $Article->{SenderTypeID} ) {
                                $Allowed = 1;
                                last TYPES;
                            }
                        }
                        if ( !$Allowed ) {
                            next ARTICLE;
                        }
                    }

                    push @AnswerArticles, $Article;
                }

                next TICKETID if !@AnswerArticles;

                {
                    my $ArticleBackend = $ArticleObject->BackendForArticle(
                        TicketID  => $TicketID,
                        ArticleID => $QuestionArticle->{ArticleID},
                    );

                    my %Article = $ArticleBackend->ArticleGet(
                        TicketID  => $TicketID,
                        ArticleID => $QuestionArticle->{ArticleID},
                    );

                    next TICKETID if !$Article{Body};

                    $QuestionArticle = \%Article;
                }

                my @AnswerArticlesWithBody;

                ANSWER:
                for my $i ( 0 .. $#AnswerArticles ) {
                    my $ArticleBackend = $ArticleObject->BackendForArticle(
                        TicketID  => $TicketID,
                        ArticleID => $AnswerArticles[$i]{ArticleID},
                    );

                    my %Article = $ArticleBackend->ArticleGet(
                        TicketID  => $TicketID,
                        ArticleID => $AnswerArticles[$i]{ArticleID},
                    );

                    next ANSWER if !$Article{Body};

                    # SelectionRule: Remove citations from agent articles
                    $Article{Body} =~ s/^\s*>.+?$//msg;

                    push @AnswerArticlesWithBody, \%Article;
                }

                next TICKETID if !@AnswerArticlesWithBody;

                $Handled++;
                $Imported++;

                my $QuestionSubject = $QuestionArticle->{Subject}         // '';
                my $QuestionBody    = $QuestionArticle->{Body}            // '';
                my $AnswerSubject   = $AnswerArticlesWithBody[0]{Subject} // '';
                my $AnswerBody      = $AnswerArticlesWithBody[0]{Body};

                $QuestionBody = $Self->StripSignature( Body => $QuestionBody );
                $AnswerBody   = $Self->StripSignature( Body => $AnswerBody );

                my $ImportQATicket = {
                    "source_id"     => "$TicketID",
                    "content_items" => [
                        {
                            type => 'question',
                            text => $QuestionSubject . '. ' . $QuestionBody,
                        },
                        {
                            type => 'answer',
                            text => $AnswerSubject . '. ' . $AnswerBody,
                        },
                    ]
                };

                $ImportQATicket->{labels} = \@UseCaseLabels;

                push @ImportTicketsQA, $ImportQATicket;

                my @ContentItems;
                for my $AnswerArticleWithBody (@AnswerArticlesWithBody) {

                    my $Subject = $AnswerArticleWithBody->{Subject} // '';
                    my $Body    = $AnswerArticleWithBody->{Body}    // '';

                    $Body = $Self->StripSignature( Body => $Body );
                    push @ContentItems, {
                        type => 'text',
                        text => $Subject . '. ' . $Body,
                    };
                }

                my $ImportAgentArticles = {
                    "source_id"     => "$TicketID",
                    "content_items" => \@ContentItems,
                };

                $ImportAgentArticles->{labels} = \@UseCaseLabels;

                push @ImportTicketsAgentArticles, $ImportAgentArticles;
            }

            my $Result;
            if (@ImportTicketsQA) {

                # Ingest Q/A articles
                $Result = $RequesterObject->Run(
                    WebserviceID => $Self->{WebserviceID},
                    Invoker      => 'IngestMany',
                    Asynchronous => $Asynchronous,
                    Data         => {
                        Type    => 'ticket_pairs',      # currently supported: faq, documentation, ticket_pairs, ticket_chunks
                        Content => \@ImportTicketsQA,
                    },
                );

                if ( !$Result->{Success} ) {
                    $Errors++;

                    my $SourceIDs = join( ',', map { $_->{source_id} } @ImportTicketsQA );

                    $Kernel::OM->Get('Kernel::System::Log')->Log(
                        Priority => 'error',
                        Message  => "Failed to ingest Q/A article pairs of TicketID(s) $SourceIDs: " . $Result->{ErrorMessage},
                    );

                    if ($Console) {
                        $Console->Print( "<red>Error importing TicketID(s) $SourceIDs: " . $Result->{ErrorMessage} . "</red>\n" );
                    }
                }
            }

            if (@ImportTicketsAgentArticles) {

                # Ingest agent articles
                $Result = $RequesterObject->Run(
                    WebserviceID => $Self->{WebserviceID},
                    Invoker      => 'IngestMany',
                    Asynchronous => $Asynchronous,
                    Data         => {
                        Type    => 'ticket_chunks',
                        Content => \@ImportTicketsAgentArticles,
                    },
                );

                if ( !$Result->{Success} ) {
                    $Errors++;

                    my $SourceIDs = join( ',', map { $_->{source_id} } @ImportTicketsQA );

                    $Kernel::OM->Get('Kernel::System::Log')->Log(
                        Priority => 'error',
                        Message  => "Failed to ingest agent articles of TicketID(s) $SourceIDs: " . $Result->{ErrorMessage},
                    );

                    if ($Console) {
                        $Console->Print( "<red>Error importing TicketID(s) $SourceIDs: " . $Result->{ErrorMessage} . "</red>\n" );
                    }
                }
            }
        }

        if ($Errors) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => 'Ticket transfer complete. ' . $Errors . ' error(s) occurred!',
            );

            if ($Console) {
                $Console->Print("<yellow>Ticket transfer complete. $Errors error(s) occurred!</yellow>\n");
            }
        }
        else {
            if ($Console) {
                $Console->Print("<green>Ticket transfer complete. Considered $Count tickets, of wich $Imported where imported.</green>\n");
            }
        }
    }

    if ($Sample) {

        my $JSON = encode_json( \%TicketSample );
        file( $Self->{SamplePath} )->spew($JSON);
    }

    return 1;
}

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

    # let the requester know it is run in an asynchronous context
    $Param{Asynchronous} = 1;

    $Kernel::OM->Get('Kernel::System::Log')->Log(
        Priority => 'debug',
        Message  => "OtoboAI::Import::MigrateTicketsAsync call initiated.",
    );

    my $Success = $Self->AsyncCall(
        ObjectName               => 'Kernel::System::OtoboAI::Import',
        FunctionName             => 'MigrateTickets',
        FunctionParams           => \%Param,
        Attempts                 => 1,
        MaximumParallelInstances => 0,
    );

    if ( !$Success ) {

        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Initialize async call failed!",
        );
        return;
    }

    return 1;
}

=head2 MigrateFAQs()

Synchronize the OTOBO-AI vector DB with the updated states of one or more FAQ items for one or more use-cases.

returns 1 if successful or undef otherwise

    my $Success = $Object->MigrateFAQs(
        FAQID    => 123,                   # optional, consider only this FAQ item for migration
        UseCases => [                      # optional, consider only these use-cases for migration
            'default',
            'sales',
        ],
        Asynchronous => 0,                 # optional, do not manually set this, unless you are explicitly
                                           # running the Requester in an asynchronous context (default: 0)
        Console      => $ConsoleObject,    # optional, give realtime status updates on the migration process (assumes print to STDOUT)
    );

=cut

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

    return if $Self->InitImport() == 0;

    my $UseCases     = $Param{UseCases};
    my $Asynchronous = $Param{Asynchronous};
    my $Console      = $Param{Console} && $Param{Console}->can('Print') ? $Param{Console} : undef;

    # check whether FAQ package is installed
    my $PackageObject = $Kernel::OM->Get('Kernel::System::Package');
    my $IsInstalled   = $PackageObject->PackageIsInstalled(
        Name => 'FAQ',
    );
    if ( !$IsInstalled ) {
        if ($Console) {
            $Console->Print("<yellow>Skipping FAQ articles (FAQ not installed)...</yellow>\n");
        }

        return 1;
    }

    if ($Console) {
        $Console->Print("<green>Ingesting FAQs ...</green>\n");
    }

    # prepare the import
    my $FAQObject       = $Kernel::OM->Get('Kernel::System::FAQ');
    my $RequesterObject = $Kernel::OM->Get('Kernel::GenericInterface::Requester');
    my $HTMLUtilsObject = $Kernel::OM->Get('Kernel::System::HTMLUtils');

    # determine search restrictions for FAQSearch
    my $SearchRestrictionsHash = $Kernel::OM->Get('Kernel::Config')->Get('OTOBOAI::FAQ::SearchRestrictions') // {};

    SEARCHRESTRICTION:
    for my $SearchRestrictionsKey ( keys $SearchRestrictionsHash->%* )
    {
        my $SearchRestrictions = dclone( $SearchRestrictionsHash->{$SearchRestrictionsKey} );
        my @UseCaseLabels      = ( delete $SearchRestrictions->{Label} )->@*;

        my $IncludeUseCase = 0;
        if ( $UseCases && scalar $UseCases->@* ) {

            $IncludeUseCase = grep { $_ eq $SearchRestrictionsKey } $UseCases->@*;
        }
        else {
            $IncludeUseCase = 1;
        }

        next SEARCHRESTRICTION if $IncludeUseCase == 0;

        if ($Console) {
            $Console->Print("<yellow>Use Case: $SearchRestrictionsKey</yellow>\n");
        }

        # fetch all FAQIDs satisfying this search restriction
        my @FAQIDs = $FAQObject->FAQSearch(
            Limit      => 100_000_000,
            UserID     => 1,
            Permission => 'ro',
            FAQID      => $Param{FAQID},
            %{$SearchRestrictions},
        );

        # iterate over the faqs
        my $Count     = 0;
        my $Percent10 = ( sort { $a <=> $b } ( 10, int( scalar(@FAQIDs) / 10 ) ) )[1];
        my $Percent1  = ( sort { $a <=> $b } ( 1,  int( scalar(@FAQIDs) / 100 ) ) )[1];

        if ( scalar(@FAQIDs) > 100 && $Console ) {
            $Console->Print("<yellow>FAQ article are transferred. This can take several hours, depending on the number of faq article.</yellow>\n");
        }

        my $Errors = 0;
        my @FAQData;

        FAQID:
        for my $FAQID (@FAQIDs) {

            $Count++;

            my %FAQ = $FAQObject->FAQGet(
                ItemID        => $FAQID,
                ItemFields    => 1,        # Optional, default 0. To include the item field content for this
                                           # FAQ item on the return structure.
                DynamicFields => 0,        # Optional, default 0. To include the dynamic fields for this
                                           # FAQ item on the return structure.
                UserID        => 1,
            );

            # scrub HTML
            my $Question = $HTMLUtilsObject->ToAscii( String => $FAQ{Title} // '' )
                . ". " . $HTMLUtilsObject->ToAscii( String => $FAQ{Field1} // '' )
                . ". " . $HTMLUtilsObject->ToAscii( String => $FAQ{Field2} // '' );

            my $Answer = $HTMLUtilsObject->ToAscii( String => $FAQ{Field3} // '' );

            # prepare data item for invoker

            my $Data = {
                "source_id"     => "$FAQID",
                "content_items" => [
                    {
                        type => 'question',
                        text => $Question,
                    },
                    {
                        type => 'answer',
                        text => $Answer,
                    }
                ]
            };

            $Data->{labels} = \@UseCaseLabels;

            push @FAQData, $Data;

            # batches of 10 FAQs
            if ( $Count % 10 == 0 ) {

                # ingest
                my $Result = $RequesterObject->Run(
                    WebserviceID => $Self->{WebserviceID},
                    Invoker      => 'IngestMany',
                    Asynchronous => $Asynchronous,
                    Data         => {
                        Type    => 'faqs',
                        Content => \@FAQData,
                    },
                );

                if ( !$Result->{Success} ) {
                    $Errors++;

                    $Kernel::OM->Get('Kernel::System::Log')->Log(
                        Priority => 'error',
                        Message  => "Error importing FAQs: " . $Result->{ErrorMessage},
                    );

                    if ($Console) {
                        $Console->Print( "<red>Error importing FAQs: " . $Result->{ErrorMessage} . "</red>\n" );
                    }
                }

                @FAQData = ();
            }

            # show progress and potentially sleep
            if ($Console) {
                if ( $Count % $Percent10 == 0 ) {
                    my $Percent = int( $Count / ( scalar(@FAQIDs) / 100 ) );
                    $Console->Print(
                        "<yellow>$Count</yellow> of <yellow>"
                            . scalar(@FAQIDs)
                            . "</yellow> processed (<yellow>$Percent %</yellow> done).\n"
                    );
                }
                elsif ( scalar(@FAQIDs) > 50 && $Count % $Percent1 == 0 ) {
                    $Console->Print('. ');
                    select()->flush();    # show the dot immediately, beware this assumes ConsoleObject prints to STDOUT
                }
            }
        }

        # ingest leftovers
        if (@FAQData) {

            my $Result = $RequesterObject->Run(
                WebserviceID => $Self->{WebserviceID},
                Invoker      => 'IngestMany',
                Asynchronous => $Asynchronous,
                Data         => {
                    Type    => 'faqs',
                    Content => \@FAQData,
                },
            );

            if ( !$Result->{Success} ) {
                $Errors++;

                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => "Error importing FAQs: " . $Result->{ErrorMessage},
                );

                if ($Console) {
                    $Console->Print( "<red>Error importing FAQs: " . $Result->{ErrorMessage} . "</red>\n" );
                }
            }
        }

        if ($Errors) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => 'FAQ transfer complete. ' . $Errors . ' error(s) occurred!',
            );

            if ($Console) {
                $Console->Print("<yellow>FAQ transfer complete. $Errors error(s) occurred!</yellow>\n");
            }
        }
        else {
            if ($Console) {
                $Console->Print("<green>FAQ transfer complete. Imported $Count FAQ items.</green>\n");
            }
        }
    }
    return 1;
}

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

    # let the requester know it is run in an asynchronous context
    $Param{Asynchronous} = 1;

    $Kernel::OM->Get('Kernel::System::Log')->Log(
        Priority => 'debug',
        Message  => "OtoboAI::Import::MigrateFAQsAsync call initiated.",
    );

    my $Success = $Self->AsyncCall(
        ObjectName               => 'Kernel::System::OtoboAI::Import',
        FunctionName             => 'MigrateFAQs',
        FunctionParams           => \%Param,
        Attempts                 => 1,
        MaximumParallelInstances => 0,
    );

    if ( !$Success ) {

        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Initialize async call failed!",
        );
        return;
    }

    return 1;
}

=head2 MigrateDocs()

Synchronize the OTOBO-AI vector DB with one or more documents for one or more use-cases.

returns 1 if successful or undef otherwise

    my $Success = $Object->MigrateDocs(
        UseCases => [                      # optional, consider only these use-cases for migration
            'default',
            'sales',
        ],
        Asynchronous => 0,                 # optional, do not manually set this, unless you are explicitly
                                           # running the Requester in an asynchronous context (default: 0)
        Console      => $ConsoleObject,    # optional, give realtime status updates on the migration process (assumes print to STDOUT)
    );

=cut

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

    return if $Self->InitImport() == 0;

    my $UseCases     = $Param{UseCases};
    my $Asynchronous = $Param{Asynchronous};
    my $BatchSize    = $Param{BatchSize};
    my $Console      = $Param{Console} && $Param{Console}->can('Print') ? $Param{Console} : undef;

    if ($Console) {
        $Console->Print("<green>Ingesting Documents ...</green>\n");
    }

    # prepare the import
    my $RequesterObject = $Kernel::OM->Get('Kernel::GenericInterface::Requester');

    # determine search restrictions for document search
    my $SearchRestrictionsHash = $Kernel::OM->Get('Kernel::Config')->Get('OTOBOAI::Document::SearchRestrictions') // {};

    SEARCHRESTRICTION:
    for my $SearchRestrictionsKey ( keys $SearchRestrictionsHash->%* )
    {
        my $SearchRestrictions = dclone( $SearchRestrictionsHash->{$SearchRestrictionsKey} );
        my @UseCaseLabels      = ( delete $SearchRestrictions->{Label} )->@*;

        my $IncludeUseCase = 0;
        if ( $UseCases && scalar $UseCases->@* ) {

            $IncludeUseCase = grep { $_ eq $SearchRestrictionsKey } $UseCases->@*;
        }
        else {
            $IncludeUseCase = 1;
        }

        next SEARCHRESTRICTION if $IncludeUseCase == 0;

        if ($Console) {
            $Console->Print("<yellow>Use Case: $SearchRestrictionsKey</yellow>\n");
        }

        my $DocumentPaths = $Self->_DocumentSearch(
            %$SearchRestrictions,
            Console => $Console,
        );

        my @Content;
        my $Count  = 0;
        my $Errors = 0;
        my $Batch  = 1;

        DOCUMENT:
        for my $DocumentPath (@$DocumentPaths) {

            $Count++;

            # slurp content of file
            my $FileContent = file($DocumentPath)->slurp( iomode => '<:encoding(UTF-8)' ) // '';

            my $Data = {
                "source_id"     => "$DocumentPath",
                "content_items" => [
                    {
                        type => 'text',
                        text => $FileContent,
                    }
                ]
            };

            $Data->{labels} = \@UseCaseLabels;

            push @Content, $Data;

            # ingest in batches of 10
            if ( $Count >= ( $BatchSize * $Batch ) ) {

                $Batch = $Batch + 1;

                # ingest
                my $Result = $RequesterObject->Run(
                    WebserviceID => $Self->{WebserviceID},
                    Invoker      => 'IngestMany',
                    Asynchronous => $Asynchronous,
                    Data         => {
                        Type    => 'docs',
                        Content => \@Content,
                    },
                );

                if ( !$Result->{Success} ) {
                    $Errors++;

                    $Kernel::OM->Get('Kernel::System::Log')->Log(
                        Priority => 'error',
                        Message  => "Error importing Document '$DocumentPath': " . $Result->{ErrorMessage},
                    );

                    if ($Console) {
                        $Console->Print( "<red>Error importing Document '$DocumentPath': " . $Result->{ErrorMessage} . "</red>\n" );
                    }
                }

                @Content = ();
            }
        }

        # ingest leftovers
        if (@Content) {

            my $Result = $RequesterObject->Run(
                WebserviceID => $Self->{WebserviceID},
                Invoker      => 'IngestMany',
                Asynchronous => $Asynchronous,
                Data         => {
                    Type    => 'docs',
                    Content => \@Content,
                },
            );

            if ( !$Result->{Success} ) {
                $Errors++;

                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => 'Error importing Documents: ' . $Result->{ErrorMessage},
                );

                if ($Console) {
                    $Console->Print( "<red>Error importing Documents: " . $Result->{ErrorMessage} . "</red>\n" );
                }
            }
        }

        if ($Errors) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => 'Document transfer complete. ' . $Errors . ' error(s) occurred!',
            );

            if ($Console) {
                $Console->Print("<yellow>Document transfer complete. $Errors error(s) occurred!</yellow>\n");
            }
        }
        else {
            if ($Console) {
                $Console->Print("<green>Document transfer complete. Transferred $Count Document items.</green>\n");
            }
        }
    }
    return 1;
}

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

    # let the requester know it is run in an asynchronous context
    $Param{Asynchronous} = 1;

    $Kernel::OM->Get('Kernel::System::Log')->Log(
        Priority => 'debug',
        Message  => "OtoboAI::Import::MigrateDocsAsync call initiated.",
    );

    my $Success = $Self->AsyncCall(
        ObjectName               => 'Kernel::System::OtoboAI::Import',
        FunctionName             => 'MigrateDocs',
        FunctionParams           => \%Param,
        Attempts                 => 1,
        MaximumParallelInstances => 0,
    );

    if ( !$Success ) {

        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Initialize async call failed!",
        );
        return;
    }

    return 1;
}

=head2 PurgeTickets()

Purges the OTOBO-AI vector DB of one or more Tickets.

returns 1 if at least one entry has been purged

    my $Success = $Object->PurgeTickets(
        TicketID => 123,    # optional, purge only this ticket
    );

=cut

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

    $Self->InitImport();

    my $ResultPairs = $Self->_Purge(
        Collection => 'ticket_pairs',
        SourceID   => $Param{TicketID}
    );
    my $ResultChunks = $Self->_Purge(
        Collection => 'ticket_chunks',
        SourceID   => $Param{TicketID}
    );

    return $ResultPairs || $ResultChunks;
}

=head2 PurgeFAQs()

Purges the OTOBO-AI vector DB of one or more FAQ items.

returns 1 if at least one entry has been purged

    my $Success = $Object->PurgeFAQs(
        FAQID => 123,    # optional, purge only this FAQ item
    );

=cut

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

    $Self->InitImport();

    return $Self->_Purge(
        Collection => 'faqs',
        SourceID   => $Param{FAQID},
    );
}

=head2 PurgeDocs()

Purges the OTOBO-AI vector DB of all Document items.

returns 1 if at least one entry has been purged

    my $Success = $Object->PurgeDocs();

=cut

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

    $Self->InitImport();

    return $Self->_Purge( Collection => 'docs' );
}

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

    my $RequesterObject = $Kernel::OM->Get('Kernel::GenericInterface::Requester');

    my $Result;

    if ( $Param{SourceID} ) {

        $Result = $RequesterObject->Run(
            WebserviceID => $Self->{WebserviceID},
            Invoker      => 'DeleteByID',
            Asynchronous => 0,
            Data         => {
                type       => $Param{Collection},
                source_ids => ["$Param{SourceID}"],
            }
        );
    }
    else {

        $Result = $RequesterObject->Run(
            WebserviceID => $Self->{WebserviceID},
            Invoker      => 'Purge',
            Asynchronous => 0,
            Data         => {
                Collection => $Param{Collection}
            }
        );
    }

    return IsHashRefWithData($Result)        &&
        $Result->{Success}                   &&
        IsHashRefWithData( $Result->{Data} ) &&
        $Result->{Data}{success};
}

sub _DocumentSearch {

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

    my $DocumentRoot  = $Param{DocumentPath};
    my $NewerThanDays = $Param{NewerThanDays};
    my $Console       = $Param{Console};

    if ( !-d $DocumentRoot ) {
        if ($Console) {
            $Console->Print("<yellow>Skipping Documents (Document folder '$DocumentRoot' does not exist)...</yellow>\n");
        }
        return;
    }

    my $SecondsPerDay = 60 * 60 * 24;

    # glob files recursively starting in $DocumentRoot
    my @Files;
    find(
        {
            wanted => sub {

                # only handle files, not directories
                if ( !-d $_ ) {

                    if ($NewerThanDays) {

                        # last write time stamp
                        my ($WriteTime) = ( stat($_) )[9];

                        # if last write time is NewerThanDays
                        if ( ( time() - $WriteTime ) < ( $NewerThanDays * $SecondsPerDay ) ) {

                            # add this file to result set
                            push @Files, $_;
                        }
                    }
                    else {
                        # add this file to result set
                        push @Files, $_;
                    }
                }
            },
            no_chdir => 1
        },
        $DocumentRoot
    );

    return \@Files;
}

sub StripSignature {

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

    my $Body = $Param{Body};

    my $RegEx = $Self->{StripSignatureRegEx};
    return $Body if ( !$RegEx );

    if ( $Body =~ /$RegEx/ ) {

        return substr( $Body, 0, $-[0] );
    }
    else {

        return $Body;
    }
}

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/
# --
# 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::DynamicField::Driver::TextAreaAI;

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

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

use parent qw(Kernel::System::DynamicField::Driver::TextArea);

# core modules

# CPAN modules

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

our @ObjectDependencies = ();

=head1 NAME

Kernel::System::DynamicField::Driver::TextAreaAI - driver for the TextAreaAI dynamic field

=head1 DESCRIPTION

DynamicFields TextAreaAI Driver delegate

=head1 PUBLIC INTERFACE

This module implements the public interface of L<Kernel::System::DynamicField::Backend>.
Please look there for a detailed reference of the functions.

=head2 new()

usually, you want to create an instance of this
by using Kernel::System::DynamicField::Backend->new();

=cut

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

    # Call constructor of the base class.
    my $Self = $Type->SUPER::new;

    # Settings that are specific to the TextAreaAI dynamic field
    $Self->{Behaviors}{IsCustomerInterfaceCapable} = 0;
    $Self->{Behaviors}{IsSetCapable}               = 0;
    $Self->{Behaviors}{IsStatsCondition}           = 0;

    return $Self;
}

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

    if ( !$Param{DoWrite} ) {
        return 1;
    }

    return $Self->SUPER::ValueSet(%Param);
}

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

    # this field is intended to be readonly and therefor must never have an EditFieldValue
    return;
}

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

    # take config from field config
    my $FieldConfig = $Param{DynamicFieldConfig}{Config};
    my $FieldName   = 'DynamicField_' . $Param{DynamicFieldConfig}{Name};
    my $FieldLabel  = $Param{DynamicFieldConfig}{Label};

    my $Value = '';

    # set the field value or default
    if ( $Param{UseDefaultValue} ) {
        $Value = $FieldConfig->{DefaultValue} // '';
    }
    $Value = $Param{Value} // $Value;

    # extract the dynamic field value from the web request
    my $FieldValue = $Self->EditFieldValueGet(
        %Param,
    );

    if ( defined $FieldValue ) {
        $Value = $FieldValue;
    }

    if ( !ref $Value ) {
        $Value = [$Value];
    }
    elsif ( !$Value->@* ) {
        $Value = [undef];
    }

    # set the rows number
    my $RowsNumber = defined $FieldConfig->{Rows} && $FieldConfig->{Rows} ? $FieldConfig->{Rows} : '7';

    # set the cols number
    my $ColsNumber = defined $FieldConfig->{Cols} && $FieldConfig->{Cols} ? $FieldConfig->{Cols} : '42';

    # check and set class if necessary
    my $FieldClass = 'DynamicFieldTextArea';
    if ( defined $Param{Class} && $Param{Class} ne '' ) {
        $FieldClass .= ' ' . $Param{Class};
    }

    # set classes according to mandatory and acl hidden params
    if ( $Param{ACLHidden} && $Param{Mandatory} ) {
        $FieldClass .= ' Validate_Required_IfVisible';
    }
    elsif ( $Param{Mandatory} ) {
        $FieldClass .= ' Validate_Required';
    }

    # set error css class
    if ( $Param{ServerError} ) {
        $FieldClass .= ' ServerError';
    }

    # set validation class for maximum characters
    $FieldClass .= ' Validate_MaxLength';

    my $FieldLabelEscaped = $Param{LayoutObject}->Ascii2Html(
        Text => $Param{LayoutObject}{LanguageObject}->Translate($FieldLabel),
    );

    # create field HTML
    # the XHTML definition does not support maxlength attribute for a text-area field,
    # we use data-maxlength instead
    # Notice that some browsers count new lines \n\r as only 1 character. In these cases the
    # validation framework might generate an error while the user is still capable to enter text in the
    # text-area. Otherwise the maxlength property will prevent to enter more text than the maximum.
    my $MaxLength = $Param{MaxLength} // $Self->{MaxLength};

    my $ErrorMessage1 = $Param{LayoutObject}{LanguageObject}->Translate("This field is required or");
    my $ErrorMessage2 = $Param{LayoutObject}{LanguageObject}->Translate("The field content is too long!");
    my $ErrorMessage3 = $Param{LayoutObject}{LanguageObject}->Translate( "Maximum size is %s characters.", $MaxLength );

    my %FieldTemplateData = (
        FieldClass        => $FieldClass,
        FieldName         => $FieldName,
        FieldLabelEscaped => $FieldLabelEscaped,
        Readonly          => $Param{Readonly},
        RowsNumber        => $RowsNumber,
        ColsNumber        => $ColsNumber,
        MaxLength         => $MaxLength,
        ErrorMessage1     => $ErrorMessage1,
        ErrorMessage2     => $ErrorMessage2,
        ErrorMessage3     => $ErrorMessage3,
        DivID             => $FieldName . 'Error',
    );

    my $FieldTemplateFile = 'DynamicField/Agent/TextArea';

    my %Error = (
        ServerError => $Param{ServerError},
        Mandatory   => $Param{Mandatory},
    );
    my @ResultHTML;
    for my $ValueIndex ( 0 .. $#{$Value} ) {
        $FieldTemplateData{FieldID}      = $FieldConfig->{MultiValue} ? $FieldName . '_' . $ValueIndex : $FieldName;
        $FieldTemplateData{ValueEscaped} = $Param{LayoutObject}->Ascii2Html(
            Text => $Value->[$ValueIndex],
        );

        if ( !$ValueIndex ) {
            if ( $Error{ServerError} ) {
                $Error{DivIDServerError} = $FieldTemplateData{FieldID} . 'ServerError';
                $Error{ErrorMessage}     = Translatable( $Param{ErrorMessage} || 'This field is required.' );
            }
            if ( $Error{Mandatory} ) {
                $Error{DivIDMandatory}       = $FieldTemplateData{FieldID} . 'Error';
                $Error{FieldRequiredMessage} = Translatable('This field is required.');
            }
        }

        push @ResultHTML, $Param{LayoutObject}->Output(
            TemplateFile => $FieldTemplateFile,
            Data         => {
                %FieldTemplateData,
                %Error,
            },
        );
    }

    # call EditLabelRender on the common Driver
    my $LabelString = $Self->EditLabelRender(
        %Param,
        Mandatory => $Param{Mandatory} || '0',
        FieldName => $FieldName,
    );

    my $Data = {
        Label => $LabelString,
        Field => $ResultHTML[0],
    };

    return $Data;
}

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

    return ();
}

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-2026 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::Console::Command::Maint::AI::Scoring;

use strict;
use warnings;

use Path::Class qw(file);
use File::Find  qw(find);
use LWP::UserAgent;
use File::Basename        qw(basename dirname);
use HTTP::Request::Common qw{ POST };
use JSON;

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

use parent qw(Kernel::System::Console::BaseCommand);

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

# Inform the object manager about the hard dependencies.
# This module must be discarded when one of the hard dependencies has been discarded.
our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::GenericInterface::Requester',
    'Kernel::System::GenericInterface::Webservice',
    'Kernel::System::Ticket',
    'Kernel::System::Ticket::Article',
    'Kernel::System::OtoboAI',
);

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

    $Self->{TicketSample} = [];

    $Self->Description('Do a quality evaluation and write the coring result into a file');
    $Self->AddOption(
        Name        => 'sample',
        Description =>
            "Specify wfile path to sample.json file with the TicketIDs to sample. This file can be produced by the 'Maint::AI::Import' console command using the --sample option.",
        Required   => 0,
        HasValue   => 1,
        ValueRegex => qr/.*/smx,
    );
    $Self->AddOption(
        Name        => 'result',
        Description =>
            "Specify the file path for the scoring output should be written to in CSV (tab separated) format.",
        Required   => 0,
        HasValue   => 1,
        ValueRegex => qr/.*/smx,
    );
    $Self->AddOption(
        Name        => 'json',
        Description =>
            "when scoring, report verbosely for each ticket processed in the specified JSON file.",
        Required   => 0,
        HasValue   => 1,
        ValueRegex => qr/.*/smx,
    );
    $Self->AddOption(
        Name        => 'limit',
        Description =>
            "when scoring, max number of ticket ids to take from sample.",
        Required => 0,
        HasValue => 1,

        ValueRegex => qr/^[0-9]+$/smx,
    );
    $Self->AddOption(
        Name        => 'use-case',
        Description =>
            "Use case to use for sampling. Defaults to 'Default'.",
        Required   => 0,
        HasValue   => 1,
        ValueRegex => qr/.*/smx,
    );

    return;
}

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

    my $Sample = $Self->GetOption('sample');
    if ($Sample) {

        if ( !-e $Sample ) {
            $Self->Print("<red>sample parameter needs a valid path to a sample.json file containing TicketIDs.</red>\n");
            die;
        }
    }

    return;
}

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

    # check whether the AI web service is enabled and if not, activate it
    my $WebserviceObject = $Kernel::OM->Get('Kernel::System::GenericInterface::Webservice');

    my $AIWebservice = $WebserviceObject->WebserviceGet(
        Name => 'OTOBO-AI',
    );

    if ( !$AIWebservice ) {
        $Self->Print("<red>OTOBO-AI webservice not found! Unable to continue.</red>\n");
        die;
    }

    # Set the webservice id
    $Self->{WebserviceID} = $AIWebservice->{ID};

    if ( $AIWebservice->{ValidID} != 1 ) {
        $Self->Print("<red>OTOBO-AI webservice not active! Unable to continue.</red>\n");
        die;
    }

    my $Sample     = $Self->GetOption('sample');
    my $Output     = $Self->GetOption('result') || 10;
    my $JSONOutput = $Self->GetOption('json');
    my $Limit      = $Self->GetOption('limit');
    my $UseCase    = $Self->GetOption('use-case') // 'Default';

    my $JSON            = file($Sample)->slurp();
    my $SampleTicketIDs = decode_json($JSON);

    $Self->DoScoring(
        SampleTicketIDs => $SampleTicketIDs,
        OutputFile      => $Output,
        JSONOutput      => $JSONOutput,
        Limit           => $Limit || scalar $SampleTicketIDs->{$UseCase}->@*,
        UseCase         => $UseCase,
    );

    return $Self->ExitCodeOk();
}

sub DoScoring {

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

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

    my $OutputCSVFileHandle;
    my $SampleTicketIDs = $Param{SampleTicketIDs};
    my $JSONOutput      = $Param{JSONOutput};
    my $Limit           = $Param{Limit};
    my $UseCase         = $Param{UseCase};

    ## no critic(OTOBO::ProhibitOpen InputOutput::RequireBriefOpen)
    open( $OutputCSVFileHandle, '>', $Param{OutputFile} ) || die("failed to open file '$Param{OutputFile}'");

    my $JSONOutputFileHandle;
    if ($JSONOutput) {
        open( $JSONOutputFileHandle, '>', $Param{JSONOutput} ) || die("failed to open file '$Param{JSONOutput}'");
    }

    my $Firstline  = 1;
    my $NumScores  = 0;
    my $SampleSize = scalar $SampleTicketIDs->{$UseCase}->@*;

    my $VerboseJSON = {
        Data => [],
    };

    if ($JSONOutput) {
        $VerboseJSON->{SampleSize} = $SampleSize;
    }

    my $Count = 0;
    TICKETID:
    for my $TicketID ( $SampleTicketIDs->{$UseCase}->@* ) {

        my $VerboseJSONItem = {};

        last TICKETID if ( $Count >= $Limit );
        $Count++;

        my $ArticleID;
        my @Articles = $ArticleObject->ArticleList(
            TicketID   => $TicketID,
            SenderType => 'customer',
            OnlyFirst  => 1,
        );
        if (@Articles) {
            $ArticleID = $Articles[0]{ArticleID};
        }

        if ($ArticleID) {

            $Self->Print("TicketID: $TicketID\n");

            if ($JSONOutput) {

                $VerboseJSONItem->{TicketID} = $TicketID;

                my $ArticleBackendObject = $ArticleObject->BackendForArticle(
                    TicketID  => $TicketID,
                    ArticleID => $ArticleID,
                );

                my %Article = $ArticleBackendObject->ArticleGet(
                    TicketID  => $TicketID,
                    ArticleID => $ArticleID,
                );

                $VerboseJSONItem->{Question} = $Article{Subject} . "\r\n" . $Article{Body};
            }

            my $Result = $OtoboAIObject->GetAnswer(
                ObjectID  => $ArticleID,
                Persist   => 0,
                DoScoring => 1,
            );

            if ( IsHashRefWithData($Result) && $Result->{Success} == 1 ) {
                if ($JSONOutput) {

                    $VerboseJSONItem->{Answer} = $Result->{Data}->{Answer};
                }

                $NumScores++;
                my @LineItems = (
                    $TicketID,
                );

                my $ScoreJSON = $Result->{Data}->{Score};
                my $Scores    = from_json($ScoreJSON);
                my $Reasoning = delete $Scores->{reasoning};

                if ($JSONOutput) {

                    $VerboseJSONItem->{Reasoning} = $Reasoning;
                }

                if ($Firstline) {

                    my @Keys = sort keys $Scores->%*;
                    my $Line = join ";", @Keys;

                    print $OutputCSVFileHandle "TicketID;$Line\r\n";
                    $Firstline = 0;
                }

                for my $Key ( sort keys $Scores->%* ) {

                    my $Score = $Scores->{$Key};

                    $Score =~ s/false/0/i;
                    $Score =~ s/true/1/i;

                    push @LineItems, $Score;

                    if ($JSONOutput) {

                        $VerboseJSONItem->{$Key} = $Score;
                    }
                }

                my $Line = join ";", @LineItems;

                print $OutputCSVFileHandle "$Line\r\n";

                push $VerboseJSON->{Data}->@*, $VerboseJSONItem;
            }
            else {
                $Self->Print( "<red>Error: " . $Result->{Error} . "</red>\n" );
            }
        }
    }

    close($OutputCSVFileHandle);

    if ($JSONOutput) {
        $VerboseJSON->{Scored} = $NumScores;
        print $JSONOutputFileHandle encode_json($VerboseJSON);
        close($JSONOutputFileHandle);
    }

    return;
}

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-2026 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::Ticket::Event::PopulateOTOBOAIDynamicField;

use strict;
use warnings;

# core modules
use List::Util qw(first);

# CPAN modules

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

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::System::DynamicField',
    'Kernel::System::DynamicField::Backend',
    'Kernel::System::Log',
    'Kernel::System::OtoboAI',
    'Kernel::System::Ticket',
    'Kernel::System::Ticket::Article',
    'Kernel::System::GenericInterface::Webservice',
);

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

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

    return $Self;
}

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

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

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

    my $WebserviceObject = $Kernel::OM->Get('Kernel::System::GenericInterface::Webservice');

    my $AIWebservice = $WebserviceObject->WebserviceGet(
        Name => 'OTOBO-AI',
    );

    if ( !$AIWebservice ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "OTOBO-AI webservice not found!",
        );
        return;
    }

    if ( $AIWebservice->{ValidID} != 1 ) {

        return;
    }

    if ( $Param{Event} eq 'TicketQueueUpdate' ) {
        $Self->_PurgeAIDynamicFields( TicketID => $Param{Data}{TicketID} );
    }

    # get necessary objects
    my $ArticleObject = $Kernel::OM->Get('Kernel::System::Ticket::Article');
    my $ConfigObject  = $Kernel::OM->Get('Kernel::Config');

    # handle missing article data by fetching last customer article
    my $ArticleID;
    if ( $Param{Data}{ArticleID} ) {
        $ArticleID = $Param{Data}{ArticleID};
    }
    else {
        my @Articles = $ArticleObject->ArticleList(
            TicketID   => $Param{Data}{TicketID},
            SenderType => 'customer',
            OnlyLast   => 1,
        );
        if (@Articles) {
            $ArticleID = $Articles[0]{ArticleID};
        }
    }

    if ( !$ArticleID ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "No ArticleID in Data and found no customer article!",
        );
        return;
    }

    my %TicketNew = $Kernel::OM->Get('Kernel::System::Ticket')->TicketGet(
        TicketID => $Param{Data}{TicketID},
        UserID   => $Param{UserID},
    );

    # check queue restriction
    if ( IsArrayRefWithData( $Param{Config}{Queues} ) ) {
        return unless first { $_ eq $TicketNew{Queue} } $Param{Config}{Queues}->@*;
    }

    # check sendertype - only auto-populate customer articles
    my %SenderLookup = map {
        $_ => $ArticleObject->ArticleSenderTypeLookup( SenderType => $_ )
    } qw/agent customer system/;

    my $ArticleBackendObject = $ArticleObject->BackendForArticle(
        TicketID  => $Param{Data}{TicketID},
        ArticleID => $ArticleID,
    );

    my %Article = $ArticleBackendObject->ArticleGet(
        TicketID  => $Param{Data}{TicketID},
        ArticleID => $ArticleID,
    );

    return if ( $Article{SenderTypeID} != $SenderLookup{'customer'} );

    # loop protection: only execute this handler once for each article
    my $CacheKey = '_PopulateOTOBOAIDynamicField::AlreadyProcessed';
    return if ( $ArticleObject->{$CacheKey}{$ArticleID} );

    # prepopulate AI dynamic field with default answer
    my $DynamicFieldName = $ConfigObject->Get('OTOBOAI::DynamicFieldOTOBOAI') || 'OTOBOAI';
    my $OTOBOAIDFConfig  = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldGet(
        Name => $DynamicFieldName,
    );
    if ( !IsHashRefWithData($OTOBOAIDFConfig) ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "DynamicField '$DynamicFieldName' not found on the system!",
        );
        return;
    }

    # if a value exists, abort
    #   value either being the placeholder or an actual value
    #   in both cases we do not want to trigger a new request
    my $DynamicFieldBackendObject = $Kernel::OM->Get('Kernel::System::DynamicField::Backend');
    my $CurrentValue              = '';
    my $OverwriteFlag             = $ConfigObject->Get('OTOBOAI::OverwritePreviousResponse') || 0;
    if ( !$OverwriteFlag ) {
        $CurrentValue = $DynamicFieldBackendObject->ValueGet(
            DynamicFieldConfig => $OTOBOAIDFConfig,
            ObjectID           => $ArticleID,
            UserID             => $Param{UserID},
        );
    }

    return if $CurrentValue;

    my $Placeholder = $Kernel::OM->Get('Kernel::Config')->Get('OTOBOAI::Placeholder') || '<|waiting for AI answer|>';
    $Kernel::OM->Get('Kernel::System::DynamicField::Backend')->ValueSet(
        DynamicFieldConfig => $OTOBOAIDFConfig,
        ObjectID           => $ArticleID,
        Value              => $Placeholder,
        DoWrite            => 1,
        UserID             => $Param{UserID},
    );

    # restrict population to RAG mapping setting
    my $QueueToRAGMapping = $ConfigObject->Get('OTOBOAI::QueueToRAGMapping');
    return if ( $QueueToRAGMapping && !$QueueToRAGMapping->{ $TicketNew{Queue} } );

    # trigger asynchronously fetching AI answer
    $Kernel::OM->Get('Kernel::System::OtoboAI')->GetAnswerAsync(
        ObjectID => $ArticleID,
    );

    $ArticleObject->{$CacheKey}{$ArticleID} = 1;

    return 1;
}

sub _PurgeAIDynamicFields {

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

    my $ArticleObject             = $Kernel::OM->Get('Kernel::System::Ticket::Article');
    my $ConfigObject              = $Kernel::OM->Get('Kernel::Config');
    my $DynamicFieldBackendObject = $Kernel::OM->Get('Kernel::System::DynamicField::Backend');

    my @Articles = $ArticleObject->ArticleList(
        TicketID => $Param{TicketID},
    );

    my $DynamicFieldName = $ConfigObject->Get('OTOBOAI::DynamicFieldOTOBOAI') || 'OTOBOAI';
    my $OTOBOAIDFConfig  = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldGet(
        Name => $DynamicFieldName,
    );

    for my $Article (@Articles) {

        my $Success = $DynamicFieldBackendObject->ValueSet(
            DynamicFieldConfig => $OTOBOAIDFConfig,
            ObjectID           => $Article->{ArticleID},
            Value              => undef,
            DoWrite            => 1,
            UserID             => 1,
        );

        if ( !$Success ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Failed to clear OTOBO AI DynamicField for Article $Article->{ArticleID}.",
            );
        }
        else {

            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'debug',
                Message  => "Cleared OTOBO AI DynamicField for Article $Article->{ArticleID}.",
            );
        }
    }

    return;
}

1;
 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 LyogT1RPQk8gaXMgYSB3ZWItYmFzZWQgdGlja2V0aW5nIHN5c3RlbSBmb3Igc2VydmljZSBvcmdhbmlzYXRpb25zLgoKQ29weXJpZ2h0IChDKSAyMDAxLTIwMjAgT1RSUyBBRywgaHR0cHM6Ly9vdHJzLmNvbS8KQ29weXJpZ2h0IChDKSAyMDE5LTIwMjYgUm90aGVyIE9TUyBHbWJILCBodHRwczovL290b2JvLmlvLwoKVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQgdW5kZXIKdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUKRm91bmRhdGlvbiwgZWl0aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCkFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTCkZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgpZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQphbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbS4gSWYgbm90LCBzZWUgPGh0dHBzOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi4KKi8KCi8qKgogKiBAcGFja2FnZSAgICAgU2tpbiAiRGVmYXVsdCIKICogQHNlY3Rpb24gICAgIFdpZGdldHMKICovCgpAbWVkaWEgc2NyZWVuLHByb2plY3Rpb24sdHYsaGFuZGhlbGQgewoKLk90b2JvQUlSZXNwb25zZUVycm9yIHsKICBjb2xvcjogZGFya3JlZDsKfQoKI0NhbmNlbFF1ZXN0aW9uIHsKICBkaXNwbGF5OiBub25lOwp9CgojT3RvYm9BSUxvYWRlciB7CiAgdmVydGljYWwtYWxpZ246IG1pZGRsZTsKICBtYXJnaW4tbGVmdDogMTBweDsKICBkaXNwbGF5OiBub25lOwp9CgouT3RvYm9BSVRleHRBcmVhIHsKICBwYWRkaW5nOiAxMHB4OwogIHdpZHRoOiA3MCU7Cn0KCi5PdG9ib0FJVGV4dEFyZWFbcmVhZG9ubHldIHsKICBiYWNrZ3JvdW5kLWNvbG9yOiAjRkZGOwp9CgoKI1JlcGx5Qm94IHsKICBkaXNwbGF5OiBub25lOwp9Cgp9IC8qIGVuZCBAbWVkaWEgKi8K # --
# 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/
# --
# 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 var::packagesetup::OTOBOAI;

use strict;
use warnings;

# core modules

# CPAN modules

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

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::System::DynamicField',
    'Kernel::System::DynamicField::Backend',
    'Kernel::System::GenericInterface::Webservice',
    'Kernel::System::Log',
    'Kernel::System::Queue',
    'Kernel::System::StandardTemplate',
    'Kernel::System::Valid',
    'Kernel::System::SysConfig',
    'Kernel::System::Main',
);

=head1 NAME

var::packagesetup::OTOBOAI - code to execute during package installation

=head1 PUBLIC INTERFACE

=cut

=head2 new()

create an object

    use Kernel::System::ObjectManager;
    local $Kernel::OM = Kernel::System::ObjectManager->new();
    my $CodeObject = $Kernel::OM->Get('var::packagesetup::OTOBOAI');

=cut

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

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

    # set dynamic field name here
    $Self->{DynamicFieldName} = 'OTOBOAI';

    # always discard the config object before package code is executed,
    # to make sure that the config object will be created newly, so that it
    # will use the recently written new config from the package
    $Kernel::OM->ObjectsDiscard(
        Objects => ['Kernel::Config'],
    );

    $Self->{Invoker} = {
        IngestMany => {
            Description => 'Import content to our roboto ai.',
            Events      => [

                #                {
                #                    Asynchronous => '0',
                #                    Event        => 'TicketCreate',
                #                },
            ],
            Type => 'OTOBOAI::IngestMany',
        },
        GetAnswer => {
            Description => 'Get an answer based on the ingested data.',
            Events      => [
            ],
            Type => 'OTOBOAI::GetAnswer',
        },
        Purge => {
            Description => 'Purge the otobo-ai vector store.',
            Events      => [
            ],
            Type => 'OTOBOAI::Purge',
        },
        DeleteByID => {
            Description => 'Purge a single item the otobo-ai vector store.',
            Events      => [
            ],
            Type => 'OTOBOAI::Purge',
        },
        QueryEmbeddings => {
            Description => 'Execute Similarity Search using the otobo-ai vector store.',
            Events      => [
            ],
            Type => 'OTOBOAI::QueryEmbeddings',
        },
    };

    $Self->{InvokerControllerMapping} = {
        IngestMany => {
            Command    => 'PUT',
            Controller => '/otobo-ai/embedding/ingest-many',
        },
        GetAnswer => {
            Command    => 'POST',
            Controller => '/otobo-ai/:RAG/invoke',
        },
        Purge => {
            Command    => 'DELETE',
            Controller => '/otobo-ai/embedding/purge/:Collection',
        },
        DeleteByID => {
            Command    => 'POST',
            Controller => '/otobo-ai/embedding/delete',
        },
        QueryEmbeddings => {
            Command    => 'POST',
            Controller => '/otobo-ai/embedding/query',
        },
    };

    $Self->{Operation} = {

        ArticleDFUpdate => {
            Description       => 'ArticleDFUpdate',
            IncludeTicketData => '0',
            Type              => 'Ticket::ArticleDFUpdate'
        },
        TicketGet => {
            Description       => 'Retrieve a Ticket',
            IncludeTicketData => '0',
            Type              => 'Ticket::TicketGetAI',
            MappingOutbound   => {
                Type   => 'XSLT',
                Config => {
                    DataInclude => [],
                    Template    => $Self->_TicketGetXSLT(),
                }
            }
        },
        TicketUpdate => {
            Description       => 'Update a Ticket',
            IncludeTicketData => '0',
            Type              => 'Ticket::TicketUpdate',
        },
        TicketLink => {
            Description       => 'Link a ticket to a target object.',
            IncludeTicketData => '0',
            Type              => 'Ticket::Link',
        },
        TicketUnlink => {
            Description       => 'Unlink a ticket to a target object.',
            IncludeTicketData => '0',
            Type              => 'Ticket::UnLink',
        },
        FAQSearch => {
            Description       => 'Search FAQs with ES',
            IncludeTicketData => '0',
            Type              => 'ElasticSearch::FAQSearch',
            MappingOutbound   => {
                Type   => 'XSLT',
                Config => {
                    DataInclude => [],
                    Template    => $Self->_FAQSearchXSLT(),
                }
            }
        },
        TicketSearch => {
            Description       => 'Search Tickets with ES',
            IncludeTicketData => '0',
            Type              => 'ElasticSearch::TicketSearch',
            MappingOutbound   => {
                Type   => 'XSLT',
                Config => {
                    DataInclude => [],
                    Template    => $Self->_TicketSearchXSLT(),
                }
            }
        },
        QueryEmbeddings => {
            Description       => 'Find similar items in vector db',
            IncludeTicketData => '0',
            Type              => 'Ticket::QueryEmbeddings',
        },
    };

    $Self->{RouteOperationMapping} = {
        ArticleDFUpdate => {
            RequestMethod => ['PUT'],
            Route         => '/Ticket/:TicketID/Article/DF'
        },
        TicketGet => {
            RequestMethod => ['GET'],
            Route         => '/Ticket/:TicketID',
        },
        TicketUpdate => {
            RequestMethod => ['PUT'],
            Route         => '/Ticket/:TicketID',
        },
        FAQSearch => {
            RequestMethod => ['GET'],
            Route         => '/FAQ',
        },
        TicketSearch => {
            RequestMethod => ['GET'],
            Route         => '/Ticket',
        },
        QueryEmbeddings => {
            RequestMethod => ['GET'],
            Route         => '/Ticket/:TicketID/Embeddings/:Collection',
        },
        TicketLink => {
            RequestMethod => ['PUT'],
            Route         => '/Ticket/:TicketID/Link/:TargetType/:LinkType/:TargetID',
        },
        TicketUnlink => {
            RequestMethod => ['DELETE'],
            Route         => '/Ticket/:TicketID/Link/:TargetType/:LinkType/:TargetID',
        },
    };

    return $Self;
}

=head2 CodeInstall()

run the code install part

    my $Result = $CodeObject->CodeInstall();

=cut

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

    # create OTOBOAI dynamic field
    $Self->_CreateAIDynamicField();

    # create AI answer template
    $Self->_CreateAIAnswerTemplate();

    my $WebserviceObject = $Kernel::OM->Get('Kernel::System::GenericInterface::Webservice');
    my $ID               = $WebserviceObject->WebserviceAdd(
        Name   => 'OTOBO-AI',
        Config => {

            # Webservice Config
            Debugger => {
                DebugThreshold => 'error',
                TestMode       => '0',
            },
            Description => '',
            Provider    => {
                Operation => $Self->{Operation},
                Transport => {
                    Config => {
                        AdditionalHeaders     => undef,
                        KeepAlive             => '',
                        MaxLength             => '100000',
                        OutboundHeaders       => {},
                        RouteOperationMapping => $Self->{RouteOperationMapping},
                    },
                    Type => 'HTTP::REST',
                },
            },
            RemoteSystem => '',
            Requester    => {
                Invoker   => $Self->{Invoker},
                Transport => {
                    Config => {
                        DefaultCommand           => 'POST',
                        Host                     => 'http://rag:8000',
                        InvokerControllerMapping => $Self->{InvokerControllerMapping},
                        Timeout                  => '300',
                    },
                    Type => 'HTTP::REST',
                },
            }

            # EO Webservice Config
        },
        ValidID => 2,
        UserID  => 1,
    );

    if ( !$ID ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Could not install the OTOBOAI webservice!",
        );
        return;
    }

    $Self->_UpdateArticleActions( Channel => 'Email' );
    $Self->_UpdateArticleActions( Channel => 'Phone' );

    return 1;
}

=head2 CodeUpgrade()

run the code upgrade part

    my $Result = $CodeObject->CodeUpgrade();

=cut

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

    my $WebserviceObject = $Kernel::OM->Get('Kernel::System::GenericInterface::Webservice');
    my $Webservice       = $WebserviceObject->WebserviceGet(
        Name => 'OTOBO-AI',
    );

    if ( !$Webservice ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Did not find the OTOBOAI webservice!",
        );
        return;
    }

    # upgrade webservice as necessary
    $Webservice->{Config} = {

        # Webservice Config
        Debugger => {
            DebugThreshold => $Webservice->{Config}->{Debugger}->{DebugThreshold} // 'error',
            TestMode       => '0',
        },
        Description => $Webservice->{Config}->{Description} // 'error',
        Provider    => {
            Operation => $Self->{Operation},
            Transport => {
                Config => {
                    AdditionalHeaders     => $Webservice->{Config}->{Provider}->{Transport}->{Config}->{AdditionalHeaders},
                    KeepAlive             => $Webservice->{Config}->{Provider}->{Transport}->{Config}->{KeepAlive},
                    MaxLength             => $Webservice->{Config}->{Provider}->{Transport}->{Config}->{MaxLength},
                    OutboundHeaders       => $Webservice->{Config}->{Provider}->{Transport}->{Config}->{OutboundHeaders},
                    RouteOperationMapping => $Self->{RouteOperationMapping},
                },
                Type => 'HTTP::REST',
            },
        },
        RemoteSystem => $Webservice->{Config}->{RemoteSystem},
        Requester    => {
            Invoker   => $Self->{Invoker},
            Transport => {
                Config => {
                    DefaultCommand => 'POST',
                    Host           => $Webservice->{Config}->{Requester}->{Transport}->{Config}->{Host} == 'http://otobo-ai:8000'
                    ?
                        'http://rag:8000'
                    : $Webservice->{Config}->{Requester}->{Transport}->{Config}->{Host},
                    InvokerControllerMapping => $Self->{InvokerControllerMapping},
                    Timeout                  => $Webservice->{Config}->{Requester}->{Transport}->{Config}->{Timeout},
                    OutboundHeaders          => $Webservice->{Config}->{Requester}->{Transport}->{Config}->{OutboundHeaders},
                },
                Type => 'HTTP::REST',
            },
        }
    };

    my $Success = $WebserviceObject->WebserviceUpdate(
        %{$Webservice},
        UserID => 1,
    );

    if ( !$Success ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Could not update the OTOBOAI webservice!",
        );
        return;
    }

    $Self->_UpdateArticleActions( Channel => 'Email' );
    $Self->_UpdateArticleActions( Channel => 'Phone' );

    return 1;
}

=head2 CodeUninstall()

run the code uninstall part

    my $Result = $CodeObject->CodeUninstall();

=cut

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

    $Self->_CleanupArticleActions( Channel => 'Phone' );
    $Self->_CleanupArticleActions( Channel => 'Email' );

    my $WebserviceObject = $Kernel::OM->Get('Kernel::System::GenericInterface::Webservice');

    my $Webservice = $WebserviceObject->WebserviceGet(
        Name => 'OTOBO-AI',
    );
    $WebserviceObject->WebserviceDelete(
        ID     => $Webservice->{ID},
        UserID => 1,
    );

    # delete OTOBOAI dynamic field
    $Self->_DeleteAIDynamicField();

    # delete Answer template
    $Self->_DeleteAIAnswerTemplate();

    return 1;
}

=head2 _CreateAIDynamicField()

creates the dynamic field needed for the AI response functionality

    my $Result = $CodeObject->_CreateAIDynamicField();

=cut

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

    my $ValidID = $Kernel::OM->Get('Kernel::System::Valid')->ValidLookup(
        Valid => 'valid',
    );

    # get all current dynamic fields
    my $DynamicFieldList = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
        Valid => 0,
    );

    # get the list of order numbers (is already sorted).
    my @DynamicfieldOrderList;
    for my $Dynamicfield ( @{$DynamicFieldList} ) {
        push @DynamicfieldOrderList, $Dynamicfield->{FieldOrder};
    }

    # get the last element from the order list and add 1
    my $NextOrderNumber = 1;
    if (@DynamicfieldOrderList) {
        $NextOrderNumber = $DynamicfieldOrderList[-1] + 1;
    }

    # create a dynamic fields lookup table
    my %DynamicFieldLookup;
    DYNAMICFIELD:
    for my $DynamicField ( @{$DynamicFieldList} ) {
        next DYNAMICFIELD if ref $DynamicField ne 'HASH';
        $DynamicFieldLookup{ $DynamicField->{Name} } = $DynamicField;
    }

    # check if the dynamic field already exists
    if ( ref $DynamicFieldLookup{ $Self->{DynamicFieldName} } ne 'HASH' ) {

        # create a new field
        my $FieldID = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldAdd(
            Name       => $Self->{DynamicFieldName},
            Label      => 'OTOBO AI',
            FieldType  => 'TextAreaAI',
            FieldOrder => $NextOrderNumber,
            ObjectType => 'Article',
            Config     => {
                DefaultValue => '',
                RegExList    => [],
                Tooltip      => '',
            },
            InternalField => 1,
            ValidID       => $ValidID,
            UserID        => 1,
        );

        if ( !$FieldID ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Could not create dynamic field $Self->{DynamicFieldName}. Please review the logs.",
            );
        }
    }
    else {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Dynamic field with name $Self->{DynamicFieldName} already exists.",
        );
    }

    return 1;
}

=head2 _DeleteAIDynamicField()

Deletes the dynamic field for AI functionality.

    my $Result = $CodeObject->_DeleteAIDynamicField();

=cut

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

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

    # running pre-uninstall, so we do have the sysconfig at hand
    my $DynamicFieldName = $Kernel::OM->Get('Kernel::Config')->Get('OTOBOAI::DynamicFieldOTOBOAI') || $Self->{DynamicFieldName};

    my $DynamicFieldConfig = $DynamicFieldObject->DynamicFieldGet(
        Name => $DynamicFieldName,
    );

    if ( !IsHashRefWithData($DynamicFieldConfig) ) {
        $LogObject->Log(
            'Priority' => 'error',
            'Message'  => "DynamicField '$DynamicFieldName' not found on the system!",
        );
        return;
    }

    my $ValuesDeleteSuccess = $DynamicFieldBackendObject->AllValuesDelete(
        DynamicFieldConfig => $DynamicFieldConfig,
        UserID             => 1,
    );

    if ( !$ValuesDeleteSuccess ) {
        $LogObject->Log(
            'Priority' => 'error',
            'Message'  => "Could not delete values for DynamicField $DynamicFieldConfig->{Name}!",
        );
    }

    my $Success = $DynamicFieldObject->DynamicFieldDelete(
        ID     => $DynamicFieldConfig->{ID},
        UserID => 1,
    );

    if ( !$Success ) {
        $LogObject->Log(
            'Priority' => 'error',
            'Message'  => "Could not delete DynamicField $DynamicFieldConfig->{Name}!",
        );
    }

    return 1;
}

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

    # get all valid queues
    my $QueueObject = $Kernel::OM->Get('Kernel::System::Queue');
    my %QueueData   = $QueueObject->QueueList( Valid => 1 );

    # add english template
    {
        my $TemplateID = $Kernel::OM->Get('Kernel::System::StandardTemplate')->StandardTemplateAdd(
            Name         => 'OTOBOAI Answer Template',
            Template     => '<OTOBO_AIAnswer_' . $Self->{DynamicFieldName} . '>',
            ContentType  => 'text/plain; charset=utf-8',
            TemplateType => 'Answer',
            ValidID      => 1,
            UserID       => 1,
        );

        # add template to every valid queue
        for my $QueueID ( keys %QueueData ) {
            $QueueObject->QueueStandardTemplateMemberAdd(
                QueueID            => $QueueID,
                StandardTemplateID => $TemplateID,
                Active             => 1,
                UserID             => 1,
            );
        }
    }

    return 1;
}

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

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

    # delete template
    for my $TemplateName ( ('OTOBOAI Answer Template') ) {
        my $TemplateID = $StandardTemplateObject->StandardTemplateLookup(
            StandardTemplate => $TemplateName,
        );

        # also cleans up the queue relations before deleting
        $StandardTemplateObject->StandardTemplateDelete(
            ID => $TemplateID,
        );
    }

    return 1;
}

sub _UpdateArticleActions {

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

    # we only do this on rel-11.0
    # for rel-11_1 we can just use XML

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

    my $ReleaseInfo = $MainObject->GetReleaseInfo(
        Directory => $ConfigObject->Get('Home'),
        Filename  => 'RELEASE',
    );

    my $Version = $ReleaseInfo->{Version};
    if ( $Version !~ /^11\.0/ ) {

        return $Self->_CleanupArticleActions( Channel => $Channel );
    }

    my $SysConfigObject = $Kernel::OM->Get('Kernel::System::SysConfig');

    my %Setting = $SysConfigObject->SettingGet(
        Name     => "Ticket::Frontend::Article::Actions###$Channel",    # (required) Setting name
        Deployed => 1,                                                  # (optional) Get deployed setting value. Default 0.
    );

    return if !%Setting;

    my $EffectiveValue = $Setting{EffectiveValue};

    if ( !$EffectiveValue->{AgentTicketAIChat} ) {

        my $ExclusiveLockGUID = $SysConfigObject->SettingLock(
            LockAll => 1,
            Force   => 1,    # (optional) Force locking (do not check if it's already locked by another user). Default: 0.
            UserID  => 1,    # (required)
        );

        $EffectiveValue->{AgentTicketAIChat} = {
            'Prio'   => '1007',
            'Module' => 'Kernel::Output::HTML::ArticleAction::AgentTicketAIChat',
            'Valid'  => '1'
        };

        my %Result = $SysConfigObject->SettingUpdate(
            Name              => "Ticket::Frontend::Article::Actions###$Channel",    # (required) setting name
            IsValid           => 1,                                                  # (optional) 1 or 0, modified 0
            EffectiveValue    => $EffectiveValue,                                    # (optional) only needed when IsValid is turned on
            ExclusiveLockGUID => $ExclusiveLockGUID,
            UserID            => 1,                                                  # (required) UserID
            NoValidation      => 1,                                                  # (optional) no value type validation.
        );

        $SysConfigObject->SettingUnlock(
            UnlockAll => 1,
        );

        $SysConfigObject->ConfigurationDeploy(
            Comments    => "otobo-ai package install",
            AllSettings => 1,
            Force       => 1,
            UserID      => 1,
        );

    }

    return;
}

sub _CleanupArticleActions {

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

    my $SysConfigObject = $Kernel::OM->Get('Kernel::System::SysConfig');

    my %Setting = $SysConfigObject->SettingGet(
        Name     => "Ticket::Frontend::Article::Actions###$Channel",    # (required) Setting name
        Deployed => 1,                                                  # (optional) Get deployed setting value. Default 0.
        NoLog    => 1,
    );

    return if !%Setting;

    my $EffectiveValue = $Setting{EffectiveValue};

    if ( $EffectiveValue->{AgentTicketAIChat} ) {

        my $ExclusiveLockGUID = $SysConfigObject->SettingLock(
            LockAll => 1,
            Force   => 1,    # (optional) Force locking (do not check if it's already locked by another user). Default: 0.
            UserID  => 1,    # (required)
        );

        delete $EffectiveValue->{AgentTicketAIChat};

        my %Result = $SysConfigObject->SettingUpdate(
            Name              => "Ticket::Frontend::Article::Actions###$Channel",    # (required) setting name
            IsValid           => 1,                                                  # (optional) 1 or 0, modified 0
            EffectiveValue    => $EffectiveValue,                                    # (optional) only needed when IsValid is turned on
            ExclusiveLockGUID => $ExclusiveLockGUID,
            UserID            => 1,                                                  # (required) UserID
            NoValidation      => 1,                                                  # (optional) no value type validation.
        );

        $SysConfigObject->SettingUnlock(
            UnlockAll => 1,
        );

        $SysConfigObject->ConfigurationDeploy(
            Comments    => "otobo-ai package install",
            AllSettings => 1,
            Force       => 1,
            UserID      => 1,
        );

    }

    return;
}

sub _FAQSearchXSLT {

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

    my $XSLT = <<'XSLT';
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
   <xsl:output method="xml" indent="yes"/>

   <!-- no-op fallback template to drop unwanted content -->
   <xsl:template match="*"></xsl:template>

   <!-- always copy full Error info -->
   <xsl:template match="Error">
       <xsl:copy-of select="." />
   </xsl:template>

   <!-- FAQ mapping -->
   <xsl:template match="anon">
       <faq>
           <faq_id><xsl:value-of select="ItemID"/></faq_id>
           <title><xsl:value-of select="Title"/></title>
           <sympthom><xsl:value-of select="Field1" /></sympthom>
           <problem><xsl:value-of select="Field1" /></problem>
           <solution><xsl:value-of select="Field1" /></solution>
       </faq>
    </xsl:template>

   <!-- main template -->
   <xsl:template match="/RootElement">
     <RootElement>
      <xsl:apply-templates/>
     </RootElement>
    </xsl:template>

</xsl:stylesheet>
XSLT

    return $XSLT;
}

sub _TicketGetXSLT {

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

    my $XSLT = <<'XSLT';
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
   <xsl:output method="xml" indent="yes"/>

   <!-- no-op fallback template to drop unwanted content -->
   <xsl:template match="*"></xsl:template>

   <!-- always copy full Error info -->
   <xsl:template match="Error">
       <xsl:copy-of select="." />
   </xsl:template>

   <!-- special handling for dynamic fields
        by default only the OTOBOAI field is kept
   -->
   <xsl:template match="DynamicField">
       <xsl:variable name="dfname"><xsl:value-of select="./Name" /></xsl:variable>
       <xsl:choose>
           <xsl:when test="starts-with($dfname,'OTOBOAI')">
               <generated_answer><xsl:value-of select="./Value" /></generated_answer>
           </xsl:when>
           <xsl:otherwise></xsl:otherwise>
       </xsl:choose>
   </xsl:template>

   <xsl:template match="Links[TargetType='Ticket']">
       <linked>
           <ticket>
            <ticket_id><xsl:value-of select="TargetID" /></ticket_id>
            <type><xsl:value-of select="LinkType" /></type>
            <direction><xsl:value-of select="Direction"/></direction>
            <xsl:for-each select="Data">
               <ticket_number><xsl:value-of select="TicketNumber"/></ticket_number>
               <title><xsl:value-of select="Title"/></title>
               <state><xsl:value-of select="State"/></state>
               <priority><xsl:value-of select="Priority"/></priority>
               <queue><xsl:value-of select="Queue"/></queue>
               <customer><xsl:value-of select="CustomerUserID"/></customer>
               <xsl:apply-templates />
            </xsl:for-each>
        </ticket>
       </linked>
   </xsl:template>

   <xsl:template match="Links[TargetType='FAQ']">
       <linked>
           <faq>
            <faq_id><xsl:value-of select="TargetID" /></faq_id>
            <type><xsl:value-of select="LinkType" /></type>
            <title><xsl:value-of select="Data/Title" /></title>
            <sypthom><xsl:value-of select="Data/Field1" /></sypthom>xsl:value-of select="CustomerUserID"/>
            <problem><xsl:value-of select="Data/Field2" /></problem>
            <solution><xsl:value-of select="Data/Field3" /></solution>
            <direction><xsl:value-of select="Direction"/></direction>
           </faq>
       </linked>
   </xsl:template>

    <!-- Article mapping -->
   <xsl:template match="Article">
       <article>
           <article_id><xsl:value-of select="ArticleID"/></article_id>
           <from><xsl:value-of select="From"/></from>
           <to><xsl:value-of select="To"/></to>
           <subject><xsl:value-of select="Subject"/></subject>
           <body><xsl:value-of select="Body"/></body>
           <xsl:variable name="Created"><xsl:value-of select="CreateTime" /></xsl:variable>
           <xsl:choose>
               <xsl:when test="not($Created = '')">
                   <created><xsl:value-of select='$Created' /></created>
               </xsl:when>
               <xsl:otherwise>
                   <created><xsl:value-of select="Created" /></created>
               </xsl:otherwise>
           </xsl:choose>
           <xsl:variable name="Channel"><xsl:value-of select="CommunicationChannelID" /></xsl:variable>
           <channel>
            <xsl:choose>
               <xsl:when test="$Channel = '1'">Email</xsl:when>
               <xsl:when test="$Channel = '2'">Phone</xsl:when>
               <xsl:when test="$Channel = '3'">Internal</xsl:when>
               <xsl:otherwise>Other</xsl:otherwise>
            </xsl:choose>
           </channel>
           <xsl:variable name="SenderType"><xsl:value-of select="SenderTypeID" /></xsl:variable>
           <sender_type>
            <xsl:choose>
               <xsl:when test="$SenderType = '1'">agent</xsl:when>
               <xsl:when test="$SenderType = '2'">system</xsl:when>
               <xsl:when test="$SenderType = '3'">customer</xsl:when>
               <xsl:otherwise>Other</xsl:otherwise>
            </xsl:choose>
           </sender_type>
           <xsl:apply-templates />
       </article>
   </xsl:template>

   <!-- Ticket mapping -->
   <xsl:template name="Ticket" match="Ticket">
       <ticket>
           <ticket_id><xsl:value-of select="TicketID"/></ticket_id>
           <ticket_number><xsl:value-of select="TicketNumber"/></ticket_number>
           <title><xsl:value-of select="Title"/></title>
           <state><xsl:value-of select="State"/></state>
           <priority><xsl:value-of select="Priority"/></priority>
           <queue><xsl:value-of select="Queue"/></queue>
           <customer><xsl:value-of select="CustomerUserID"/></customer>
           <owner><xsl:value-of select="Owner"/></owner>
           <created><xsl:value-of select="Created"/></created>
           <changed><xsl:value-of select="Changed"/></changed>
           <xsl:apply-templates />
       </ticket>
    </xsl:template>

   <!-- main template -->
   <xsl:template match="/RootElement">
     <RootElement>
      <xsl:apply-templates/>
     </RootElement>
    </xsl:template>

</xsl:stylesheet>
XSLT

    return $XSLT;
}

sub _TicketSearchXSLT {

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

    my $XSLT = <<'XSLT';
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
   <xsl:output method="xml" indent="yes"/>

   <!-- no-op fallback template to drop unwanted content -->
   <xsl:template match="*"></xsl:template>

   <!-- always copy full Error info -->
   <xsl:template match="Error">
       <xsl:copy-of select="." />
   </xsl:template>

   <xsl:template match="To">
       <to><xsl:value-of select="."/></to>
   </xsl:template>

   <xsl:template match="ArticlesExternal">
       <article>
           <subject><xsl:value-of select="Subject"/></subject>
           <from><xsl:value-of select="From"/></from>
           <body><xsl:value-of select="Body"/></body>
           <xsl:apply-templates/>
       </article>
   </xsl:template>
   <!-- ticket mapping -->
   <xsl:template match="anon">
       <ticket>
           <ticket_id><xsl:value-of select="TicketID"/></ticket_id>
           <title><xsl:value-of select="Title"/></title>
           <ticket_number><xsl:value-of select="TicketNumber" /></ticket_number>
           <customer><xsl:value-of select="CustomerID" /></customer>
           <customer_user><xsl:value-of select="CustomerUserID" /></customer_user>
           <xsl:apply-templates/>
       </ticket>
    </xsl:template>

   <!-- main template -->
   <xsl:template match="/RootElement">
     <RootElement>
      <xsl:apply-templates/>
     </RootElement>
    </xsl:template>

</xsl:stylesheet>
XSLT

    return $XSLT;
}

1;
 --- 
components:

  schemas:
    ArticleDFUpdateRequest:
      allOf:
        - $ref: '#/components/schemas/Credentials'
        - type: object
          properties:
            DynamicField:
              $ref : '#/components/schemas/DynamicFields'
            TicketID:
              description: The TicketID to update
              type: string
            ArticleID:
              description: The ArticleID to update
              type: string
          required:
            - TicketID

    ArticleDFUpdateResponse:
      allOf:
        - $ref: '#/components/schemas/ApiError'
        - type: object
          properties:
            TicketID:
              type: string
            ArticleID:
              type: string
            Success:
              type: string

    ESSearchRequest:
      allOf:
        - $ref: '#/components/schemas/Credentials'
        - type: object
          properties:
            Fulltext:
              description: The fulltext search term
              type: string
            Limit:
              description: Maximum number of search results
              type: integer
          required:
            - Query


    ESFAQSearchResponse:
      allOf:
        - $ref: '#/components/schemas/ApiError'
        - type: object
          properties:
            faq:
              type: array
              items:
                type: object
                properties:
                  ItemID:
                    type: integer
                  Title:
                    type: string
                  Field1:
                    type: string
                  Field2:
                    type: string
                  Field3:
                    type: string

    ESTicketSearchResponse:
      allOf:
        - $ref: '#/components/schemas/ApiError'
        - type: object
          properties:
            ticket:
              type: array
              items:
                type: object
                properties:
                  CustomerID:
                    type: string
                  CustomerUserID:
                    type: string
                  TicketID:
                    type: string
                  TicketNumber:
                    type: string
                  Title:
                    type: string
                  Article:
                    type: object
                    properties:
                      Subject:
                        type: string
                      Body: 
                        type: string
                      From: 
                        type: string
                      To:
                        type: array
                        items:
                          type: string

    QueryEmbeddingsRequest:
      allOf:
        - $ref: '#/components/schemas/Credentials'
        - type: object
          properties:
            TicketID:
              description: TicketID
              type: string
            ArticleID:
              description: ArticleID
              type: string
            Collection:
              description: Collection
              type: string
              enum:
                - faqs
                - ticket_pairs
                - ticket_chunks
                - docs

    QueryEmbeddingsResponse:
      allOf:
        - $ref: '#/components/schemas/ApiError'
        - type: array
          items:            
              properties:
                page_content:
                  type: string
                id:
                  type: string
                metadata:
                  type: object
                  properties:
                    fulltext:
                      type: string
                    source_id:
                      type: string
                    label:
                      type: string


    TicketLinkRequest:
      allOf:
        - $ref: '#/components/schemas/Credentials'
        - type: object
          properties:
            TicketID:
              description: TicketID
              type: string
            TargetType:
              description: Target Object Type
              type: string
              enum:
                - Ticket
                - FAQ
                - ConfigItem                
            LinkType:
              description: Target Link Type
              type: string
              enum:
                - Normal
                - ParentChild
                - LocationOf
                - Includes
                - AlternativeTo
                - ConnectedTo
                - DependsOn
                - RelevantTo                
            TargetID:
              description: Target Object ID
              type: string

    TicketLinkResponse:
      allOf:
        - $ref: '#/components/schemas/ApiError'
        - type: object
          properties:
            Success:
              type: string

    TicketUnlinkRequest:
      allOf:
        - $ref: '#/components/schemas/Credentials'
        - type: object
          properties:
            TicketID:
              description: TicketID
              type: string
            TargetType:
              description: Target Object Type
              type: string
              enum:
                - Ticket
                - FAQ
                - ConfigItem                
            LinkType:
              description: Target Link Type
              type: string
              enum:
                - Normal
                - ParentChild
                - LocationOf
                - Includes
                - AlternativeTo
                - ConnectedTo
                - DependsOn
                - RelevantTo                      
            TargetID:
              description: Target Object ID
              type: string

    TicketUnlinkResponse:
      allOf:
        - $ref: '#/components/schemas/ApiError'
        - type: object
          properties:
            Success:
              type: string


Ticket::ArticleDFUpdate: 
  QueryParams:
    GET:
    - $ref: '#/components/parameters/UserLogin'
    - $ref: '#/components/parameters/Password'
    - $ref: '#/components/parameters/SessionID'  
    - description: ArticleID
      in: query
      name: ArticleID
      required: false
      schema:
        type: string    
    PUT:
    - $ref: '#/components/parameters/UserLogin'
    - $ref: '#/components/parameters/Password'
    - $ref: '#/components/parameters/SessionID'  
    - description: ArticleID
      in: query
      name: ArticleID
      required: false
      schema:
        type: string    
  RequestBody:
    content:
      application/json:
        examples:
          Simple:
            value:
              TicketID: 1
              DynamicField:
              - Name: MyDynamicFieldName
                Value: SomeValue
          WithArticleID:
            value:
              TicketID: 1
              ArticleID: 18
              DynamicField:
              - Name: MyDynamicFieldName
                Value: SomeValue
        schema:
          $ref : '#/components/schemas/ArticleDFUpdateRequest'
    required: true
  Responses:
    200:
      content:
        application/json:
          examples:
            foo:
              value:
                ArticleID: 7
                TicketID: 7
                Sucess : 1
          schema:
            $ref : '#/components/schemas/ArticleDFUpdateResponse'
      description: 200 response

ElasticSearch::FAQSearch:
  QueryParams: 
    GET:
    - $ref: '#/components/parameters/UserLogin'
    - $ref: '#/components/parameters/Password'
    - $ref: '#/components/parameters/SessionID'
    - description: Fulltext query term
      in: query
      name: Fulltext
      required: true
      schema:
        type: string
    - description: Maximum number of search results
      in: query
      name: Limit
      required: false
      schema:
        type: integer
  RequestBody:
    content:
      application/json:
        examples:
          Simple:
            value:
              Query: 'Who let the dogs out?'
        schema:
          $ref : '#/components/schemas/ESSearchRequest'
    required: true
  Responses:
    200:
      content:
        application/json:
          examples:
            faqs:
              value:
                - faq:
                  faq_id: 2
                  sympthom : "A sympthom"
                  problem: "A problem"
                  solution: "The solution"
                  title: "some title"
          schema:
            $ref : '#/components/schemas/ESFAQSearchResponse'
      description: 200 response

ElasticSearch::TicketSearch:
  QueryParams: 
    GET:
    - $ref: '#/components/parameters/UserLogin'
    - $ref: '#/components/parameters/Password'
    - $ref: '#/components/parameters/SessionID'
    - description: Fulltext query term
      in: query
      name: Fulltext
      required: true
      schema:
        type: string
    - description: Maximum number of search results
      in: query
      name: Limit
      required: false
      schema:
        type: integer
  RequestBody:
    content:
      application/json:
        examples:
          Simple:
            value:
              Query: 'Who let the dogs out?'
        schema:
          $ref : '#/components/schemas/ESSearchRequest'
    required: true
  Responses:
    200:
      content:
        application/json:
          examples:
            faqs:
              value:
                - ticket 
          schema:
            $ref : '#/components/schemas/ESTicketSearchResponse'
      description: 200 response

Ticket::QueryEmbeddings:
  QueryParams: 
    GET:
    - $ref: '#/components/parameters/UserLogin'
    - $ref: '#/components/parameters/Password'
    - $ref: '#/components/parameters/SessionID'
    - description: TicketID
      in: query
      name: TicketID
      required: true
      schema:
        type: string
    - description: ArticleID
      in: query
      name: ArticleID
      required: false
      schema:
        type: string
    - description: Collection name
      in: query
      name: Collection
      required: true
      schema:
        type: string
        enum:
          - faqs
          - ticket_pairs
          - ticket_chunks
          - docs
    - description: Query for similar item search. if omitted, subject + body of the referenced article is used
      in: query
      name: Query
      required: false
      schema:
        type: string

  RequestBody:
    content:
      application/json:
        examples:
          Simple:
            value:
              TicketID: 1,
              ArticleID: 1,
              Collections: faqs,
        schema:
          $ref : '#/components/schemas/QueryEmbeddingsRequest'
    required: true
  Responses:
    200:
      content:
        application/json:
          examples:
            faqs:
              value:
                - id: <uuid>
                  page_content: 'embedded text'
                  type: Document
                  metadata:
                    label: default
                    source_id: 1
          schema:
            $ref : '#/components/schemas/QueryEmbeddingsResponse'
      description: 200 response


Ticket::Link:
  QueryParams:
    PUT:
    - $ref: '#/components/parameters/UserLogin'
    - $ref: '#/components/parameters/Password'
    - $ref: '#/components/parameters/SessionID'    
  RequestBody:
    content:
      application/json:
        examples:
          Simple:
            value:
              TicketID: 1,
              TargetType: Ticket
              LinkType: Normal
              TargetID: 2,
          ParentChild:
            value:
              TicketID: 1,
              TargetType: Ticket
              LinkType: ParentChild
              TargetID: 2,
        schema:
          $ref : '#/components/schemas/TicketLinkRequest'
    required: true
  Responses:
    200:
      content:
        application/json:
          examples:
            Success : 1
          schema:
            $ref : '#/components/schemas/TicketLinkResponse'
      description: 200 response


Ticket::UnLink:
  QueryParams:
    DELETE:
    - $ref: '#/components/parameters/UserLogin'
    - $ref: '#/components/parameters/Password'
    - $ref: '#/components/parameters/SessionID'    
  RequestBody:
    content:
      application/json:
        examples:
          Simple:
            value:
              TicketID: 1,
              TargetType: Ticket
              LinkType: Normal
              TargetID: 2,
          ParentChild:
            value:
              TicketID: 1,
              TargetType: Ticket
              LinkType: ParentChild
              TargetID: 2,
        schema:
          $ref : '#/components/schemas/TicketUnlinkRequest'
    required: true
  Responses:
    200:
      content:
        application/json:
          examples:
            Success : 1
          schema:
            $ref : '#/components/schemas/TicketUnlinkResponse'
      description: 200 response


 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