HideShowForAgentTicketCompose 10.1.3 Rother OSS GmbH https://otobo.io/ GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Added translations. Fix usage with PropertiesDatabase. Initial Release. The package HideShowForAgentTicketCompose enables the usage of hiding and showing dynamic fields via ACLs in AgentTicketCompose. 10.1.x 29a2e5e9764664ce17f54eeefc2b09804b949e34 2026-10-28 14:38:02 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-2025 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo - c4729719b9788da163909113055de495fac35df4 - Kernel/Modules/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::Modules::AgentTicketCompose;

use strict;
use warnings;

use Kernel::System::VariableCheck qw(:all);
use Kernel::Language qw(Translatable);
use Mail::Address;

our $ObjectManagerDisabled = 1;

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

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

    # Try to load draft if requested.
    if (
        $Kernel::OM->Get('Kernel::Config')->Get("Ticket::Frontend::$Self->{Action}")->{FormDraft}
        && $Kernel::OM->Get('Kernel::System::Web::Request')->GetParam( Param => 'LoadFormDraft' )
        && $Kernel::OM->Get('Kernel::System::Web::Request')->GetParam( Param => 'FormDraftID' )
        )
    {
        $Self->{LoadedFormDraftID} = $Kernel::OM->Get('Kernel::System::Web::Request')->LoadFormDraft(
            FormDraftID => $Kernel::OM->Get('Kernel::System::Web::Request')->GetParam( Param => 'FormDraftID' ),
            UserID      => $Self->{UserID},
        );
    }

    $Self->{Debug} = $Param{Debug} || 0;

    # get form id
    $Self->{FormID} = $Kernel::OM->Get('Kernel::System::Web::Request')->GetParam( Param => 'FormID' );

    # create form id
    if ( !$Self->{FormID} ) {
        $Self->{FormID} = $Kernel::OM->Get('Kernel::System::Web::UploadCache')->FormIDCreate();
    }

    return $Self;
}

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

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

    # check needed stuff
    if ( !$Self->{TicketID} ) {
        return $LayoutObject->ErrorScreen(
            Message => Translatable('No TicketID is given!'),
            Comment => Translatable('Please contact the administrator.'),
        );
    }

    # get needed objects
    my $ConfigObject  = $Kernel::OM->Get('Kernel::Config');
    my $TicketObject  = $Kernel::OM->Get('Kernel::System::Ticket');
    my $ArticleObject = $Kernel::OM->Get('Kernel::System::Ticket::Article');
# Rother OSS / HideShowForAgentTicketCompose
    my $FieldRestrictionsObject = $Kernel::OM->Get('Kernel::System::Ticket::FieldRestrictions');
# EO HideShowForAgentTicketCompose

    my $ArticleBackendObject = $ArticleObject->BackendForChannel( ChannelName => 'Email' );

    # get config for frontend module
    my $Config = $ConfigObject->Get("Ticket::Frontend::$Self->{Action}");

    # check permissions
    my $Access = $TicketObject->TicketPermission(
        Type     => $Config->{Permission},
        TicketID => $Self->{TicketID},
        UserID   => $Self->{UserID}
    );

    # error screen, don't show ticket
    if ( !$Access ) {
        return $LayoutObject->NoPermission(
            Message    => $LayoutObject->{LanguageObject}->Translate( 'You need %s permissions!', $Config->{Permission} ),
            WithHeader => 'yes',
        );
    }

    # get ACL restrictions
    my %PossibleActions = ( 1 => $Self->{Action} );

    my $ACL = $TicketObject->TicketAcl(
        Data          => \%PossibleActions,
        Action        => $Self->{Action},
        TicketID      => $Self->{TicketID},
        ReturnType    => 'Action',
        ReturnSubType => '-',
        UserID        => $Self->{UserID},
    );
    my %AclAction = $TicketObject->TicketAclActionData();

    # check if ACL restrictions exist
    if ( $ACL || IsHashRefWithData( \%AclAction ) ) {

        my %AclActionLookup = reverse %AclAction;

        # show error screen if ACL prohibits this action
        if ( !$AclActionLookup{ $Self->{Action} } ) {
            return $LayoutObject->NoPermission( WithHeader => 'yes' );
        }
    }

    # Check for failed draft loading request.
    if (
        $Kernel::OM->Get('Kernel::System::Web::Request')->GetParam( Param => 'LoadFormDraft' )
        && !$Self->{LoadedFormDraftID}
        )
    {
        return $LayoutObject->ErrorScreen(
            Message => Translatable('Loading draft failed!'),
            Comment => Translatable('Please contact the administrator.'),
        );
    }

    my %Ticket = $TicketObject->TicketGet(
        TicketID      => $Self->{TicketID},
        DynamicFields => 1
    );

    # get lock state
    my $TicketBackType = 'TicketBack';
    if ( $Config->{RequiredLock} ) {
        if ( !$TicketObject->TicketLockGet( TicketID => $Self->{TicketID} ) ) {

            my $Lock = $TicketObject->TicketLockSet(
                TicketID => $Self->{TicketID},
                Lock     => 'lock',
                UserID   => $Self->{UserID}
            );

            # Set new owner if ticket owner is different then logged user.
            if ( $Lock && ( $Ticket{OwnerID} != $Self->{UserID} ) ) {

                # Remember previous owner, which will be used to restore ticket owner on undo action.
                $Ticket{PreviousOwner} = $Ticket{OwnerID};

                my $Success = $TicketObject->TicketOwnerSet(
                    TicketID  => $Self->{TicketID},
                    UserID    => $Self->{UserID},
                    NewUserID => $Self->{UserID},
                );

                # Show lock state.
                if ( !$Success ) {
                    return $LayoutObject->FatalError();
                }
            }

            $TicketBackType .= 'Undo';
        }
        else {
            my $AccessOk = $TicketObject->OwnerCheck(
                TicketID => $Self->{TicketID},
                OwnerID  => $Self->{UserID},
            );
            if ( !$AccessOk ) {
                my $Output = $LayoutObject->Header(
                    Value     => $Ticket{Number},
                    Type      => 'Small',
                    BodyClass => 'Popup',
                );
                $Output .= $LayoutObject->Warning(
                    Message => Translatable('Sorry, you need to be the ticket owner to perform this action.'),
                    Comment => Translatable('Please change the owner first.'),
                );
                $Output .= $LayoutObject->Footer(
                    Type => 'Small',
                );
                return $Output;
            }
        }
    }

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

    # get params
    my %GetParam;
    for (
        qw(
            To Cc Bcc Subject Body InReplyTo References ResponseID ReplyArticleID StateID ArticleID
            IsVisibleForCustomerPresent IsVisibleForCustomer TimeUnits Year Month Day Hour Minute FormID ReplyAll
            FormDraftID Title
        )
        )
    {
        $GetParam{$_} = $ParamObject->GetParam( Param => $_ );
    }

    # Make sure sender is correct one. See bug#14872 ( https://bugs.otrs.org/show_bug.cgi?id=14872 ).
    $GetParam{From} = $Kernel::OM->Get('Kernel::System::TemplateGenerator')->Sender(
        QueueID => $Ticket{QueueID},
        UserID  => $Self->{UserID},
    );

    # hash for check duplicated entries
    my %AddressesList;

    my @MultipleCustomer;
    my $CustomersNumber = $ParamObject->GetParam( Param => 'CustomerTicketCounterToCustomer' ) || 0;
    my $Selected        = $ParamObject->GetParam( Param => 'CustomerSelected' )                || '';

    # get check item object
    my $CheckItemObject = $Kernel::OM->Get('Kernel::System::CheckItem');

    if ($CustomersNumber) {

        my $CustomerCounter = 1;
        for my $Count ( 1 ... $CustomersNumber ) {
            my $CustomerElement  = $ParamObject->GetParam( Param => 'CustomerTicketText_' . $Count );
            my $CustomerSelected = ( $Selected eq $Count ? 'checked="checked"' : '' );
            my $CustomerKey      = $ParamObject->GetParam( Param => 'CustomerKey_' . $Count )
                || '';
            my $CustomerQueue = $ParamObject->GetParam( Param => 'CustomerQueue_' . $Count )
                || '';
            if ($CustomerElement) {

                if ( $GetParam{To} ) {
                    $GetParam{To} .= ', ' . $CustomerElement;
                }
                else {
                    $GetParam{To} = $CustomerElement;
                }

                # check email address
                my $CustomerErrorMsg = 'CustomerGenericServerErrorMsg';
                my $CustomerError    = '';
                for my $Email ( Mail::Address->parse($CustomerElement) ) {
                    if ( !$CheckItemObject->CheckEmail( Address => $Email->address() ) ) {
                        $CustomerErrorMsg = $CheckItemObject->CheckErrorType()
                            . 'ServerErrorMsg';
                        $CustomerError = 'ServerError';
                    }
                }

                # check for duplicated entries
                if ( defined $AddressesList{$CustomerElement} && $CustomerError eq '' ) {
                    $CustomerErrorMsg = 'IsDuplicatedServerErrorMsg';
                    $CustomerError    = 'ServerError';
                }

                my $CustomerDisabled = '';
                my $CountAux         = $CustomerCounter++;
                if ( $CustomerError ne '' ) {
                    $CustomerDisabled = 'disabled="disabled"';
                    $CountAux         = $Count . 'Error';
                }

                if ( $CustomerQueue ne '' ) {
                    $CustomerQueue = $Count;
                }

                push @MultipleCustomer, {
                    Count            => $CountAux,
                    CustomerElement  => $CustomerElement,
                    CustomerSelected => $CustomerSelected,
                    CustomerKey      => $CustomerKey,
                    CustomerError    => $CustomerError,
                    CustomerErrorMsg => $CustomerErrorMsg,
                    CustomerDisabled => $CustomerDisabled,
                    CustomerQueue    => $CustomerQueue,
                };
                $AddressesList{$CustomerElement} = 1;
            }
        }
    }

    my @MultipleCustomerCc;
    my $CustomersNumberCc = $ParamObject->GetParam( Param => 'CustomerTicketCounterCcCustomer' ) || 0;

    if ($CustomersNumberCc) {
        my $CustomerCounterCc = 1;
        for my $Count ( 1 ... $CustomersNumberCc ) {
            my $CustomerElementCc = $ParamObject->GetParam( Param => 'CcCustomerTicketText_' . $Count );
            my $CustomerKeyCc     = $ParamObject->GetParam( Param => 'CcCustomerKey_' . $Count )
                || '';
            my $CustomerQueueCc = $ParamObject->GetParam( Param => 'CcCustomerQueue_' . $Count )
                || '';

            if ($CustomerElementCc) {

                if ( $GetParam{Cc} ) {
                    $GetParam{Cc} .= ', ' . $CustomerElementCc;
                }
                else {
                    $GetParam{Cc} = $CustomerElementCc;
                }

                # check email address
                my $CustomerErrorMsgCc = 'CustomerGenericServerErrorMsg';
                my $CustomerErrorCc    = '';
                for my $Email ( Mail::Address->parse($CustomerElementCc) ) {
                    if ( !$CheckItemObject->CheckEmail( Address => $Email->address() ) ) {
                        $CustomerErrorMsgCc = $CheckItemObject->CheckErrorType()
                            . 'ServerErrorMsg';
                        $CustomerErrorCc = 'ServerError';
                    }
                }

                # check for duplicated entries
                if ( defined $AddressesList{$CustomerElementCc} && $CustomerErrorCc eq '' ) {
                    $CustomerErrorMsgCc = 'IsDuplicatedServerErrorMsg';
                    $CustomerErrorCc    = 'ServerError';
                }

                my $CustomerDisabledCc = '';
                my $CountAuxCc         = $CustomerCounterCc++;
                if ( $CustomerErrorCc ne '' ) {
                    $CustomerDisabledCc = 'disabled="disabled"';
                    $CountAuxCc         = $Count . 'Error';
                }

                if ( $CustomerQueueCc ne '' ) {
                    $CustomerQueueCc = $Count;
                }

                push @MultipleCustomerCc, {
                    Count            => $CountAuxCc,
                    CustomerElement  => $CustomerElementCc,
                    CustomerKey      => $CustomerKeyCc,
                    CustomerError    => $CustomerErrorCc,
                    CustomerErrorMsg => $CustomerErrorMsgCc,
                    CustomerDisabled => $CustomerDisabledCc,
                    CustomerQueue    => $CustomerQueueCc,
                };
                $AddressesList{$CustomerElementCc} = 1;
            }
        }
    }

    my @MultipleCustomerBcc;
    my $CustomersNumberBcc = $ParamObject->GetParam( Param => 'CustomerTicketCounterBccCustomer' ) || 0;

    if ($CustomersNumberBcc) {
        my $CustomerCounterBcc = 1;
        for my $Count ( 1 ... $CustomersNumberBcc ) {
            my $CustomerElementBcc = $ParamObject->GetParam( Param => 'BccCustomerTicketText_' . $Count );
            my $CustomerKeyBcc     = $ParamObject->GetParam( Param => 'BccCustomerKey_' . $Count )
                || '';
            my $CustomerQueueBcc = $ParamObject->GetParam( Param => 'BccCustomerQueue_' . $Count )
                || '';

            if ($CustomerElementBcc) {

                if ( $GetParam{Bcc} ) {
                    $GetParam{Bcc} .= ', ' . $CustomerElementBcc;
                }
                else {
                    $GetParam{Bcc} = $CustomerElementBcc;
                }

                # check email address
                my $CustomerErrorMsgBcc = 'CustomerGenericServerErrorMsg';
                my $CustomerErrorBcc    = '';
                for my $Email ( Mail::Address->parse($CustomerElementBcc) ) {
                    if ( !$CheckItemObject->CheckEmail( Address => $Email->address() ) ) {
                        $CustomerErrorMsgBcc = $CheckItemObject->CheckErrorType()
                            . 'ServerErrorMsg';
                        $CustomerErrorBcc = 'ServerError';
                    }
                }

                # check for duplicated entries
                if ( defined $AddressesList{$CustomerElementBcc} && $CustomerErrorBcc eq '' ) {
                    $CustomerErrorMsgBcc = 'IsDuplicatedServerErrorMsg';
                    $CustomerErrorBcc    = 'ServerError';
                }

                my $CustomerDisabledBcc = '';
                my $CountAuxBcc         = $CustomerCounterBcc++;
                if ( $CustomerErrorBcc ne '' ) {
                    $CustomerDisabledBcc = 'disabled="disabled"';
                    $CountAuxBcc         = $Count . 'Error';
                }

                if ( $CustomerQueueBcc ne '' ) {
                    $CustomerQueueBcc = $Count;
                }

                push @MultipleCustomerBcc, {
                    Count            => $CountAuxBcc,
                    CustomerElement  => $CustomerElementBcc,
                    CustomerKey      => $CustomerKeyBcc,
                    CustomerError    => $CustomerErrorBcc,
                    CustomerErrorMsg => $CustomerErrorMsgBcc,
                    CustomerDisabled => $CustomerDisabledBcc,
                    CustomerQueue    => $CustomerQueueBcc,
                };
                $AddressesList{$CustomerElementBcc} = 1;
            }
        }
    }

    # get Dynamic fields form ParamObject
    my %DynamicFieldValues;

    # get backend object
    my $DynamicFieldBackendObject = $Kernel::OM->Get('Kernel::System::DynamicField::Backend');

    # get the dynamic fields for this screen
    my $DynamicField = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
        Valid       => 1,
        ObjectType  => [ 'Ticket', 'Article' ],
        FieldFilter => $Config->{DynamicField} || {},
    );

    # cycle trough the activated Dynamic Fields for this screen
    DYNAMICFIELD:
    for my $DynamicFieldConfig ( @{$DynamicField} ) {
        next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);

        # extract the dynamic field value from the web request
        $DynamicFieldValues{ $DynamicFieldConfig->{Name} } =
            $DynamicFieldBackendObject->EditFieldValueGet(
                DynamicFieldConfig => $DynamicFieldConfig,
                ParamObject        => $ParamObject,
                LayoutObject       => $LayoutObject,
            );
    }

    # convert dynamic field values into a structure for ACLs
    my %DynamicFieldACLParameters;
    DYNAMICFIELD:
    for my $DynamicFieldItem ( sort keys %DynamicFieldValues ) {
        next DYNAMICFIELD if !$DynamicFieldItem;
        next DYNAMICFIELD if !defined $DynamicFieldValues{$DynamicFieldItem};

        $DynamicFieldACLParameters{ 'DynamicField_' . $DynamicFieldItem } = $DynamicFieldValues{$DynamicFieldItem};
    }
    $GetParam{DynamicField} = \%DynamicFieldACLParameters;

    # transform pending time, time stamp based on user time zone
    if (
        defined $GetParam{Year}
        && defined $GetParam{Month}
        && defined $GetParam{Day}
        && defined $GetParam{Hour}
        && defined $GetParam{Minute}
        )
    {
        %GetParam = $LayoutObject->TransformDateSelection(
            %GetParam,
        );
    }

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

    # send email
    if ( $Self->{Subaction} eq 'SendEmail' || $Self->{LoadedFormDraftID} ) {

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

        # get valid state id
        if ( !$GetParam{StateID} ) {
            my %Ticket = $TicketObject->TicketGet(
                TicketID => $Self->{TicketID},
                UserID   => 1,
            );
            $GetParam{StateID} = $Ticket{StateID};
        }

        my %StateData = $Kernel::OM->Get('Kernel::System::State')->StateGet( ID => $GetParam{StateID} );

        my %Error;

        # get check item object
        my $CheckItemObject = $Kernel::OM->Get('Kernel::System::CheckItem');

        # check some values
        LINE:
        for my $Line (qw(To Cc Bcc)) {
            next LINE if !$GetParam{$Line};
            for my $Email ( Mail::Address->parse( $GetParam{$Line} ) ) {
                if ( !$CheckItemObject->CheckEmail( Address => $Email->address() ) ) {
                    $Error{ $Line . 'ErrorType' } = $Line . $CheckItemObject->CheckErrorType() . 'ServerErrorMsg';
                    $Error{ $Line . 'Invalid' }   = 'ServerError';
                }
                my $IsLocal = $Kernel::OM->Get('Kernel::System::SystemAddress')->SystemAddressIsLocalAddress(
                    Address => $Email->address()
                );
                if ($IsLocal) {
                    $Error{ $Line . 'IsLocalAddress' } = 'ServerError';
                }
            }
        }

        if ( $Error{ToIsLocalAddress} ) {
            $LayoutObject->Block(
                Name => 'ToIsLocalAddressServerErrorMsg',
                Data => \%GetParam,
            );
        }

        if ( $Error{CcIsLocalAddress} ) {
            $LayoutObject->Block(
                Name => 'CcIsLocalAddressServerErrorMsg',
                Data => \%GetParam,
            );
        }

        if ( $Error{BccIsLocalAddress} ) {
            $LayoutObject->Block(
                Name => 'BccIsLocalAddressServerErrorMsg',
                Data => \%GetParam,
            );
        }

        # get all attachments meta data
        my @Attachments = $UploadCacheObject->FormIDGetAllFilesMeta(
            FormID => $Self->{FormID},
        );

        # Get and validate draft action.
        my $FormDraftAction = $ParamObject->GetParam( Param => 'FormDraftAction' );
        if ( $FormDraftAction && !$Config->{FormDraft} ) {
            return $LayoutObject->ErrorScreen(
                Message => Translatable('FormDraft functionality disabled!'),
                Comment => Translatable('Please contact the administrator.'),
            );
        }

        my %FormDraftResponse;

        # Check draft name.
        if (
            $FormDraftAction
            && ( $FormDraftAction eq 'Add' || $FormDraftAction eq 'Update' )
            )
        {
            my $Title = $ParamObject->GetParam( Param => 'FormDraftTitle' );

            # A draft name is required.
            if ( !$Title ) {

                %FormDraftResponse = (
                    Success      => 0,
                    ErrorMessage => $Kernel::OM->Get('Kernel::Language')->Translate("Draft name is required!"),
                );
            }

            # Chosen draft name must be unique.
            else {
                my $FormDraftList = $Kernel::OM->Get('Kernel::System::FormDraft')->FormDraftListGet(
                    ObjectType => 'Ticket',
                    ObjectID   => $Self->{TicketID},
                    Action     => $Self->{Action},
                    UserID     => $Self->{UserID},
                );
                DRAFT:
                for my $FormDraft ( @{$FormDraftList} ) {

                    # No existing draft with same name.
                    next DRAFT if $Title ne $FormDraft->{Title};

                    # Same name for update on existing draft.
                    if (
                        $GetParam{FormDraftID}
                        && $FormDraftAction eq 'Update'
                        && $GetParam{FormDraftID} eq $FormDraft->{FormDraftID}
                        )
                    {
                        next DRAFT;
                    }

                    # Another draft with the chosen name already exists.
                    %FormDraftResponse = (
                        Success      => 0,
                        ErrorMessage => $Kernel::OM->Get('Kernel::Language')->Translate( "FormDraft name %s is already in use!", $Title ),
                    );
                    last DRAFT;
                }
            }
        }

        # Perform draft action instead of saving form data in ticket/article.
        if ( $FormDraftAction && !%FormDraftResponse ) {

            # Reset FormDraftID to prevent updating existing draft.
            if ( $FormDraftAction eq 'Add' && $GetParam{FormDraftID} ) {
                $ParamObject->{Query}->param(
                    -name  => 'FormDraftID',
                    -value => '',
                );
            }

            my $FormDraftActionOk;
            if (
                $FormDraftAction eq 'Add'
                ||
                ( $FormDraftAction eq 'Update' && $GetParam{FormDraftID} )
                )
            {
                $FormDraftActionOk = $ParamObject->SaveFormDraft(
                    UserID     => $Self->{UserID},
                    ObjectType => 'Ticket',
                    ObjectID   => $Self->{TicketID},
                );
            }
            elsif ( $FormDraftAction eq 'Delete' && $GetParam{FormDraftID} ) {
                $FormDraftActionOk = $Kernel::OM->Get('Kernel::System::FormDraft')->FormDraftDelete(
                    FormDraftID => $GetParam{FormDraftID},
                    UserID      => $Self->{UserID},
                );
            }

            if ($FormDraftActionOk) {
                $FormDraftResponse{Success} = 1;
            }
            else {
                %FormDraftResponse = (
                    Success      => 0,
                    ErrorMessage => 'Could not perform requested draft action!',
                );
            }
        }

        if (%FormDraftResponse) {

            # build JSON output
            my $JSON = $LayoutObject->JSONEncode(
                Data => \%FormDraftResponse,
            );

            # send JSON response
            return $LayoutObject->Attachment(
                ContentType => 'application/json; charset=' . $LayoutObject->{Charset},
                Content     => $JSON,
                Type        => 'inline',
                NoCache     => 1,
            );
        }

        # check pending date
        if ( $StateData{TypeName} && $StateData{TypeName} =~ /^pending/i ) {

            # convert pending date to a datetime object
            my $PendingDateTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    %GetParam,
                    Second => 0,
                },
            );

            # get current system epoch
            my $CurSystemDateTimeObject = $Kernel::OM->Create('Kernel::System::DateTime');

            if (
                ( !$PendingDateTimeObject || $PendingDateTimeObject < $CurSystemDateTimeObject )
                )
            {
                $Error{DateInvalid} = 'ServerError';
            }
        }

        # check if at least one recipient has been chosen
        if ( !$GetParam{To} ) {
            $Error{'ToInvalid'} = 'ServerError';
        }

        # check some values
        LINE:
        for my $Line (qw(To Cc Bcc)) {
            next LINE if !$GetParam{$Line};
            for my $Email ( Mail::Address->parse( $GetParam{$Line} ) ) {
                if ( !$CheckItemObject->CheckEmail( Address => $Email->address() ) ) {
                    $Error{ $Line . 'Invalid' } = 'ServerError';
                }
            }
        }

        # check subject
        if ( !$GetParam{Subject} ) {
            $Error{SubjectInvalid} = ' ServerError';
        }

        # check body
        if ( !$GetParam{Body} ) {
            $Error{BodyInvalid} = ' ServerError';
        }

        # check time units
        if (
            $ConfigObject->Get('Ticket::Frontend::AccountTime')
            && $ConfigObject->Get('Ticket::Frontend::NeedAccountedTime')
            && $GetParam{TimeUnits} eq ''
            )
        {
            $Error{TimeUnitsInvalid} = 'ServerError';
        }

        # prepare subject
        my $Tn = $TicketObject->TicketNumberLookup( TicketID => $Self->{TicketID} );
        $GetParam{Subject} = $TicketObject->TicketSubjectBuild(
            TicketNumber => $Tn,
            Subject      => $GetParam{Subject} || '',
        );

        my %ArticleParam;

        # run compose modules
        if ( ref $ConfigObject->Get('Ticket::Frontend::ArticleComposeModule') eq 'HASH' ) {

            # use ticket QueueID in compose modules
            $GetParam{QueueID} = $Ticket{QueueID};

            my %Jobs = %{ $ConfigObject->Get('Ticket::Frontend::ArticleComposeModule') };
            for my $Job ( sort keys %Jobs ) {

                # load module
                if ( !$MainObject->Require( $Jobs{$Job}->{Module} ) ) {
                    return $LayoutObject->FatalError();
                }
                my $Object = $Jobs{$Job}->{Module}->new( %{$Self}, Debug => $Self->{Debug} );

                my $Multiple;

                # get params
                PARAMETER:
                for my $Parameter ( $Object->Option( %GetParam, Config => $Jobs{$Job} ) ) {
                    if ( $Jobs{$Job}->{ParamType} && $Jobs{$Job}->{ParamType} ne 'Single' ) {
                        @{ $GetParam{$Parameter} } = $ParamObject->GetArray( Param => $Parameter );
                        $Multiple = 1;
                        next PARAMETER;
                    }

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

                # run module
                $Object->Run(
                    %GetParam,
                    StoreNew => 1,
                    Config   => $Jobs{$Job}
                );

                # get options that have been removed from the selection
                # and add them back to the selection so that the submit
                # will contain options that were hidden from the agent
                my $Key = $Object->Option( %GetParam, Config => $Jobs{$Job} );

                if ( $Object->can('GetOptionsToRemoveAJAX') ) {
                    my @RemovedOptions = $Object->GetOptionsToRemoveAJAX(%GetParam);
                    if (@RemovedOptions) {
                        if ($Multiple) {
                            for my $RemovedOption (@RemovedOptions) {
                                push @{ $GetParam{$Key} }, $RemovedOption;
                            }
                        }
                        else {
                            $GetParam{$Key} = shift @RemovedOptions;
                        }
                    }
                }

                # ticket params
                %ArticleParam = (
                    %ArticleParam,
                    $Object->ArticleOption( %GetParam, %ArticleParam, Config => $Jobs{$Job} ),
                );

                # get errors
                %Error = (
                    %Error,
                    $Object->Error( %GetParam, Config => $Jobs{$Job} ),
                );
            }
        }
# Rother OSS / HideShowForAgentTicketCompose

        # skip validation of hidden fields
        my %Visibility;

        # transform dynamic field data into DFName => DFName pair
        my %DynamicFieldAcl = map { $_->{Name} => $_->{Name} } @{$DynamicField};

        # call ticket ACLs for DynamicFields to check field visibility
        my $ACLResult = $TicketObject->TicketAcl(
            %GetParam,
            Action        => $Self->{Action},
            TicketID      => $Self->{TicketID},
            ReturnType    => 'Form',
            ReturnSubType => '-',
            Data          => \%DynamicFieldAcl,
            UserID        => $Self->{UserID},
        );
        if ($ACLResult) {
            %Visibility = map { 'DynamicField_' . $_->{Name} => 0 } @{$DynamicField};
            my %AclData = $TicketObject->TicketAclData();
            for my $Field ( sort keys %AclData ) {
                $Visibility{ 'DynamicField_' . $Field } = 1;
            }
        }
        else {
            %Visibility = map { 'DynamicField_' . $_->{Name} => 1 } @{$DynamicField};
        }
# EO HideShowForAgentTicketCompose

        # create html strings for all dynamic fields
        my %DynamicFieldHTML;

        # cycle trough the activated Dynamic Fields for this screen
        DYNAMICFIELD:
        for my $DynamicFieldConfig ( @{$DynamicField} ) {
            next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);

            my $PossibleValuesFilter;

            my $IsACLReducible = $DynamicFieldBackendObject->HasBehavior(
                DynamicFieldConfig => $DynamicFieldConfig,
                Behavior           => 'IsACLReducible',
            );

            if ($IsACLReducible) {

                # get PossibleValues
                my $PossibleValues = $DynamicFieldBackendObject->PossibleValuesGet(
                    DynamicFieldConfig => $DynamicFieldConfig,
                );

                # check if field has PossibleValues property in its configuration
                if ( IsHashRefWithData($PossibleValues) ) {

                    # convert possible values key => value to key => key for ACLs using a Hash slice
                    my %AclData = %{$PossibleValues};
                    @AclData{ keys %AclData } = keys %AclData;

                    # set possible values filter from ACLs
                    my $ACL = $TicketObject->TicketAcl(
                        %GetParam,
                        Action        => $Self->{Action},
                        TicketID      => $Self->{TicketID},
                        ReturnType    => 'Ticket',
                        ReturnSubType => 'DynamicField_' . $DynamicFieldConfig->{Name},
                        Data          => \%AclData,
                        UserID        => $Self->{UserID},
                    );
                    if ($ACL) {
                        my %Filter = $TicketObject->TicketAclData();

                        # convert Filer key => key back to key => value using map
                        %{$PossibleValuesFilter} = map { $_ => $PossibleValues->{$_} }
                            keys %Filter;
                    }
                }
            }

# Rother OSS / HideShowForAgentTicketCompose
#             my $ValidationResult = $DynamicFieldBackendObject->EditFieldValueValidate(
#                 DynamicFieldConfig   => $DynamicFieldConfig,
#                 PossibleValuesFilter => $PossibleValuesFilter,
#                 ParamObject          => $ParamObject,
#                 Mandatory            =>
#                     $Config->{DynamicField}->{ $DynamicFieldConfig->{Name} } == 2,
#             );
#
#             if ( !IsHashRefWithData($ValidationResult) ) {
#                 return $LayoutObject->ErrorScreen(
#                     Message => $LayoutObject->{LanguageObject}->Translate(
#                         'Could not perform validation on field %s!',
#                         $DynamicFieldConfig->{Label},
#                     ),
#                     Comment => Translatable('Please contact the administrator.'),
#                 );
#             }
#
#             # propagate validation error to the Error variable to be detected by the frontend
#             if ( $ValidationResult->{ServerError} ) {
#                 $Error{ $DynamicFieldConfig->{Name} } = ' ServerError';
#             }
            my $ValidationResult;

            # do not validate on invisible fields
            if ( $Visibility{ 'DynamicField_' . $DynamicFieldConfig->{Name} } ) {

                $ValidationResult = $DynamicFieldBackendObject->EditFieldValueValidate(
                    DynamicFieldConfig   => $DynamicFieldConfig,
                    PossibleValuesFilter => $PossibleValuesFilter,
                    ParamObject          => $ParamObject,
                    Mandatory            =>
                        $Config->{DynamicField}->{ $DynamicFieldConfig->{Name} } == 2,
                );

                if ( !IsHashRefWithData($ValidationResult) ) {
                    return $LayoutObject->ErrorScreen(
                        Message =>
                            $LayoutObject->{LanguageObject}->Translate( 'Could not perform validation on field %s!', $DynamicFieldConfig->{Label} ),
                        Comment => Translatable('Please contact the administrator.'),
                    );
                }

                # propagate validation error to the Error variable to be detected by the frontend
                if ( $ValidationResult->{ServerError} ) {
                    $Error{ $DynamicFieldConfig->{Name} } = ' ServerError';
                }
            }

# EO HideShowForAgentTicketCompose
            # get field html
            $DynamicFieldHTML{ $DynamicFieldConfig->{Name} } =
                $DynamicFieldBackendObject->EditFieldRender(
                    DynamicFieldConfig   => $DynamicFieldConfig,
                    PossibleValuesFilter => $PossibleValuesFilter,
                    Mandatory            =>
                    $Config->{DynamicField}->{ $DynamicFieldConfig->{Name} } == 2,
                    ServerError     => $ValidationResult->{ServerError}  || '',
                    ErrorMessage    => $ValidationResult->{ErrorMessage} || '',
                    LayoutObject    => $LayoutObject,
                    ParamObject     => $ParamObject,
                    AJAXUpdate      => 1,
                    UpdatableFields => $Self->_GetFieldsToUpdate(),
                );
        }

        if ( $Self->{LoadedFormDraftID} ) {

            # Make sure we don't save form if a draft was loaded.
            %Error = ( LoadedFormDraft => 1 );
        }

        # check if there is an error
        if (%Error) {

            my $Output = $LayoutObject->Header(
                Value     => $Ticket{TicketNumber},
                Type      => 'Small',
                BodyClass => 'Popup',
            );

            # When a draft is loaded, inform a user that article subject will be empty
            # if contains only the ticket hook (if nothing is modified).
            if ( $Error{LoadedFormDraft} ) {
                $Output .= $LayoutObject->Notify(
                    Data => $LayoutObject->{LanguageObject}->Translate(
                        'Article subject will be empty if the subject contains only the ticket hook!'
                    ),
                );
            }

            $GetParam{StandardResponse} = $GetParam{Body};
            $Output .= $Self->_Mask(
                TicketID   => $Self->{TicketID},
                NextStates => $Self->_GetNextStates(
                    %GetParam,
                ),
                ResponseFormat      => $LayoutObject->Ascii2Html( Text => $GetParam{Body} ),
                Errors              => \%Error,
                MultipleCustomer    => \@MultipleCustomer,
                MultipleCustomerCc  => \@MultipleCustomerCc,
                MultipleCustomerBcc => \@MultipleCustomerBcc,
                Attachments         => \@Attachments,
                GetParam            => \%GetParam,
                TicketBackType      => $TicketBackType,
                %Ticket,
                DynamicFieldHTML => \%DynamicFieldHTML,
                %GetParam,
# Rother OSS / HideShowForAgentTicketCompose
                Visibility       => \%Visibility,
# EO HideShowForAgentTicketCompose
            );
            $Output .= $LayoutObject->Footer(
                Type => 'Small',
            );
            return $Output;
        }

        # replace <OTOBO_TICKET_STATE> with next ticket state name
        if ( $StateData{Name} ) {
            $GetParam{Body} =~ s/<OTOBO_TICKET_STATE>/$StateData{Name}/g;
            $GetParam{Body} =~ s/&lt;OTOBO_TICKET_STATE&gt;/$StateData{Name}/g;
        }

        # get pre loaded attachments
        my @AttachmentData = $UploadCacheObject->FormIDGetAllFilesData(
            FormID => $Self->{FormID},
        );

        # get submit attachment
        my %UploadStuff = $ParamObject->GetUploadAll(
            Param => 'FileUpload',
        );
        if (%UploadStuff) {
            push @AttachmentData, \%UploadStuff;
        }

        # get recipients
        my $Recipients = '';
        LINE:
        for my $Line (qw(To Cc Bcc)) {

            next LINE if !$GetParam{$Line};

            if ($Recipients) {
                $Recipients .= ', ';
            }
            $Recipients .= $GetParam{$Line};
        }

        my $MimeType = 'text/plain';
        if ( $LayoutObject->{BrowserRichText} ) {
            $MimeType = 'text/html';

            # remove unused inline images
            my @NewAttachmentData;
            ATTACHMENT:
            for my $Attachment (@AttachmentData) {
                my $ContentID = $Attachment->{ContentID};
                if ( $ContentID && ( $Attachment->{ContentType} =~ /image/i ) ) {
                    my $ContentIDHTMLQuote = $LayoutObject->Ascii2Html(
                        Text => $ContentID,
                    );

                    # workaround for link encode of rich text editor, see bug#5053
                    my $ContentIDLinkEncode = $LayoutObject->LinkEncode($ContentID);
                    $GetParam{Body} =~ s/(ContentID=)$ContentIDLinkEncode/$1$ContentID/g;

                    # IF the image is referenced in the body set it as inline.
                    if ( $GetParam{Body} =~ /(\Q$ContentIDHTMLQuote\E|\Q$ContentID\E)/i ) {
                        $Attachment->{Disposition} = 'inline';
                    }
                    elsif ( $Attachment->{Disposition} eq 'inline' ) {

                        # Ignore attachment if not linked in body.
                        next ATTACHMENT;
                    }
                }

                # remember inline images and normal attachments
                push @NewAttachmentData, \%{$Attachment};
            }
            @AttachmentData = @NewAttachmentData;

            # verify HTML document
            $GetParam{Body} = $LayoutObject->RichTextDocumentComplete(
                String => $GetParam{Body},
            );
        }

        my $IsVisibleForCustomer = $Config->{IsVisibleForCustomerDefault};
        if ( $GetParam{IsVisibleForCustomerPresent} ) {
            $IsVisibleForCustomer = $GetParam{IsVisibleForCustomer} ? 1 : 0;
        }

        # Get attributes like sender address
        my %Data = $Kernel::OM->Get('Kernel::System::TemplateGenerator')->Attributes(
            TicketID => $Self->{TicketID},
            Data     => {},
            UserID   => $Self->{UserID},
        );

        # send email
        my $ArticleID = $ArticleBackendObject->ArticleSend(
            IsVisibleForCustomer => $IsVisibleForCustomer,
            SenderType           => 'agent',
            TicketID             => $Self->{TicketID},
            HistoryType          => 'SendAnswer',
            HistoryComment       => "\%\%$Recipients",
            From                 => $Data{From},
            To                   => $GetParam{To},
            Cc                   => $GetParam{Cc},
            Bcc                  => $GetParam{Bcc},
            Subject              => $GetParam{Subject},
            UserID               => $Self->{UserID},
            Body                 => $GetParam{Body},
            InReplyTo            => $GetParam{InReplyTo},
            References           => $GetParam{References},
            Charset              => $LayoutObject->{UserCharset},
            MimeType             => $MimeType,
            Attachment           => \@AttachmentData,
            %ArticleParam,
        );

        # error page
        if ( !$ArticleID ) {
            return $LayoutObject->ErrorScreen();
        }

        # time accounting
        if ( $GetParam{TimeUnits} ) {
            $TicketObject->TicketAccountTime(
                TicketID  => $Self->{TicketID},
                ArticleID => $ArticleID,
                TimeUnit  => $GetParam{TimeUnits},
                UserID    => $Self->{UserID},
            );
        }

        # set dynamic fields
        # cycle trough the activated Dynamic Fields for this screen
        DYNAMICFIELD:
        for my $DynamicFieldConfig ( @{$DynamicField} ) {
            next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);
# Rother OSS / HideShowForAgentTicketCompose
            next DYNAMICFIELD if !$Visibility{"DynamicField_$DynamicFieldConfig->{Name}"};
# EO HideShowForAgentTicketCompose

            # set the object ID (TicketID or ArticleID) depending on the field configration
            my $ObjectID = $DynamicFieldConfig->{ObjectType} eq 'Article' ? $ArticleID : $Self->{TicketID};

            # set the value
            my $Success = $DynamicFieldBackendObject->ValueSet(
                DynamicFieldConfig => $DynamicFieldConfig,
                ObjectID           => $ObjectID,
                Value              => $DynamicFieldValues{ $DynamicFieldConfig->{Name} },
                UserID             => $Self->{UserID},
            );
        }

        # set state
        $TicketObject->TicketStateSet(
            TicketID  => $Self->{TicketID},
            ArticleID => $ArticleID,
            StateID   => $GetParam{StateID},
            UserID    => $Self->{UserID},
        );

        # should I set an unlock?
        if ( $StateData{TypeName} =~ /^close/i ) {
            $TicketObject->TicketLockSet(
                TicketID => $Self->{TicketID},
                Lock     => 'unlock',
                UserID   => $Self->{UserID},
            );
        }

        # set pending time
        elsif ( $StateData{TypeName} =~ /^pending/i ) {
            $TicketObject->TicketPendingTimeSet(
                UserID   => $Self->{UserID},
                TicketID => $Self->{TicketID},
                Year     => $GetParam{Year},
                Month    => $GetParam{Month},
                Day      => $GetParam{Day},
                Hour     => $GetParam{Hour},
                Minute   => $GetParam{Minute},
            );
        }

        # log use response id and reply article id (useful for response diagnostics)
        $TicketObject->HistoryAdd(
            Name         => "ResponseTemplate ($GetParam{ResponseID}/$GetParam{ReplyArticleID}/$ArticleID)",
            HistoryType  => 'Misc',
            TicketID     => $Self->{TicketID},
            CreateUserID => $Self->{UserID},
        );

        # remove pre submited attachments
        $UploadCacheObject->FormIDRemove( FormID => $GetParam{FormID} );

        # If form was called based on a draft,
        #   delete draft since its content has now been used.
        if (
            $GetParam{FormDraftID}
            && !$Kernel::OM->Get('Kernel::System::FormDraft')->FormDraftDelete(
                FormDraftID => $GetParam{FormDraftID},
                UserID      => $Self->{UserID},
            )
            )
        {
            return $LayoutObject->ErrorScreen(
                Message => Translatable('Could not delete draft!'),
                Comment => Translatable('Please contact the administrator.'),
            );
        }

        # redirect
        if (
            $StateData{TypeName} =~ /^close/i
            && !$ConfigObject->Get('Ticket::Frontend::RedirectAfterCloseDisabled')
            )
        {
            return $LayoutObject->PopupClose(
                URL => ( $Self->{LastScreenOverview} || 'Action=AgentDashboard' ),
            );
        }

        # load new URL in parent window and close popup
        return $LayoutObject->PopupClose(
            URL => "Action=AgentTicketZoom;TicketID=$Self->{TicketID};ArticleID=$ArticleID",
        );
    }

    # check for SMIME / PGP if customer has changed
    elsif ( $Self->{Subaction} eq 'AJAXUpdate' ) {

        my @ExtendedData;

        # run compose modules
        if ( ref $ConfigObject->Get('Ticket::Frontend::ArticleComposeModule') eq 'HASH' ) {

            # use ticket QueueID in compose modules
            $GetParam{QueueID} = $Ticket{QueueID};

            my %Jobs = %{ $ConfigObject->Get('Ticket::Frontend::ArticleComposeModule') };
            JOB:
            for my $Job ( sort keys %Jobs ) {

                # load module
                next JOB if !$MainObject->Require( $Jobs{$Job}->{Module} );

                my $Object = $Jobs{$Job}->{Module}->new(
                    %{$Self},
                    Debug => $Self->{Debug},
                );

                my $Multiple;

                # get params
                PARAMETER:
                for my $Parameter ( $Object->Option( %GetParam, Config => $Jobs{$Job} ) ) {
                    if ( $Jobs{$Job}->{ParamType} && $Jobs{$Job}->{ParamType} ne 'Single' ) {
                        @{ $GetParam{$Parameter} } = $ParamObject->GetArray( Param => $Parameter );
                        $Multiple = 1;
                        next PARAMETER;
                    }

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

                # run module
                my %Data = $Object->Data( %GetParam, Config => $Jobs{$Job} );

                # get AJAX param values
                if ( $Object->can('GetParamAJAX') ) {
                    %GetParam = ( %GetParam, $Object->GetParamAJAX(%GetParam) );
                }

                # get options that have to be removed from the selection visible
                # to the agent. These options will be added again on submit.
                if ( $Object->can('GetOptionsToRemoveAJAX') ) {
                    my @OptionsToRemove = $Object->GetOptionsToRemoveAJAX(%GetParam);

                    for my $OptionToRemove (@OptionsToRemove) {
                        delete $Data{$OptionToRemove};
                    }
                }

                my $Key = $Object->Option( %GetParam, Config => $Jobs{$Job} );
                if ($Key) {
                    push(
                        @ExtendedData,
                        {
                            Name         => $Key,
                            Data         => \%Data,
                            SelectedID   => $GetParam{$Key},
                            Translation  => 1,
                            PossibleNone => 1,
                            Multiple     => $Multiple,
                            Max          => 150,
                        }
                    );
                }
            }
        }

        my $NextStates = $Self->_GetNextStates(
            %GetParam,
        );

        # update Dynamic Fields Possible Values via AJAX
        my @DynamicFieldAJAX;

# Rother OSS / HideShowForAgentTicketCompose
#         # cycle trough the activated Dynamic Fields for this screen
#         DYNAMICFIELD:
#         for my $DynamicFieldConfig ( @{$DynamicField} ) {
#             next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);
#
#             my $IsACLReducible = $DynamicFieldBackendObject->HasBehavior(
#                 DynamicFieldConfig => $DynamicFieldConfig,
#                 Behavior           => 'IsACLReducible',
#             );
#             next DYNAMICFIELD if !$IsACLReducible;
#
#             my $PossibleValues = $DynamicFieldBackendObject->PossibleValuesGet(
#                 DynamicFieldConfig => $DynamicFieldConfig,
#             );
#
#             # convert possible values key => value to key => key for ACLs using a Hash slice
#             my %AclData = %{$PossibleValues};
#             @AclData{ keys %AclData } = keys %AclData;
#
#             # set possible values filter from ACLs
#             my $ACL = $TicketObject->TicketAcl(
#                 %GetParam,
#                 Action        => $Self->{Action},
#                 TicketID      => $Self->{TicketID},
#                 QueueID       => $Self->{QueueID},
#                 ReturnType    => 'Ticket',
#                 ReturnSubType => 'DynamicField_' . $DynamicFieldConfig->{Name},
#                 Data          => \%AclData,
#                 UserID        => $Self->{UserID},
#             );
#             if ($ACL) {
#                 my %Filter = $TicketObject->TicketAclData();
#
#                 # convert Filer key => key back to key => value using map
#                 %{$PossibleValues} = map { $_ => $PossibleValues->{$_} } keys %Filter;
#             }
#
#             my $DataValues = $DynamicFieldBackendObject->BuildSelectionDataGet(
#                 DynamicFieldConfig => $DynamicFieldConfig,
#                 PossibleValues     => $PossibleValues,
#                 Value              => $DynamicFieldValues{ $DynamicFieldConfig->{Name} },
#             ) || $PossibleValues;
#
#             # add dynamic field to the list of fields to update
#             push(
#                 @DynamicFieldAJAX,
#                 {
#                     Name        => 'DynamicField_' . $DynamicFieldConfig->{Name},
#                     Data        => $DataValues,
#                     SelectedID  => $DynamicFieldValues{ $DynamicFieldConfig->{Name} },
#                     Translation => $DynamicFieldConfig->{Config}->{TranslatableValues} || 0,
#                     Max         => 100,
#                 }
#             );
#         }
        my $ElementChanged = $ParamObject->GetParam( Param => 'ElementChanged' ) || '';
        if ( $ElementChanged eq 'StateID' ) {
            $ElementChanged = 'NextStateID';
        }

        # get list type
        my $TreeView = 0;
        if ( $ConfigObject->Get('Ticket::Frontend::ListType') eq 'tree' ) {
            $TreeView = 1;
        }

        my $Autoselect = $ConfigObject->Get('TicketACL::Autoselect') || undef;
        my $ACLPreselection;
        if ( $ConfigObject->Get('TicketACL::ACLPreselection') ) {

            # get cached preselection rules
            my $CacheObject = $Kernel::OM->Get('Kernel::System::Cache');
            $ACLPreselection = $CacheObject->Get(
                Type => 'TicketACL',
                Key  => 'Preselection',
            );
            if ( !$ACLPreselection ) {
                $ACLPreselection = $FieldRestrictionsObject->SetACLPreselectionCache();
            }
        }

        my %Convergence = (
            StdFields => 0,
            Fields    => 0,
        );
        my %ChangedElements        = $ElementChanged                                        ? ( $ElementChanged => 1 ) : ();
        my %ChangedElementsDFStart = $ElementChanged                                        ? ( $ElementChanged => 1 ) : ();
        my %ChangedStdFields       = $ElementChanged && $ElementChanged !~ /^DynamicField_/ ? ( $ElementChanged => 1 ) : ();

        my $LoopProtection = 100;
        my %StdFieldValues;
        my %DynFieldStates = (
            Visibility => {},
            Fields     => {},
        );

        until ( $Convergence{Fields} ) {

            # determine standard field input
            until ( $Convergence{StdFields} ) {

                my %NewChangedElements;

                # which standard fields to check - FieldID => GetParamValue (neccessary for Dest)
                my %Check = (
                    NextStateID => 'NextStateID',
                );
                if ($ACLPreselection) {
                    FIELD:
                    for my $FieldID ( sort keys %Check ) {
                        if ( !$ACLPreselection->{Fields}{$FieldID} ) {
                            $Kernel::OM->Get('Kernel::System::Log')->Log(
                                Priority => 'debug',
                                Message  => "$FieldID not defined in TicketACL preselection rules!"
                            );
                            next FIELD;
                        }
                        if ( $Autoselect && $Autoselect->{$FieldID} && $ChangedElements{$FieldID} ) {
                            next FIELD;
                        }
                        for my $Element ( sort keys %ChangedElements ) {
                            if (
                                $ACLPreselection->{Rules}{Ticket}{$Element}{$FieldID}
                                || $Self->{InternalDependancy}{$Element}{$FieldID}
                                )
                            {
                                next FIELD;
                            }
                            if ( !$ACLPreselection->{Fields}{$Element} ) {
                                $Kernel::OM->Get('Kernel::System::Log')->Log(
                                    Priority => 'debug',
                                    Message  => "$Element not defined in TicketACL preselection rules!"
                                );
                                next FIELD;
                            }
                        }

                        # delete unaffected fields
                        delete $Check{$FieldID};
                    }
                }

                # check value of state
                $NextStates = $Self->_GetNextStates(
                    %GetParam,
                );

                # check whether current selected value is still valid for the field
                if ( $GetParam{StateID} && !$NextStates->{ $GetParam{StateID} } ) {

                    # if not empty the field
                    $GetParam{StateID}               = '';
                    $NewChangedElements{NextStateID} = 1;
                    $ChangedStdFields{NextStateID}   = 1;
                }

                # autoselect
                elsif ( !$GetParam{StateID} && $Autoselect && $Autoselect->{NextStateID} ) {
                    $GetParam{StateID} = $FieldRestrictionsObject->Autoselect(
                        PossibleValues => $NextStates,
                    ) || '';
                    if ( $GetParam{StateID} ) {
                        $NewChangedElements{NextStateID} = 1;
                        $ChangedStdFields{NextStateID}   = 1;
                    }
                }

                if ( !%NewChangedElements ) {
                    $Convergence{StdFields} = 1;
                }
                else {
                    %ChangedElements = %NewChangedElements;
                }

                %ChangedElementsDFStart = (
                    %ChangedElementsDFStart,
                    %NewChangedElements,
                );

                if ( $LoopProtection-- < 1 ) {
                    $Kernel::OM->Get('Kernel::System::Log')->Log(
                        Priority => 'error',
                        Message  => "Ran into unresolvable loop!",
                    );
                    return;
                }

            }

            %ChangedElements        = %ChangedElementsDFStart;
            %ChangedElementsDFStart = ();

            # check dynamic fields
            my %CurFieldStates;
            if (%ChangedElements) {

                # get values and visibility of dynamic fields
                %CurFieldStates = $FieldRestrictionsObject->GetFieldStates(
                    TicketObject              => $TicketObject,
                    DynamicFields             => $DynamicField,
                    DynamicFieldBackendObject => $DynamicFieldBackendObject,
                    ChangedElements           => \%ChangedElements,            # optional to reduce ACL evaluation
                    Action                    => $Self->{Action},
                    UserID                    => $Self->{UserID},
                    TicketID                  => $Self->{TicketID},
                    FormID                    => $Self->{FormID},
                    CustomerUser              => $Selected || '',
                    GetParam                  => {
                        %GetParam,
                        NextStateID => $GetParam{StateID},
                        StateID     => undef,
                    },
                    Autoselect      => $Autoselect,
                    ACLPreselection => $ACLPreselection,
                    LoopProtection  => \$LoopProtection,
                );

                # combine FieldStates
                $DynFieldStates{Fields} = {
                    %{ $DynFieldStates{Fields} },
                    %{ $CurFieldStates{Fields} },
                };
                $DynFieldStates{Visibility} = {
                    %{ $DynFieldStates{Visibility} },
                    %{ $CurFieldStates{Visibility} },
                };

                # store new values
                $GetParam{DynamicField} = {
                    %{ $GetParam{DynamicField} },
                    %{ $CurFieldStates{NewValues} },
                };
            }

            # if dynamic fields changed, check standard fields again
            if ( %CurFieldStates && IsHashRefWithData( $CurFieldStates{NewValues} ) ) {
                $Convergence{StdFields} = 0;
                %ChangedElements = map { $_ => 1 } keys %{ $CurFieldStates{NewValues} };
            }
            else {
                $Convergence{Fields} = 1;
            }

        }

        # cycle through the activated Dynamic Fields for this screen
        DYNAMICFIELD:
        for my $Index ( sort keys %{ $DynFieldStates{Fields} } ) {
            my $DynamicFieldConfig = $DynamicField->[$Index];

            my $DataValues = $DynFieldStates{Fields}{$Index}{NotACLReducible}
                ? $GetParam{DynamicField}{"DynamicField_$DynamicFieldConfig->{Name}"}
                :
                (
                    $DynamicFieldBackendObject->BuildSelectionDataGet(
                        DynamicFieldConfig => $DynamicFieldConfig,
                        PossibleValues     => $DynFieldStates{Fields}{$Index}{PossibleValues},
                        Value              => $GetParam{DynamicField}{"DynamicField_$DynamicFieldConfig->{Name}"},
                    )
                    || $DynFieldStates{Fields}{$Index}{PossibleValues}
                );

            # add dynamic field to the list of fields to update
            push @DynamicFieldAJAX, {
                Name        => 'DynamicField_' . $DynamicFieldConfig->{Name},
                Data        => $DataValues,
                SelectedID  => $GetParam{DynamicField}{"DynamicField_$DynamicFieldConfig->{Name}"},
                Translation => $DynamicFieldConfig->{Config}->{TranslatableValues} || 0,
                Max         => 100,
            };
        }

        if ( IsHashRefWithData( $DynFieldStates{Visibility} ) ) {
            push @DynamicFieldAJAX, {
                Name => 'Restrictions_Visibility',
                Data => $DynFieldStates{Visibility},
            };
        }

# EO HideShowForAgentTicketCompose
        my $JSON = $LayoutObject->BuildSelectionJSON(
            [
                @ExtendedData,
                {
                    Name         => 'StateID',
                    Data         => $NextStates,
                    SelectedID   => $GetParam{StateID},
                    Translation  => 1,
                    PossibleNone => 1,
                    Max          => 100,
                },
                @DynamicFieldAJAX,

            ],
        );
        return $LayoutObject->Attachment(
            ContentType => 'application/json; charset=' . $LayoutObject->{Charset},
            Content     => $JSON,
            Type        => 'inline',
            NoCache     => 1,
        );
    }
    else {
        my $Output = $LayoutObject->Header(
            Value     => $Ticket{TicketNumber},
            Type      => 'Small',
            BodyClass => 'Popup',
        );

        # get std attachment object
        my $StdAttachmentObject = $Kernel::OM->Get('Kernel::System::StdAttachment');

        # add std. attachments to email
        if ( $GetParam{ResponseID} ) {
            my %AllStdAttachments = $StdAttachmentObject->StdAttachmentStandardTemplateMemberList(
                StandardTemplateID => $GetParam{ResponseID},
            );
            for ( sort keys %AllStdAttachments ) {
                my %Data = $StdAttachmentObject->StdAttachmentGet( ID => $_ );
                $UploadCacheObject->FormIDAddFile(
                    FormID      => $Self->{FormID},
                    Disposition => 'attachment',
                    %Data,
                );
            }
        }

        # get all attachments meta data
        my @Attachments = $UploadCacheObject->FormIDGetAllFilesMeta(
            FormID => $Self->{FormID},
        );

        # get last customer article or selected article ...
        my @ArticleList;

        if ( $GetParam{ArticleID} ) {

            @ArticleList = $ArticleObject->ArticleList(
                TicketID  => $Self->{TicketID},
                ArticleID => $GetParam{ArticleID},
            );
        }
        else {

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

        my %Data;

        ARTICLEMETADATA:
        for my $ArticleMetaData (@ArticleList) {

            next ARTICLEMETADATA if !$ArticleMetaData;
            next ARTICLEMETADATA if !IsHashRefWithData($ArticleMetaData);

            my $CurrentArticleBackendObject = $ArticleObject->BackendForArticle( %{$ArticleMetaData} );

            %Data = $CurrentArticleBackendObject->ArticleGet(
                TicketID  => $Self->{TicketID},
                ArticleID => $ArticleMetaData->{ArticleID},
            );

            $Data{CommunicationChannelName} = $CurrentArticleBackendObject->ChannelNameGet();

            last ARTICLEMETADATA;
        }

        # Merge ticket data with article data, see bug#13995 (https://bugs.otrs.org/show_bug.cgi?id=13995).
        %Data = ( %Ticket, %Data );

        # If article is not a MIMEBase article, get customer recipients from the backend.
        if ( !$Data{To} && !$Data{From} ) {
            my @CustomerUserIDs = $LayoutObject->ArticleCustomerRecipientsGet(
                TicketID  => $Self->{TicketID},
                ArticleID => $Data{ArticleID},
                UserID    => $Self->{UserID},
            );

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

            my @CustomerRecipients;

            CUSTOMER_USER_ID:
            for my $CustomerUserID (@CustomerUserIDs) {
                my %Customer = $CustomerUserObject->CustomerUserDataGet(
                    User => $CustomerUserID,
                );
                next CUSTOMER_USER_ID if !%Customer;

                push @CustomerRecipients, "\"$Customer{UserFirstname} $Customer{UserLastname}\" <$Customer{UserEmail}>";
            }

            $Data{To} = join( ',', @CustomerRecipients ) // '';

            # Include sender name in 'From' field for correct quoting.
            my %ArticleFields = $LayoutObject->ArticleFields(
                TicketID  => $Self->{TicketID},
                ArticleID => $Data{ArticleID},
            );
            $Data{From} = $ArticleFields{Sender}->{Value} // '';
        }

        # set OrigFrom for correct email quoting (xxxx wrote)
        $Data{OrigFrom} = $Data{From};

        # check article type and replace To with From (in case)
        if ( $Data{SenderType} !~ /customer/ ) {

            # replace From/To, To/From because sender is agent
            my $To = $Data{To};
            $Data{To}   = $Data{From};
            $Data{From} = $To;

            $Data{ReplyTo} = '';
        }

        # build OrigFromName (to only use the realname)
        $Data{OrigFromName} = $Data{OrigFrom};
        $Data{OrigFromName} =~ s/<.*>|\(.*\)|\"|;|,//g;
        $Data{OrigFromName} =~ s/( $)|(  $)//g;

        # Fallback to OrigFrom if realname part is empty.
        if ( !$Data{OrigFromName} ) {
            $Data{OrigFromName} = $Data{OrigFrom};
        }

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

        # get article to quote
        $Data{Body} = $LayoutObject->ArticleQuote(
            TicketID          => $Self->{TicketID},
            ArticleID         => $Data{ArticleID},
            FormID            => $Self->{FormID},
            UploadCacheObject => $UploadCacheObject,
        );

        my %SafetyCheckResult = $Kernel::OM->Get('Kernel::System::HTMLUtils')->Safety(
            String => $Data{Body},

            # Strip out external content if BlockLoadingRemoteContent is enabled.
            NoExtSrcLoad => $ConfigObject->Get('Ticket::Frontend::BlockLoadingRemoteContent'),

            # Disallow potentially unsafe content.
            NoApplet     => 1,
            NoObject     => 1,
            NoEmbed      => 1,
            NoSVG        => 1,
            NoJavaScript => 1,
        );
        $Data{Body} = $SafetyCheckResult{String};

        # restrict number of body lines if configured
        if (
            $Data{Body}
            && $ConfigObject->Get('Ticket::Frontend::ResponseQuoteMaxLines')
            )
        {
            my $MaxLines = $ConfigObject->Get('Ticket::Frontend::ResponseQuoteMaxLines');

            # split body - one element per line
            my @Body = split "\n", $Data{Body};

            # only modify if body is longer than allowed
            if ( scalar @Body > $MaxLines ) {

                # splice to max. allowed lines and reassemble
                @Body       = @Body[ 0 .. ( $MaxLines - 1 ) ];
                $Data{Body} = join "\n", @Body;
            }
        }

        if ( $LayoutObject->{BrowserRichText} ) {

            # prepare body, subject, ReplyTo ...
            # rewrap body if exists
            if ( $Data{Body} ) {
                $Data{Body} =~ s/\t/ /g;
                my $Quote = $LayoutObject->Ascii2Html(
                    Text           => $ConfigObject->Get('Ticket::Frontend::Quote') || '',
                    HTMLResultMode => 1,
                );
                if ($Quote) {

                    # quote text
                    $Data{Body} = "<blockquote type=\"cite\">$Data{Body}</blockquote>\n";

                    # cleanup not compat. tags
                    $Data{Body} = $LayoutObject->RichTextDocumentCleanup(
                        String => $Data{Body},
                    );

                }
                else {
                    $Data{Body} = "<br/>" . $Data{Body};

                    if ( $Data{CreateTime} ) {
                        $Data{Body} = $LayoutObject->{LanguageObject}->Translate('Date') .
                            ": $Data{CreateTime}<br/>" . $Data{Body};
                    }

                    for (qw(Subject ReplyTo Reply-To Cc To From)) {
                        if ( $Data{$_} ) {
                            $Data{Body} = $LayoutObject->{LanguageObject}->Translate($_) .
                                ": $Data{$_}<br/>" . $Data{Body};
                        }
                    }

                    my $From = $LayoutObject->Ascii2RichText(
                        String => $Data{From},
                    );

                    my $MessageFrom = $LayoutObject->{LanguageObject}->Translate('Message from');
                    my $EndMessage  = $LayoutObject->{LanguageObject}->Translate('End message');

                    $Data{Body} = "<br/>---- $MessageFrom $From ---<br/><br/>" . $Data{Body};
                    $Data{Body} .= "<br/>---- $EndMessage ---<br/>";
                }
            }
        }
        else {

            # prepare body, subject, ReplyTo ...
            # re-wrap body if exists
            if ( $Data{Body} ) {
                $Data{Body} =~ s/\t/ /g;
                my $Quote = $ConfigObject->Get('Ticket::Frontend::Quote');
                if ($Quote) {
                    $Data{Body} =~ s/\n/\n$Quote /g;
                    $Data{Body} = "\n$Quote " . $Data{Body};
                }
                else {
                    $Data{Body} = "\n" . $Data{Body};
                    if ( $Data{CreateTime} ) {
                        $Data{Body} = $LayoutObject->{LanguageObject}->Translate('Date') .
                            ": $Data{CreateTime}\n" . $Data{Body};
                    }

                    for (qw(Subject ReplyTo Reply-To Cc To From)) {
                        if ( $Data{$_} ) {
                            $Data{Body} = $LayoutObject->{LanguageObject}->Translate($_) .
                                ": $Data{$_}\n" . $Data{Body};
                        }
                    }

                    my $MessageFrom = $LayoutObject->{LanguageObject}->Translate('Message from');
                    my $EndMessage  = $LayoutObject->{LanguageObject}->Translate('End message');

                    $Data{Body} = "\n---- $MessageFrom $Data{From} ---\n\n" . $Data{Body};
                    $Data{Body} .= "\n---- $EndMessage ---\n";
                }
            }
        }

        # get system address object
        my $SystemAddress = $Kernel::OM->Get('Kernel::System::SystemAddress');

        # add not local To addresses to Cc
        for my $Email ( Mail::Address->parse( $Data{To} ) ) {
            my $IsLocal = $SystemAddress->SystemAddressIsLocalAddress(
                Address => $Email->address(),
            );
            if ( !$IsLocal ) {
                if ( $Data{Cc} ) {
                    $Data{Cc} .= ', ';
                }
                $Data{Cc} .= $Email->format();
            }
        }

        # check ReplyTo
        if ( $Data{ReplyTo} ) {
            $Data{To} = $Data{ReplyTo};
        }
        else {
            $Data{To} = $Data{From};

            # try to remove some wrong text to from line (by way of ...)
            # added by some strange mail programs on bounce
            $Data{To} =~ s/(.+?\<.+?\@.+?\>)\s+\(by\s+way\s+of\s+.+?\)/$1/ig;
        }

        # get to email (just "some@example.com")
        for my $Email ( Mail::Address->parse( $Data{To} ) ) {
            $Data{ToEmail} = $Email->address();
        }

        # only reply to sender
        if ( !$GetParam{ReplyAll} ) {
            $Data{Cc}  = '';
            $Data{Bcc} = '';
        }

        # use customer database email
        # do not add customer email to cc, if article is visible for customer
        if (
            $ConfigObject->Get('Ticket::Frontend::ComposeAddCustomerAddress')
            && $Data{IsVisibleForCustomer}
            )
        {
            # check if customer is in recipient list
            if ( $Customer{UserEmail} && $Data{ToEmail} !~ /^\Q$Customer{UserEmail}\E$/i ) {

                if ( $Data{SenderType} eq 'agent' && !$Data{IsVisibleForCustomer} ) {
                    if ( $Data{To} ) {
                        $Data{To} .= ', ' . $Customer{UserEmail};
                    }
                    else {
                        $Data{To} = $Customer{UserEmail};
                    }
                }

                # replace To with customers database address
                elsif ( $ConfigObject->Get('Ticket::Frontend::ComposeReplaceSenderAddress') ) {

                    $Output .= $LayoutObject->Notify(
                        Data => $LayoutObject->{LanguageObject}->Translate(
                            'Address %s replaced with registered customer address.',
                            $Data{ToEmail},
                        ),

                    );
                    $Data{To} = $Customer{UserEmail};
                }

                # add customers database address to Cc
                else {
                    $Output .= $LayoutObject->Notify(
                        Info => Translatable("Customer user automatically added in Cc."),
                    );
                    if ( $Data{Cc} ) {
                        $Data{Cc} .= ', ' . $Customer{UserEmail};
                    }
                    else {
                        $Data{Cc} = $Customer{UserEmail};
                    }
                }
            }
        }

        # find duplicate addresses
        my %Recipient;
        for my $Type (qw(To Cc Bcc)) {
            if ( $Data{$Type} ) {
                my $NewLine = '';
                for my $Email ( Mail::Address->parse( $Data{$Type} ) ) {
                    my $Address = lc $Email->address();

                    # only use email addresses with @ inside
                    if ( $Address && $Address =~ /@/ && !$Recipient{$Address} ) {
                        $Recipient{$Address} = 1;
                        my $IsLocal = $SystemAddress->SystemAddressIsLocalAddress(
                            Address => $Address,
                        );
                        if ( !$IsLocal ) {
                            if ($NewLine) {
                                $NewLine .= ', ';
                            }
                            $NewLine .= $Email->format();
                        }
                    }
                }
                $Data{$Type} = $NewLine;
            }
        }

        # get template
        my $TemplateGenerator = $Kernel::OM->Get('Kernel::System::TemplateGenerator');

        # use key StdResponse to pass the data to the template for legacy reasons,
        #   because existing systems may have it in their configuration as that was
        #   the key used before the internal switch to StandardResponse And StandardTemplate

        $Data{StdResponse} = $TemplateGenerator->Template(
            TicketID   => $Self->{TicketID},
            ArticleID  => $GetParam{ArticleID},
            TemplateID => $GetParam{ResponseID},
            Data       => \%Data,
            UserID     => $Self->{UserID},
        );

        # get salutation
        $Data{Salutation} = $TemplateGenerator->Salutation(
            TicketID => $Self->{TicketID},
            Data     => \%Data,
            UserID   => $Self->{UserID},
        );

        # get signature
        $Data{Signature} = $TemplateGenerator->Signature(
            TicketID => $Self->{TicketID},
            Data     => \%Data,
            UserID   => $Self->{UserID},
        );

        # $TemplateGenerator->Attributes() does not overwrite %Data, but it adds more keys
        %Data = $TemplateGenerator->Attributes(
            TicketID  => $Self->{TicketID},
            ArticleID => $GetParam{ArticleID},
            Data      => \%Data,
            UserID    => $Self->{UserID},
        );

        my $ResponseFormat = $ConfigObject->Get('Ticket::Frontend::ResponseFormat');

        # make sure body is rich text
        my %DataHTML = %Data;
        if ( $LayoutObject->{BrowserRichText} ) {
            if ($ResponseFormat) {
                $ResponseFormat = $LayoutObject->Ascii2RichText(
                    String => $ResponseFormat,
                );

                # restore qdata formatting for Output replacement
                $ResponseFormat =~ s/&quot;/"/gi;

                # html quote to have it correct in edit area
                $ResponseFormat = $LayoutObject->Ascii2Html(
                    Text => $ResponseFormat,
                );

                # restore qdata formatting for Output replacement
                $ResponseFormat =~ s/&quot;/"/gi;
            }

            # quote all non html content to have it correct in edit area
            KEY:
            for my $Key ( sort keys %DataHTML ) {
                next KEY if !$DataHTML{$Key};
                next KEY if $Key eq 'Salutation';
                next KEY if $Key eq 'Body';
                next KEY if $Key eq 'StdResponse';
                next KEY if $Key eq 'Signature';
                $DataHTML{$Key} = $LayoutObject->Ascii2RichText(
                    String => $DataHTML{$Key},
                );
            }
        }

        # build new repsonse format based on template
        $Data{ResponseFormat} = $LayoutObject->Output(
            Template => $ResponseFormat,
            Data     => { %Param, %DataHTML },
        );

        # check some values
        my %Error;
        LINE:
        for my $Line (qw(To Cc Bcc)) {
            next LINE if !$Data{$Line};
            for my $Email ( Mail::Address->parse( $Data{$Line} ) ) {
                if ( !$CheckItemObject->CheckEmail( Address => $Email->address() ) ) {
                    $Error{ $Line . "Invalid" } = " ServerError";
                }
            }
        }
        if ( $Data{From} ) {
            for my $Email ( Mail::Address->parse( $Data{From} ) ) {
                if ( !$CheckItemObject->CheckEmail( Address => $Email->address() ) ) {
                    $Error{"FromInvalid"} .= $CheckItemObject->CheckError();
                }
            }
        }
# Rother OSS / HideShowForAgentTicketCompose

        # get list type
        my $TreeView = 0;
        if ( $ConfigObject->Get('Ticket::Frontend::ListType') eq 'tree' ) {
            $TreeView = 1;
        }

        my $Autoselect = $ConfigObject->Get('TicketACL::Autoselect') || undef;

        # gather fields which are supposed to be hidden when autoselected
        my $HideAutoselectedJSON;
        if ($Autoselect) {
            my @HideAutoselected = grep { !ref( $Autoselect->{$_} ) && $Autoselect->{$_} == 2 } keys %{$Autoselect};
            for my $Item (@HideAutoselected) {
                $Item = 'StateID';
            }
            if ( $Autoselect->{DynamicField} ) {
                push @HideAutoselected,
                    map { "DynamicField_" . $_ }
                    ( grep { $Autoselect->{DynamicField}{$_} == 2 } keys %{ $Autoselect->{DynamicField} } );
            }

            if (@HideAutoselected) {
                my $JSONObject = $Kernel::OM->Get('Kernel::System::JSON');
                $HideAutoselectedJSON = $JSONObject->Encode(
                    Data => \@HideAutoselected,
                );
            }
        }

        my $ACLPreselection;
        if ( $ConfigObject->Get('TicketACL::ACLPreselection') ) {

            # get cached preselection rules
            my $CacheObject = $Kernel::OM->Get('Kernel::System::Cache');
            $ACLPreselection = $CacheObject->Get(
                Type => 'TicketACL',
                Key  => 'Preselection',
            );
            if ( !$ACLPreselection ) {
                $ACLPreselection = $FieldRestrictionsObject->SetACLPreselectionCache();
            }
        }

        my %Convergence = (
            StdFields => 0,
            Fields    => 0,
        );
        my %ChangedElements        = ();
        my %ChangedElementsDFStart = ();
        my %ChangedStdFields;

        my $LoopProtection = 100;
        my %StdFieldValues;
        my %DynFieldStates = (
            Visibility => {},
            Fields     => {},
        );

        my $InitialRun = 1;

        # handle default values for standard fields
        if ( $Config->{StateDefault} ) {

            my $NextStates = $Self->_GetNextStates(
                %GetParam,
            );

            $GetParam{StateID} //= { reverse $NextStates->%* }->{ $Config->{StateDefault} };
        }
        if ( $Config->{IsVisibleForCustomerDefault} ) {

            $GetParam{IsVisibleForCustomer} //= $Config->{IsVisibleForCustomerDefault};
        }

        until ( $Convergence{Fields} ) {

            # determine standard field input
            until ( $Convergence{StdFields} ) {

                my %NewChangedElements;

                # which standard fields to check - FieldID => GetParamValue (neccessary for Dest)
                my %Check = (
                    NextStateID => 'NextStateID',
                );
                if ( $ACLPreselection && !$InitialRun ) {
                    FIELD:
                    for my $FieldID ( sort keys %Check ) {
                        if ( !$ACLPreselection->{Fields}{$FieldID} ) {
                            $Kernel::OM->Get('Kernel::System::Log')->Log(
                                Priority => 'debug',
                                Message  => "$FieldID not defined in TicketACL preselection rules!"
                            );
                            next FIELD;
                        }
                        if ( $Autoselect && $Autoselect->{$FieldID} && $ChangedElements{$FieldID} ) {
                            next FIELD;
                        }
                        for my $Element ( sort keys %ChangedElements ) {
                            if (
                                $ACLPreselection->{Rules}{Ticket}{$Element}{$FieldID}
                                || $Self->{InternalDependancy}{$Element}{$FieldID}
                                )
                            {
                                next FIELD;
                            }
                            if ( !$ACLPreselection->{Fields}{$Element} ) {
                                $Kernel::OM->Get('Kernel::System::Log')->Log(
                                    Priority => 'debug',
                                    Message  => "$Element not defined in TicketACL preselection rules!"
                                );
                                next FIELD;
                            }
                        }

                        # delete unaffected fields
                        delete $Check{$FieldID};
                    }
                }

                # check value of state
                my $NextStates = $Self->_GetNextStates(
                    %GetParam,
                );

                # check whether current selected value is still valid for the field
                if ( $GetParam{StateID} && !$NextStates->{ $GetParam{StateID} } ) {

                    # if not empty the field
                    $GetParam{StateID}               = '';
                    $NewChangedElements{NextStateID} = 1;
                    $ChangedStdFields{NextStateID}   = 1;
                }

                # autoselect
                elsif ( !$GetParam{StateID} && $Autoselect && $Autoselect->{NextStateID} ) {
                    $GetParam{StateID} = $FieldRestrictionsObject->Autoselect(
                        PossibleValues => $NextStates,
                    ) || '';
                    if ( $GetParam{StateID} ) {
                        $NewChangedElements{NextStateID} = 1;
                        $ChangedStdFields{NextStateID}   = 1;
                    }
                }

                if ( !%NewChangedElements ) {
                    $Convergence{StdFields} = 1;
                }
                else {
                    %ChangedElements = %NewChangedElements;
                }

                %ChangedElementsDFStart = (
                    %ChangedElementsDFStart,
                    %NewChangedElements,
                );

                if ( $LoopProtection-- < 1 ) {
                    $Kernel::OM->Get('Kernel::System::Log')->Log(
                        Priority => 'error',
                        Message  => "Ran into unresolvable loop!",
                    );
                    return;
                }

            }

            %ChangedElements        = %ChangedElementsDFStart;
            %ChangedElementsDFStart = ();

            # check dynamic fields
            my %CurFieldStates;
            if ( %ChangedElements || $InitialRun ) {

                # get values and visibility of dynamic fields
                %CurFieldStates = $FieldRestrictionsObject->GetFieldStates(
                    TicketObject              => $TicketObject,
                    DynamicFields             => $DynamicField,
                    DynamicFieldBackendObject => $DynamicFieldBackendObject,
                    ChangedElements           => \%ChangedElements,             # optional to reduce ACL evaluation
                    Action                    => $Self->{Action},
                    UserID                    => $Self->{UserID},
                    TicketID                  => $Self->{TicketID},
                    FormID                    => $Self->{FormID},
                    CustomerUser              => $Ticket{CustomerUser} || '',
                    GetParam                  => {
                        %GetParam,
                        NextStateID => $GetParam{StateID},
                        StateID     => undef,
                    },
                    Autoselect      => $Autoselect,
                    ACLPreselection => $ACLPreselection,
                    LoopProtection  => \$LoopProtection,
                );

                # combine FieldStates
                $DynFieldStates{Fields} = {
                    %{ $DynFieldStates{Fields} },
                    %{ $CurFieldStates{Fields} },
                };
                $DynFieldStates{Visibility} = {
                    %{ $DynFieldStates{Visibility} },
                    %{ $CurFieldStates{Visibility} },
                };

                # store new values
                $GetParam{DynamicField} = {
                    %{ $GetParam{DynamicField} },
                    %{ $CurFieldStates{NewValues} },
                };
            }

            # if dynamic fields changed, check standard fields again
            if ( %CurFieldStates && IsHashRefWithData( $CurFieldStates{NewValues} ) ) {
                $Convergence{StdFields} = 0;
                %ChangedElements = map { $_ => 1 } keys %{ $CurFieldStates{NewValues} };
            }
            else {
                $Convergence{Fields} = 1;
            }

            $InitialRun = 0;
        }
# EO HideShowForAgentTicketCompose

        # create html strings for all dynamic fields
        my %DynamicFieldHTML;

        # cycle trough the activated Dynamic Fields for this screen
# Rother OSS / HideShowForAgentTicketCompose
#         DYNAMICFIELD:
#         for my $DynamicFieldConfig ( @{$DynamicField} ) {
#             next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);
#
#             my $PossibleValuesFilter;
        DYNAMICFIELD:
        for my $i ( 0 .. $#{$DynamicField} ) {
            next DYNAMICFIELD if !IsHashRefWithData( $DynamicField->[$i] );

            my $DynamicFieldConfig = $DynamicField->[$i];

            # don't set a default value for hidden fields
            my %UseDefault = ();
            if (
                !$DynFieldStates{Visibility}{"DynamicField_$DynamicFieldConfig->{Name}"}
                && ( $DynamicFieldConfig->{FieldType} ne 'Date' || $DynamicFieldConfig->{FieldType} ne 'DateTime' )
                )
            {
                %UseDefault = (
                    UseDefaultValue      => 0,
                    OverridePossibleNone => 1,
                );
            }
# EO HideShowForAgentTicketCompose

            # to store dynamic field value from database (or undefined)
            my $Value;

            # only get values for Ticket fields (all screens based on AgentTicketActionCommon
            # generate a new article, then article fields will be always empty at the beginign)
# Rother OSS / HideShowForAgentTicketCompose
#             if ( $DynamicFieldConfig->{ObjectType} eq 'Ticket' ) {
            if (
                $DynamicFieldConfig->{ObjectType} eq 'Ticket'
                && (
                    !IsHashRefWithData( $DynFieldStates{Visibility} )
                    || $DynFieldStates{Visibility}{ 'DynamicField_' . $DynamicFieldConfig->{Name} }
                )
                )
            {
# EO HideShowForAgentTicketCompose

                # get value stored on the database from Ticket
                $Value = $Ticket{ 'DynamicField_' . $DynamicFieldConfig->{Name} };
            }

            # get field html
            $DynamicFieldHTML{ $DynamicFieldConfig->{Name} } =
                $DynamicFieldBackendObject->EditFieldRender(
                    DynamicFieldConfig => $DynamicFieldConfig,
# Rother OSS / HideShowForAgentTicketCompose
#                     PossibleValuesFilter => $PossibleValuesFilter,
                    PossibleValuesFilter => defined $DynFieldStates{Fields}{$i}
                    ? $DynFieldStates{Fields}{$i}{PossibleValues}
                    : undef,
# EO HideShowForAgentTicketCompose
                    Value     => $Value,
                    Mandatory =>
                    $Config->{DynamicField}->{ $DynamicFieldConfig->{Name} } == 2,
                    LayoutObject    => $LayoutObject,
                    ParamObject     => $ParamObject,
                    AJAXUpdate      => 1,
                    UpdatableFields => $Self->_GetFieldsToUpdate(),
# Rother OSS / HideShowForAgentTicketCompose
                    %UseDefault,
# EO HideShowForAgentTicketCompose
                );
        }

        # build references if exist
        my $References = ( $Data{MessageID} || '' ) . ( $Data{References} || '' );

        # run compose modules
        if ( ref $ConfigObject->Get('Ticket::Frontend::ArticleComposeModule') eq 'HASH' ) {

            # use ticket QueueID in compose modules
            $GetParam{QueueID} = $Ticket{QueueID};

            my %Jobs = %{ $ConfigObject->Get('Ticket::Frontend::ArticleComposeModule') };
            for my $Job ( sort keys %Jobs ) {

                # load module
                if ( !$MainObject->Require( $Jobs{$Job}->{Module} ) ) {
                    return $LayoutObject->FatalError();
                }
                my $Object = $Jobs{$Job}->{Module}->new( %{$Self}, Debug => $Self->{Debug} );

                # get params
                PARAMETER:
                for my $Parameter ( $Object->Option( %GetParam, Config => $Jobs{$Job} ) ) {
                    if ( $Jobs{$Job}->{ParamType} && $Jobs{$Job}->{ParamType} ne 'Single' ) {
                        @{ $GetParam{$Parameter} } = $ParamObject->GetArray( Param => $Parameter );
                        next PARAMETER;
                    }

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

                # run module
                my $NewParams = $Object->Run( %GetParam, Config => $Jobs{$Job} );

                if ($NewParams) {
                    for my $Parameter ( $Object->Option( %GetParam, Config => $Jobs{$Job} ) ) {
                        $GetParam{$Parameter} = $NewParams;
                    }
                }

                # get errors
                %Error = (
                    %Error,
                    $Object->Error( %GetParam, Config => $Jobs{$Job} ),
                );
            }
        }

        # build view ...
        $Output .= $Self->_Mask(
            TicketID   => $Self->{TicketID},
            NextStates => $Self->_GetNextStates(
                %GetParam,
            ),
            Attachments         => \@Attachments,
            Errors              => \%Error,
            MultipleCustomer    => \@MultipleCustomer,
            MultipleCustomerCc  => \@MultipleCustomerCc,
            MultipleCustomerBcc => \@MultipleCustomerBcc,
            GetParam            => \%GetParam,
            ResponseID          => $GetParam{ResponseID},
            ReplyArticleID      => $GetParam{ArticleID},
            %Ticket,
            %Data,
            InReplyTo        => $Data{MessageID},
            References       => "$References",
            TicketBackType   => $TicketBackType,
            DynamicFieldHTML => \%DynamicFieldHTML,
# Rother OSS / HideShowForAgentTicketCompose
            NextState        => $GetParam{StateID} ? $StdFieldValues{NextStateID}{ $GetParam{StateID} } : '',
            HideAutoselected => $HideAutoselectedJSON,
            Visibility       => $DynFieldStates{Visibility},
# EO HideShowForAgentTicketCompose
        );
        $Output .= $LayoutObject->Footer(
            Type => 'Small',
        );
        return $Output;
    }
}

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

    # get next states
    my %NextStates = $Kernel::OM->Get('Kernel::System::Ticket')->TicketStateList(
        %Param,
        Action   => $Self->{Action},
        TicketID => $Self->{TicketID},
        UserID   => $Self->{UserID},
    );
    return \%NextStates;
}

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

    my $DynamicFieldNames = $Self->_GetFieldsToUpdate(
        OnlyDynamicFields => 1
    );

    # get needed objects
    my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
    my $ConfigObject = $Kernel::OM->Get('Kernel::Config');

# Rother OSS / HideShowForAgentTicketCompose
    if ( $Param{HideAutoselected} ) {

        # add Autoselect JS
        $LayoutObject->AddJSOnDocumentComplete(
            Code => "Core.Form.InitHideAutoselected({ FieldIDs: $Param{HideAutoselected} });",
        );
    }

# EO HideShowForAgentTicketCompose
    # get config for frontend module
    my $Config = $ConfigObject->Get("Ticket::Frontend::$Self->{Action}");

    my %State;
    if ( $Param{GetParam}->{StateID} ) {
        $State{SelectedID} = $Param{GetParam}->{StateID};
    }
    else {
        $State{SelectedValue} = $Config->{StateDefault};
    }
    $Param{NextStatesStrg} = $LayoutObject->BuildSelection(
        Data         => $Param{NextStates},
        Name         => 'StateID',
        PossibleNone => 1,
        %State,
        %Param,
        Class => 'Modernize',
    );

    my $IsVisibleForCustomer = $Config->{IsVisibleForCustomerDefault};
    if ( $Param{GetParam}->{IsVisibleForCustomerPresent} ) {
        $IsVisibleForCustomer = $Param{GetParam}->{IsVisibleForCustomer} ? 1 : 0;
    }

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

    # prepare errors!
    if ( $Param{Errors} ) {
        for my $Error ( sort keys %{ $Param{Errors} } ) {
            $Param{$Error} = $LayoutObject->Ascii2Html(
                Text => $Param{Errors}->{$Error},
            );
        }
    }

    # get used calendar
    my $Calendar = $Kernel::OM->Get('Kernel::System::Ticket')->TicketCalendarGet(
        QueueID => $Param{QueueID},
        SLAID   => $Param{SLAID},
    );

    # pending data string
    $Param{PendingDateString} = $LayoutObject->BuildDateSelection(
        %Param,
        Format               => 'DateInputFormatLong',
        YearPeriodPast       => 0,
        YearPeriodFuture     => 5,
        DiffTime             => $ConfigObject->Get('Ticket::Frontend::PendingDiffTime') || 0,
        Class                => $Param{Errors}->{DateInvalid}                           || ' ',
        Validate             => 1,
        ValidateDateInFuture => 1,
        Calendar             => $Calendar,
    );

    # Multiple-Autocomplete
    $Param{To} = ( scalar @{ $Param{MultipleCustomer} } ? '' : $Param{To} );
    if ( defined $Param{To} && $Param{To} ne '' ) {
        $Param{ToInvalid} = '';
    }

    $Param{Cc} = ( scalar @{ $Param{MultipleCustomerCc} } ? '' : $Param{Cc} );
    if ( defined $Param{Cc} && $Param{Cc} ne '' ) {
        $Param{CcInvalid} = '';
    }

    # Cc
    my $CustomerCounterCc = 0;
    if ( $Param{MultipleCustomerCc} ) {
        for my $Item ( @{ $Param{MultipleCustomerCc} } ) {
            $LayoutObject->Block(
                Name => 'CcMultipleCustomer',
                Data => $Item,
            );
            $LayoutObject->Block(
                Name => 'Cc' . $Item->{CustomerErrorMsg},
                Data => $Item,
            );
            if ( $Item->{CustomerError} ) {
                $LayoutObject->Block(
                    Name => 'CcCustomerErrorExplantion',
                );
            }
            $CustomerCounterCc++;
        }
    }

    if ( !$CustomerCounterCc ) {
        $Param{CcCustomerHiddenContainer} = 'Hidden';
    }

    # set customer counter
    $LayoutObject->Block(
        Name => 'CcMultipleCustomerCounter',
        Data => {
            CustomerCounter => $CustomerCounterCc,
        },
    );

    # Bcc
    my $CustomerCounterBcc = 0;
    if ( $Param{MultipleCustomerBcc} ) {
        for my $Item ( @{ $Param{MultipleCustomerBcc} } ) {
            $LayoutObject->Block(
                Name => 'BccMultipleCustomer',
                Data => $Item,
            );
            $LayoutObject->Block(
                Name => 'Bcc' . $Item->{CustomerErrorMsg},
                Data => $Item,
            );
            if ( $Item->{CustomerError} ) {
                $LayoutObject->Block(
                    Name => 'BccCustomerErrorExplantion',
                );
            }
            $CustomerCounterBcc++;
        }
    }

    if ( !$CustomerCounterBcc ) {
        $Param{BccCustomerHiddenContainer} = 'Hidden';
    }

    # set customer counter
    $LayoutObject->Block(
        Name => 'BccMultipleCustomerCounter',
        Data => {
            CustomerCounter => $CustomerCounterBcc++,
        },
    );

    # To
    my $CustomerCounter = 0;
    if ( $Param{MultipleCustomer} ) {
        for my $Item ( @{ $Param{MultipleCustomer} } ) {
            $LayoutObject->Block(
                Name => 'MultipleCustomer',
                Data => $Item,
            );
            $LayoutObject->Block(
                Name => $Item->{CustomerErrorMsg},
                Data => $Item,
            );
            if ( $Item->{CustomerError} ) {
                $LayoutObject->Block(
                    Name => 'CustomerErrorExplantion',
                );
            }
            $CustomerCounter++;
        }
    }

    if ( !$CustomerCounter ) {
        $Param{CustomerHiddenContainer} = 'Hidden';
    }

    # set customer counter
    $LayoutObject->Block(
        Name => 'MultipleCustomerCounter',
        Data => {
            CustomerCounter => $CustomerCounter,
        },
    );

    if ( $Param{ToInvalid} && $Param{Errors} ) {
        $LayoutObject->Block(
            Name => 'ToServerErrorMsg',
        );
    }

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

    # set preselected values for Cc field
    if ( $Param{Cc} && $Param{Cc} ne '' && !$CustomerCounterCc ) {

        # split Cc values
        my @EmailAddressesCc;
        for my $Email ( Mail::Address->parse( $Param{Cc} ) ) {

            my %CustomerSearch = $CustomerUserObject->CustomerSearch(
                PostMasterSearch => $Email->address(),
                Limit            => 1,
            );

            # CustomerSearch hash could have one item from each backend, so insert just the first one.
            if (%CustomerSearch) {
                CUSTOMERUSERID:
                for my $CustomerUserID ( sort keys %CustomerSearch ) {
                    push @EmailAddressesCc, {
                        CustomerKey        => $CustomerUserID,
                        CustomerTicketText => $CustomerSearch{$CustomerUserID},
                    };
                    last CUSTOMERUSERID;
                }
            }
            else {
                push @EmailAddressesCc, {
                    CustomerKey        => '',
                    CustomerTicketText => $Email->[0] ? "$Email->[0] <$Email->[1]>" : "$Email->[1]",
                };
            }
        }

        $LayoutObject->AddJSData(
            Key   => 'EmailAddressesCc',
            Value => \@EmailAddressesCc,
        );

        $Param{Cc} = '';
    }

    # set preselected values for To field
    if ( defined $Param{To} && $Param{To} ne '' && !$CustomerCounter ) {

        # split To values
        my @EmailAddressesTo;
        for my $Email ( Mail::Address->parse( $Param{To} ) ) {

            my %CustomerSearch = $CustomerUserObject->CustomerSearch(
                PostMasterSearch => $Email->address(),
                Limit            => 1,
            );

            # CustomerSearch hash could have one item from each backend, so insert just the first one.
            if (%CustomerSearch) {
                CUSTOMERUSERID:
                for my $CustomerUserID ( sort keys %CustomerSearch ) {
                    push @EmailAddressesTo, {
                        CustomerKey        => $CustomerUserID,
                        CustomerTicketText => $CustomerSearch{$CustomerUserID},
                    };
                    last CUSTOMERUSERID;
                }
            }
            else {
                push @EmailAddressesTo, {
                    CustomerKey        => '',
                    CustomerTicketText => $Email->[0] ? "$Email->[0] <$Email->[1]>" : "$Email->[1]",
                };
            }
        }

        $LayoutObject->AddJSData(
            Key   => 'EmailAddressesTo',
            Value => \@EmailAddressesTo,
        );

        $Param{To} = '';
    }

    $LayoutObject->Block(
        Name => $Param{TicketBackType},
        Data => {

            #            FormID => $Self->{FormID},
            %Param,
        },
    );

    # get the dynamic fields for this screen
    my $DynamicField = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
        Valid       => 1,
        ObjectType  => [ 'Ticket', 'Article' ],
        FieldFilter => $Config->{DynamicField} || {},
    );

    # Dynamic fields
    # cycle trough the activated Dynamic Fields for this screen
    DYNAMICFIELD:
    for my $DynamicFieldConfig ( @{$DynamicField} ) {
        next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);

        # skip fields that HTML could not be retrieved
        next DYNAMICFIELD if !IsHashRefWithData(
            $Param{DynamicFieldHTML}->{ $DynamicFieldConfig->{Name} }
        );

        # get the html strings form $Param
        my $DynamicFieldHTML = $Param{DynamicFieldHTML}->{ $DynamicFieldConfig->{Name} };
# Rother OSS / HideShowForAgentTicketCompose

        my %Hidden;

        # hide field
        if ( !$Param{Visibility}{"DynamicField_$DynamicFieldConfig->{Name}"} ) {
            %Hidden = (
                HiddenClass => ' oooACLHidden',
                HiddenStyle => 'style=display:none;',
            );

            # ACL hidden fields cannot be mandatory
            if ( $Config->{DynamicField}->{ $DynamicFieldConfig->{Name} } == 2 ) {
                $DynamicFieldHTML->{Field} =~ s/(class=.+?Validate_Required)/$1_IfVisible/g;
            }
        }
# EO HideShowForAgentTicketCompose

        $LayoutObject->Block(
            Name => 'DynamicField',
            Data => {
                Name  => $DynamicFieldConfig->{Name},
                Label => $DynamicFieldHTML->{Label},
                Field => $DynamicFieldHTML->{Field},
# Rother OSS / HideShowForAgentTicketCompose
                %Hidden,
# EO HideShowForAgentTicketCompose
            },
        );

        # example of dynamic fields order customization
        $LayoutObject->Block(
            Name => 'DynamicField_' . $DynamicFieldConfig->{Name},
            Data => {
                Name  => $DynamicFieldConfig->{Name},
                Label => $DynamicFieldHTML->{Label},
                Field => $DynamicFieldHTML->{Field},
# Rother OSS / HideShowForAgentTicketCompose
                %Hidden,
# EO HideShowForAgentTicketCompose
            },
        );
    }

    # show time accounting box
    if ( $ConfigObject->Get('Ticket::Frontend::AccountTime') ) {
        if ( $ConfigObject->Get('Ticket::Frontend::NeedAccountedTime') ) {
            $LayoutObject->Block(
                Name => 'TimeUnitsLabelMandatory',
                Data => \%Param,
            );
            $Param{TimeUnitsRequired} = 'Validate_Required';
        }
        else {
            $LayoutObject->Block(
                Name => 'TimeUnitsLabel',
                Data => \%Param,
            );
            $Param{TimeUnitsRequired} = '';
        }
        $LayoutObject->Block(
            Name => 'TimeUnits',
            Data => \%Param,
        );
    }

    # Show the customer user address book if the module is registered and java script support is available.
    if (
        $ConfigObject->Get('Frontend::Module')->{AgentCustomerUserAddressBook}
        && $LayoutObject->{BrowserJavaScriptSupport}
        )
    {
        $Param{OptionCustomerUserAddressBook} = 1;
    }

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

        # use height/width defined for this screen
        $Param{RichTextHeight} = $Config->{RichTextHeight} || 0;
        $Param{RichTextWidth}  = $Config->{RichTextWidth}  || 0;

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

    # show attachments
    ATTACHMENT:
    for my $Attachment ( @{ $Param{Attachments} } ) {
        if (
            $Attachment->{ContentID}
            && $LayoutObject->{BrowserRichText}
            && ( $Attachment->{ContentType} =~ /image/i )
            && ( $Attachment->{Disposition} eq 'inline' )
            )
        {
            next ATTACHMENT;
        }

        push @{ $Param{AttachmentList} }, $Attachment;
    }

    $LayoutObject->AddJSData(
        Key   => 'DynamicFieldNames',
        Value => $DynamicFieldNames,
    );

    my $LoadedFormDraft;
    if ( $Self->{LoadedFormDraftID} ) {
        $LoadedFormDraft = $Kernel::OM->Get('Kernel::System::FormDraft')->FormDraftGet(
            FormDraftID => $Self->{LoadedFormDraftID},
            GetContent  => 0,
            UserID      => $Self->{UserID},
        );

        my @Articles = $Kernel::OM->Get('Kernel::System::Ticket::Article')->ArticleList(
            TicketID => $Self->{TicketID},
            OnlyLast => 1,
        );

        if (@Articles) {
            my $LastArticle = $Articles[0];

            my $LastArticleSystemTime;
            if ( $LastArticle->{CreateTime} ) {
                my $LastArticleSystemTimeObject = $Kernel::OM->Create(
                    'Kernel::System::DateTime',
                    ObjectParams => {
                        String => $LastArticle->{CreateTime},
                    },
                );
                $LastArticleSystemTime = $LastArticleSystemTimeObject->ToEpoch();
            }

            my $FormDraftSystemTimeObject = $Kernel::OM->Create(
                'Kernel::System::DateTime',
                ObjectParams => {
                    String => $LoadedFormDraft->{ChangeTime},
                },
            );
            my $FormDraftSystemTime = $FormDraftSystemTimeObject->ToEpoch();

            if ( !$LastArticleSystemTime || $FormDraftSystemTime <= $LastArticleSystemTime ) {
                $Param{FormDraftOutdated} = 1;
            }
        }
    }

    if ( IsHashRefWithData($LoadedFormDraft) ) {

        $LoadedFormDraft->{ChangeByName} = $Kernel::OM->Get('Kernel::System::User')->UserName(
            UserID => $LoadedFormDraft->{ChangeBy},
        );
    }

    # create & return output
    return $LayoutObject->Output(
        TemplateFile => 'AgentTicketCompose',
        Data         => {
            FormID         => $Self->{FormID},
            FormDraft      => $Config->{FormDraft},
            FormDraftID    => $Self->{LoadedFormDraftID},
            FormDraftTitle => $LoadedFormDraft ? $LoadedFormDraft->{Title} : '',
            FormDraftMeta  => $LoadedFormDraft,
            %Param,
        },
    );
}

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

    my @UpdatableFields;

    # set the fields that can be updatable via AJAXUpdate
    if ( !$Param{OnlyDynamicFields} ) {
        @UpdatableFields = qw( StateID );
    }

    my $Config = $Kernel::OM->Get('Kernel::Config')->Get("Ticket::Frontend::$Self->{Action}");

    # get the dynamic fields for this screen
    my $DynamicField = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
        Valid       => 1,
        ObjectType  => [ 'Ticket', 'Article' ],
        FieldFilter => $Config->{DynamicField} || {},
    );

    # cycle trough the activated Dynamic Fields for this screen
    DYNAMICFIELD:
    for my $DynamicFieldConfig ( @{$DynamicField} ) {
        next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);

        my $IsACLReducible = $Kernel::OM->Get('Kernel::System::DynamicField::Backend')->HasBehavior(
            DynamicFieldConfig => $DynamicFieldConfig,
            Behavior           => 'IsACLReducible',
        );
        next DYNAMICFIELD if !$IsACLReducible;

        push @UpdatableFields, 'DynamicField_' . $DynamicFieldConfig->{Name};
    }

    return \@UpdatableFields;
}

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

<form action="[% Env("CGIHandle") %]" method="post" enctype="multipart/form-data" name="compose" id="ComposeTicket" class="Validate PreventMultipleSubmits">
    <input type="hidden" name="Action" value="[% Env("Action") %]"/>
    <input type="hidden" name="Subaction" value="SendEmail"/>
    <input type="hidden" name="TicketID" value="[% Data.TicketID | html %]"/>
    <input type="hidden" name="Email" value="[% Data.Email | html %]"/>
    <input type="hidden" name="InReplyTo" value="[% Data.InReplyTo | html %]"/>
    <input type="hidden" name="References" value="[% Data.References | html %]"/>
    <input type="hidden" name="FormID" value="[% Data.FormID | html %]"/>
    <input type="hidden" name="ResponseID" value="[% Data.ResponseID | html %]"/>
    <input type="hidden" name="ReplyArticleID" value="[% Data.ReplyArticleID | html %]"/>
    <input type="hidden" name="IsVisibleForCustomerPresent" value="1"/>
    <input type="hidden" name="FormDraftTitle" value="[% Data.FormDraftTitle | html %]"/>
    <input type="hidden" name="FormDraftID" value="[% Data.FormDraftID | html %]"/>
    <input type="hidden" name="FormDraftAction" id="FormDraftAction" />
    <div class="LayoutPopup ARIARoleMain">
        <div class="Header">
            <ul class="HeaderPopup">
                <li class="HeaderPopupleft">
                    <h1>[% Translate("Compose Answer for %s%s%s", Config('Ticket::Hook'), Config('Ticket::HookDivider'), Data.TicketNumber) | html %] &mdash; [% Data.Title | html %]</h1>
                </li>
[% RenderBlockStart("TicketBack") %]
                <li class="HeaderPopupright">
                    <a class="CancelClosePopup" href="#">[% Translate("Cancel & close") | html %]</a>
                </li>
[% RenderBlockEnd("TicketBack") %]
[% RenderBlockStart("TicketBackUndo") %]
                <li class="HeaderPopupright">
                    [% Translate("The ticket has been locked") | html %].
                    <a class="UndoClosePopup" href="[% Env("Baselink") %]Action=AgentTicketLock;Subaction=Unlock;TicketID=[% Data.TicketID %][% IF Data.PreviousOwner %];PreviousOwner=[% Data.PreviousOwner %][% END %];[% Env("ChallengeTokenParam") | html %]">
                        [% Translate("Undo & close") | html %]
                    </a>
                </li>
[% RenderBlockEnd("TicketBackUndo") %]
            </ul>
        </div>
        <div class="Content">
            [% INCLUDE "FormElements/DraftNotifications.tt" %]
            <div class="ContentColumn">
                <fieldset class="TableLike FixedLabel">

                    <label>[% Translate("From") | html %]:</label>
                    <div class="Field">
                        [% Data.From | html %]
                    </div>
                    <div class="Clear"></div>

                    <label for="ToCustomer" class="Mandatory"><span class="Marker">*</span>[% Translate("To") | html %]:</label>
                    <div class="Field">
                        <input id="ToCustomer" type="text" name="ToCustomer" value="" class="CustomerAutoComplete W75pc [% Data.ToIsLocalAddress | html %] [% Data.ToInvalid | html %]" autocomplete="off" />

                        <div id="ToCustomerServerError" class="TooltipErrorMessage">
[% RenderBlockStart("ToIsLocalAddressServerErrorMsg") %]
                            <p>[% Translate("This address is registered as system address and cannot be used: %s", Data.To) | html %]</p>
[% RenderBlockEnd("ToIsLocalAddressServerErrorMsg") %]

[% RenderBlockStart("ToServerErrorMsg") %]
                            <p>[% Translate("Please include at least one recipient") | html %]</p>
[% RenderBlockEnd("ToServerErrorMsg") %]
                        </div>
                    [% IF Data.OptionCustomerUserAddressBook %]
                        <a href="#" data-recipient-field-label="[% Translate("To") | html %]" data-recipient-field="ToCustomer" data-recipient-type="Email" id="OptionCustomerUserAddressBookToCustomer" class="OptionCustomerUserAddressBook AdditionlFieldIcon" title="[% Translate("Select one or more recipients from the customer user address book.") | html %]">
                            <span>[% Translate("Customer user address book") | html %]</span>
                            <i class="fa fa-address-book-o"></i>
                        </a>
                    [% END %]
                    </div>
                    <div class="Clear"></div>

                    <div class="Field [% Data.CustomerHiddenContainer | html %]">
                        <div class="CustomerTicketTemplateToCustomer SpacingTopSmall Hidden">
                            <input name="CustomerInitialValue" id="CustomerInitialValue" type="hidden" value="[% Data.To | html %]" />
                            <input name="CustomerKey" id="CustomerKey" class="CustomerKey" type="hidden" value=""/>
                            <input name="CustomerQueue" id="CustomerQueue" class="CustomerQueue" type="hidden" value=""/>
                            <input class="CustomerTicketText" title="[% Translate("To") | html %]" name="CustomerTicketText" id="CustomerTicketText" type="text" value="" readonly="readonly" />
                            <a href="#" id="RemoveCustomerTicket" class="RemoveButton CustomerTicketRemove">
                                <i class="fa fa-minus-square-o"></i>
                                <span class="InvisibleText">[% Translate("Remove Ticket Customer") | html %]</span>
                            </a>
                            <a href="#" id="MoveCustomerTicketToCc" class="MoveCustomerButton CcMove" title="[% Translate("Move to Cc") | html %]"><span>Cc</span></a>
                            <a href="#" id="MoveCustomerTicketToBcc" class="MoveCustomerButton BccMove" title="[% Translate("Move to Bcc") | html %]"><span>Bcc</span></a>
                        </div>

                        <div id="TicketCustomerContentToCustomer" class="CustomerContainer">
                            <span class="BoxLabel">[% Translate("To") | html %]</span>
[% RenderBlockStart("MultipleCustomer") %]
                            <div class="SpacingTopSmall ">
                                <input name="CustomerKey_[% Data.Count | html %]" id="CustomerKey_[% Data.Count | html %]" class="CustomerKey" type="hidden" value="[% Data.CustomerKey | html %]"/>
                                <input name="CustomerQueue_[% Data.Count | html %]" id="CustomerQueue_[% Data.Count | html %]" class="CustomerQueue" type="hidden" value="[% Data.CustomerQueue | html %]"/>
                                <input class="CustomerTicketText [% Data.CustomerError | html %]" name="CustomerTicketText_[% Data.Count %]" id="CustomerTicketText_[% Data.Count %]" type="text" value="[% Data.CustomerElement | html %]" readonly="readonly" />
                                <a href="#" id="RemoveCustomerTicket_[% Data.Count %]" class="RemoveButton CustomerTicketRemove">
                                    <i class="fa fa-minus-square-o"></i>
                                    <span class="InvisibleText">[% Translate("Remove Ticket Customer") | html %]</span>
                                </a>
                                <a href="#" id="MoveCustomerTicketToCc_[% Data.Count | html %]"  class="MoveCustomerButton CcMove"  title="[% Translate("Move to Cc") | html %]" name="MoveCustomerTicketToCc_[% Data.Count | html %]"><span>Cc</span></a>
                                <a href="#" id="MoveCustomerTicketToBcc_[% Data.Count | html %]" class="MoveCustomerButton BccMove" title="[% Translate("Move to Bcc") | html %]" name="MoveCustomerTicketToBcc_[% Data.Count | html %]"><span>Bcc</span></a>

[% RenderBlockStart("CustomerErrorExplantion") %]
                                <p class="Explanation Error">[% Translate("Please remove this entry and enter a new one with the correct value.") | html %]</p>
[% RenderBlockEnd("CustomerErrorExplantion") %]

                                <div id="CustomerTicketText_[% Data.Count %]ServerError" class="TooltipErrorMessage">
[% RenderBlockStart("CustomerGenericServerErrorMsg") %]
                                    <p>[% Translate("This field is required.") | html %]</p>
[% RenderBlockEnd("CustomerGenericServerErrorMsg") %]
[% RenderBlockStart("InvalidConfigServerErrorMsg") %]
                                    <p>[% Translate("This email address is not allowed due to the system configuration.") | html %]</p>
[% RenderBlockEnd("InvalidConfigServerErrorMsg") %]
[% RenderBlockStart("InvalidMXServerErrorMsg") %]
                                    <p>[% Translate("This email address failed MX check.") | html %]</p>
[% RenderBlockEnd("InvalidMXServerErrorMsg") %]
[% RenderBlockStart("InvalidDNSServerErrorMsg") %]
                                    <p>[% Translate("DNS problem, please check your configuration and the error log.") | html %]</p>
[% RenderBlockEnd("InvalidDNSServerErrorMsg") %]
[% RenderBlockStart("InvalidSyntaxServerErrorMsg") %]
                                    <p>[% Translate("The syntax of this email address is incorrect.") | html %]</p>
[% RenderBlockEnd("InvalidSyntaxServerErrorMsg") %]
[% RenderBlockStart("IsDuplicatedServerErrorMsg") %]
                                    <p>[% Translate("This address already exists on the address list.") | html %]</p>
[% RenderBlockEnd("IsDuplicatedServerErrorMsg") %]
                                </div>
                            </div>
[% RenderBlockEnd("MultipleCustomer") %]
                        </div>
[% RenderBlockStart("MultipleCustomerCounter") %]
                        <input name="CustomerTicketCounterToCustomer" id="CustomerTicketCounterToCustomer" type="hidden" value="[% Data.CustomerCounter | html %]"/>
[% RenderBlockEnd("MultipleCustomerCounter") %]
                    </div>
                    <div class="Clear"></div>

                    <label for="CcCustomer">[% Translate("Cc") | html %]:</label>
                    <div class="Field">
                        <input id="CcCustomer" type="text" name="CcCustomer" value="" class="CustomerAutoComplete W75pc [% Data.CcIsLocalAddress | html %] [% Data.CcInvalid | html %]" autocomplete="off" />

                        <div id="CcCustomerServerError" class="TooltipErrorMessage">
[% RenderBlockStart("CcIsLocalAddressServerErrorMsg") %]
                            <p>[% Translate("This address is registered as system address and cannot be used: %s", Data.Cc) | html %]</p>
[% RenderBlockEnd("CcIsLocalAddressServerErrorMsg") %]

                        </div>
                    [% IF Data.OptionCustomerUserAddressBook %]
                        <a href="#" data-recipient-field-label="[% Translate("Cc") | html %]" data-recipient-field="CcCustomer" data-recipient-type="Email" id="OptionCustomerUserAddressBookCcCustomer" class="OptionCustomerUserAddressBook AdditionlFieldIcon" title="[% Translate("Select one or more recipients from the customer user address book.") | html %]">
                            <span>[% Translate("Customer user address book") | html %]</span>
                            <i class="fa fa-address-book-o"></i>
                        </a>
                    [% END %]
                    </div>
                    <div class="Clear"></div>

                    <div class="Field [% Data.CcCustomerHiddenContainer | html %]">
                        <div class="CustomerTicketTemplateCcCustomer SpacingTopSmall Hidden">
                            <input name="CcCustomerInitialValue" id="CcCustomerInitialValue" type="hidden" value="[% Data.Cc | html %]" />
                            <input name="CcCustomerKey" id="CcCustomerKey" class="CustomerKey" type="hidden" value=""/>
                            <input name="CcCustomerQueue" id="CcCustomerQueue" class="CustomerQueue" type="hidden" value=""/>
                            <input class="CustomerTicketText" title="[% Translate("Cc") | html %]" name="CcCustomerTicketText" id="CcCustomerTicketText" type="text" value="" readonly="readonly" />
                            <a href="#" id="CcRemoveCustomerTicket" class="RemoveButton CustomerTicketRemove">
                                <i class="fa fa-minus-square-o"></i>
                                <span class="InvisibleText">[% Translate("Remove Cc") | html %]</span>
                            </a>
                            <a href="#" id="MoveCustomerTicketCcTo" class="MoveCustomerButton ToMove" title="[% Translate("Move to To") | html %]"><span>To</span></a>
                            <a href="#" id="MoveCustomerTicketCcBcc" class="MoveCustomerButton BccMove" title="[% Translate("Move to Bcc") | html %]"><span>Bcc</span></a>
                        </div>

                        <div id="TicketCustomerContentCcCustomer" class="CcCustomerContainer">
                            <span class="BoxLabel">[% Translate("Cc") | html %]</span>
[% RenderBlockStart("CcMultipleCustomer") %]
                            <div>
                                <input name="CcCustomerKey_[% Data.Count | html %]" id="CcCustomerKey_[% Data.Count | html %]" class="CustomerKey" type="hidden" value="[% Data.CustomerKey | html %]"/>
                                <input name="CcCustomerQueue_[% Data.Count | html %]" id="CcCustomerQueue_[% Data.Count | html %]" class="CustomerQueue" type="hidden" value="[% Data.CustomerQueue | html %]"/>
                                <input class="CustomerTicketText [% Data.CustomerError | html %]" name="CcCustomerTicketText_[% Data.Count %]" id="CcCustomerTicketText_[% Data.Count %]" type="text" value="[% Data.CustomerElement | html %]" readonly="readonly" />
                                <a href="#" id="CcRemoveCustomerTicket_[% Data.Count %]" class="RemoveButton CustomerTicketRemove">
                                    <i class="fa fa-minus-square-o"></i>
                                    <span class="InvisibleText">[% Translate("Remove Cc") | html %]</span>
                                </a>
                                <a href="#" id="MoveCustomerTicketCcTo_[% Data.Count | html %]"  class="MoveCustomerButton ToMove"  title="[% Translate("Move to To") | html %]"  name="MoveCustomerTicketCcTo_[% Data.Count | html %]"><span>To</span></a>
                                <a href="#" id="MoveCustomerTicketCcBcc_[% Data.Count | html %]" class="MoveCustomerButton BccMove" title="[% Translate("Move to Bcc") | html %]" name="MoveCustomerTicketCcBcc_[% Data.Count | html %]"><span>Bcc</span></a>

[% RenderBlockStart("CcCustomerErrorExplantion") %]
                                <p class="Explanation Error">[% Translate("Please remove this entry and enter a new one with the correct value.") | html %]</p>
[% RenderBlockEnd("CcCustomerErrorExplantion") %]

                                <div id="CcCustomerTicketText_[% Data.Count %]ServerError" class="TooltipErrorMessage">
[% RenderBlockStart("CcCustomerGenericServerErrorMsg") %]
                                    <p>[% Translate("This field is required.") | html %]</p>
[% RenderBlockEnd("CcCustomerGenericServerErrorMsg") %]
[% RenderBlockStart("CcInvalidConfigServerErrorMsg") %]
                                    <p>[% Translate("This email address is not allowed due to the system configuration.") | html %]</p>
[% RenderBlockEnd("CcInvalidConfigServerErrorMsg") %]
[% RenderBlockStart("CcInvalidMXServerErrorMsg") %]
                                    <p>[% Translate("This email address failed MX check.") | html %]</p>
[% RenderBlockEnd("CcInvalidMXServerErrorMsg") %]
[% RenderBlockStart("CcInvalidDNSServerErrorMsg") %]
                                    <p>[% Translate("DNS problem, please check your configuration and the error log.") | html %]</p>
[% RenderBlockEnd("CcInvalidDNSServerErrorMsg") %]
[% RenderBlockStart("CcInvalidSyntaxServerErrorMsg") %]
                                    <p>[% Translate("The syntax of this email address is incorrect.") | html %]</p>
[% RenderBlockEnd("CcInvalidSyntaxServerErrorMsg") %]
[% RenderBlockStart("CcIsDuplicatedServerErrorMsg") %]
                                    <p>[% Translate("This address already exists on the address list.") | html %]</p>
[% RenderBlockEnd("CcIsDuplicatedServerErrorMsg") %]
                                </div>
                            </div>
[% RenderBlockEnd("CcMultipleCustomer") %]

                        </div>
[% RenderBlockStart("CcMultipleCustomerCounter") %]
                        <input name="CustomerTicketCounterCcCustomer" id="CustomerTicketCounterCcCustomer" type="hidden" value="[% Data.CustomerCounter | html %]"/>
[% RenderBlockEnd("CcMultipleCustomerCounter") %]
                    </div>
                    <div class="Clear"></div>

                    <label for="BccCustomer">[% Translate("Bcc") | html %]:</label>
                    <div class="Field">
                        <input id="BccCustomer" type="text" name="BccCustomer" value="" class="CustomerAutoComplete W75pc [% Data.BccIsLocalAddress | html %] [% Data.BccInvalid | html %]" autocomplete="off" />

                        <div id="BccCustomerServerError" class="TooltipErrorMessage">
[% RenderBlockStart("BccIsLocalAddressServerErrorMsg") %]
                            <p>[% Translate("This address is registered as system address and cannot be used: %s", Data.Bcc) | html %]</p>
[% RenderBlockEnd("BccIsLocalAddressServerErrorMsg") %]
                        </div>
                    [% IF Data.OptionCustomerUserAddressBook %]
                        <a href="#" data-recipient-field-label="[% Translate("Bcc") | html %]" data-recipient-field="BccCustomer" data-recipient-type="Email" id="OptionCustomerUserAddressBookBccCustomer" class="OptionCustomerUserAddressBook AdditionlFieldIcon" title="[% Translate("Select one or more recipients from the customer user address book.") | html %]">
                            <span>[% Translate("Customer user address book") | html %]</span>
                            <i class="fa fa-address-book-o"></i>
                        </a>
                    [% END %]
                    </div>
                    <div class="Clear"></div>

                    <div class="Field [% Data.BccCustomerHiddenContainer | html %]">
                        <div class="CustomerTicketTemplateBccCustomer SpacingTopSmall Hidden">
                            <input name="BccCustomerInitialValue" id="BccCustomerInitialValue" type="hidden" value="[% Data.Bcc | html %]" />
                            <input name="BccCustomerKey" id="BccCustomerKey" class="CustomerKey" type="hidden" value=""/>
                            <input name="BccCustomerQueue" id="BccCustomerQueue" class="CustomerQueue" type="hidden" value=""/>
                            <input class="CustomerTicketText" title="[% Translate("Bcc") | html %]" name="BccCustomerTicketText" id="BccCustomerTicketText" type="text" value="" readonly="readonly" />
                            <a href="#" id="BccRemoveCustomerTicket" class="RemoveButton CustomerTicketRemove">
                                <i class="fa fa-minus-square-o"></i>
                                <span class="InvisibleText">[% Translate("Remove Bcc") | html %]</span>
                            </a>
                            <a href="#" id="MoveCustomerTicketBccTo" class="MoveCustomerButton ToMove" title="[% Translate("Move to To") | html %]"><span>To</span></a>
                            <a href="#" id="MoveCustomerTicketBccCc" class="MoveCustomerButton CcMove" title="[% Translate("Move to Cc") | html %]"><span>Cc</span></a>
                        </div>

                        <div id="TicketCustomerContentBccCustomer" class="BccCustomerContainer">
                            <span class="BoxLabel">[% Translate("Bcc") | html %]</span>
[% RenderBlockStart("BccMultipleCustomer") %]
                            <div class="SpacingTopSmall ">
                                <input name="BccCustomerKey_[% Data.Count | html %]" id="BccCustomerKey_[% Data.Count | html %]" class="CustomerKey" type="hidden" value="[% Data.CustomerKey | html %]"/>
                                <input name="BccCustomerQueue_[% Data.Count | html %]" id="BccCustomerQueue_[% Data.Count | html %]" class="CustomerQueue" type="hidden" value="[% Data.CustomerQueue | html %]"/>
                                <input class="CustomerTicketText [% Data.CustomerError | html %]" name="BccCustomerTicketText_[% Data.Count %]" id="BccCustomerTicketText_[% Data.Count %]" type="text" value="[% Data.CustomerElement | html %]" readonly="readonly" />
                                <a href="#" id="BccRemoveCustomerTicket_[% Data.Count %]" class="RemoveButton CustomerTicketRemove">
                                    <i class="fa fa-minus-square-o"></i>
                                    <span class="InvisibleText">[% Translate("Remove Bcc") | html %]</span>
                                </a>
                                <a href="#" id="MoveCustomerTicketBccTo_[% Data.Count | html %]" class="MoveCustomerButton ToMove" title="[% Translate("Move to To") | html %]" name="MoveCustomerTicketBccTo_[% Data.Count | html %]"><span>To</span></a>
                                <a href="#" id="MoveCustomerTicketBccCc_[% Data.Count | html %]" class="MoveCustomerButton CcMove" title="[% Translate("Move to Cc") | html %]" name="MoveCustomerTicketBccCc_[% Data.Count | html %]"><span>Cc</span></a>

[% RenderBlockStart("BccCustomerErrorExplantion") %]
                                <p class="Explanation Error">[% Translate("Please remove this entry and enter a new one with the correct value.") | html %]</p>
[% RenderBlockEnd("BccCustomerErrorExplantion") %]

                                <div id="BccCustomerTicketText_[% Data.Count %]ServerError" class="TooltipErrorMessage">
[% RenderBlockStart("BccCustomerGenericServerErrorMsg") %]
                                    <p>[% Translate("This field is required.") | html %]</p>
[% RenderBlockEnd("BccCustomerGenericServerErrorMsg") %]
[% RenderBlockStart("BccInvalidConfigServerErrorMsg") %]
                                    <p>[% Translate("This email address is not allowed due to the system configuration.") | html %]</p>
[% RenderBlockEnd("BccInvalidConfigServerErrorMsg") %]
[% RenderBlockStart("BccInvalidMXServerErrorMsg") %]
                                    <p>[% Translate("This email address failed MX check.") | html %]</p>
[% RenderBlockEnd("BccInvalidMXServerErrorMsg") %]
[% RenderBlockStart("BccInvalidDNSServerErrorMsg") %]
                                    <p>[% Translate("DNS problem, please check your configuration and the error log.") | html %]</p>
[% RenderBlockEnd("BccInvalidDNSServerErrorMsg") %]
[% RenderBlockStart("BccInvalidSyntaxServerErrorMsg") %]
                                    <p>[% Translate("The syntax of this email address is incorrect.") | html %]</p>
[% RenderBlockEnd("BccInvalidSyntaxServerErrorMsg") %]
[% RenderBlockStart("BccIsDuplicatedServerErrorMsg") %]
                                    <p>[% Translate("This address already exists on the address list.") | html %]</p>
[% RenderBlockEnd("BccIsDuplicatedServerErrorMsg") %]
                                </div>
                            </div>
[% RenderBlockEnd("BccMultipleCustomer") %]

                        </div>
[% RenderBlockStart("BccMultipleCustomerCounter") %]
                        <input name="CustomerTicketCounterBccCustomer" id="CustomerTicketCounterBccCustomer" type="hidden" value="[% Data.CustomerCounter | html %]"/>
[% RenderBlockEnd("BccMultipleCustomerCounter") %]
                    </div>
                    <div class="Clear"></div>


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

[% RenderBlockStart("Option") %]
                    <label for="[% Data.Name | html %]">[% Translate(Data.Key) | html %]:</label>
                    <div class="Field">
                        [% Data.Value %]
                        <div id="[% Data.Name | html %]ServerError" class="TooltipErrorMessage"><p>[% Data.Invalid | html %]</p></div>
                        [% IF Data.FieldExplanation.length %]
                            <p class="FieldExplanation">[% Translate(Data.FieldExplanation) | html %]</p>
                        [% END %]
                    </div>
                    <div class="Clear"></div>
[% RenderBlockEnd("Option") %]

[% RenderBlockStart("TicketOptions") %]
                    <label>[% Translate("Options") | html %]:</label>
                    <div class="Field">

<!-- OutputFilterHook_TicketOptionsBegin -->
<!-- OutputFilterHook_TicketOptionsEnd -->

                    </div>
                    <div class="Clear"></div>
[% RenderBlockEnd("TicketOptions") %]

<!-- OutputFilterHook_NoTicketOptionsFallback -->

                    <label class="Mandatory" for="RichText"><span class="Marker">*</span>[% Translate("Text") | html %]:</label>
                    <div class="RichTextField">
                        <textarea id="RichText" name="Body" rows="15" cols="[% Config("Ticket::Frontend::TextAreaEmail") %]" class="RichText Validate_Required [% Data.BodyInvalid | html %]">[% Data.ResponseFormat %]</textarea>
                        <div id="RichTextError" class="TooltipErrorMessage"><p>[% Translate("This field is required.") | html %]</p></div>
                        <div id="RichTextServerError" class="TooltipErrorMessage"><p>[% Translate("This field is required.") | html %]</p></div>
                    </div>
                    <div class="Clear"></div>

                    <label>[% Translate("Attachments") | html %]:</label>
                    <div class="Field">
[% INCLUDE "FormElements/AttachmentList.tt" %]
                    </div>
                    <div class="Clear"></div>

                    <label for="StateID">[% Translate("Next ticket state") | html %]:</label>
                    <div class="Field">
                        [% Data.NextStatesStrg %]
                    </div>
                    <div class="Clear"></div>

                    <label>[% Translate("Pending date") | html %]:</label>
                    <div class="Field">
                        [% Data.PendingDateString %]
                        <div id="DayServerError" class="TooltipErrorMessage"><p>[% Translate("Date Invalid!") | html %]</p></div>
                        <div id="HourServerError" class="TooltipErrorMessage"><p>[% Translate("Date Invalid!") | html %]</p></div>
                        <p class="FieldExplanation">[% Translate("For all pending* states.") | html %]</p>
                    </div>
                    <div class="Clear"></div>

[% RenderBlockStart("IsVisibleForCustomer") %]
                    <label for="IsVisibleForCustomer">[% Translate("Visible for customer") | html %]:</label>
                    <div class="Field">
                        <input type="checkbox" id="IsVisibleForCustomer" name="IsVisibleForCustomer" value="1" [% IF Data.IsVisibleForCustomer %]checked="checked"[% END %]/>
                    </div>
                    <div class="Clear"></div>
[% RenderBlockEnd("IsVisibleForCustomer") %]
[% RenderBlockStart("DynamicField") %]
# Rother OSS / HideShowForAgentTicketCompose
#                     <div class="Row Row_DynamicField_[% Data.Name | html %]">
                    <div class="Row Row_DynamicField_[% Data.Name | html %][% Data.HiddenClass | html %]" [% Data.HiddenStyle | html %]>
# EO HideShowForAgentTicketCompose
                        [% Data.Label %]
                        <div class="Field">
                            [% Data.Field %]
                        </div>
                        <div class="Clear"></div>
                    </div>
[% RenderBlockEnd("DynamicField") %]

# example of how to use fixed dynamic field blocks for customizations
# Note: Field1 and Field2 are the names of the fields and had to be replaced with the actual
# field names
#[% RenderBlockStart("DynamicField_Field1") %]
# Rother OSS / HideShowForAgentTicketCompose
# #                    <div class="Row Row_DynamicField_[% Data.Name | html %]">
#                    <div class="Row Row_DynamicField_[% Data.Name | html %][% Data.HiddenClass | html %]" [% Data.HiddenStyle | html %]>
# EO HideShowForAgentTicketCompose
#                        [% Data.Label %]
#                        <div class="Field">
#                            [% Data.Field %]
#                        </div>
#                        <div class="Clear"></div>
#                    </div>
#[% RenderBlockEnd("DynamicField_Field1") %]
#[% RenderBlockStart("DynamicField_Field2") %]
# Rother OSS / HideShowForAgentTicketCompose
# #                    <div class="Row Row_DynamicField_[% Data.Name | html %]">
#                    <div class="Row Row_DynamicField_[% Data.Name | html %][% Data.HiddenClass | html %]" [% Data.HiddenStyle | html %]>
# EO HideShowForAgentTicketCompose
#                        [% Data.Label %]
#                        <div class="Field">
#                            [% Data.Field %]
#                        </div>
#                        <div class="Clear"></div>
#                    </div>
#[% RenderBlockEnd("DynamicField_Field2") %]

[% RenderBlockStart("TimeUnitsLabel") %]
                    <label for="TimeUnits">[% Translate("Time units") | html %] [% Translate(Config("Ticket::Frontend::TimeUnits")) | html %]:</label>
[% RenderBlockEnd("TimeUnitsLabel") %]
[% RenderBlockStart("TimeUnitsLabelMandatory") %]
                    <label class="Mandatory" for="TimeUnits"><span class="Marker">*</span>[% Translate("Time units") | html %] [% Translate(Config("Ticket::Frontend::TimeUnits")) | html %]:</label>
[% RenderBlockEnd("TimeUnitsLabelMandatory") %]
[% RenderBlockStart("TimeUnits") %]
                    <div class="Field">
                        <input type="text" name="TimeUnits" id="TimeUnits" value="[% Data.TimeUnits | html %]" class="W50pc Validate_TimeUnits [% Data.TimeUnitsRequired | html %] [% Data.TimeUnitsInvalid | html %] " />
                        <div id="TimeUnitsError" class="TooltipErrorMessage"><p>[% Translate("Invalid time!") | html %]</p></div>
                        <div id="TimeUnitsServerError" class="TooltipErrorMessage"><p>[% Translate("This field is required.") | html %]</p></div>
                    </div>
                    <div class="Clear"></div>
[% RenderBlockEnd("TimeUnits") %]
                </fieldset>
            </div>
            <br/>

        </div>
        <div class="Footer">
            <button class="CallForAction Primary" id="submitRichText" accesskey="g" title="[% Translate("Send mail") | html %] (g)" type="submit" value="[% Translate("Send mail") | html %]" >
                <span><i class="fa fa-envelope-o"></i> [% Translate("Send mail") | html %]</span>
            </button>
            [% INCLUDE "FormElements/DraftButtons.tt" %]
        </div>
    </div>
</form>
 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