init III

Perl OTRS/Kernel/Modules/AdminGenericInterfaceErrorHandlingRequestRetry.pm

@@ -0,0 +1,772 @@
+# --
+# Copyright (C) 2001-2019 OTRS AG, https://otrs.com/
+# --
+# This software comes with ABSOLUTELY NO WARRANTY. For details, see
+# the enclosed file COPYING for license information (GPL). If you
+# did not receive this file, see https://www.gnu.org/licenses/gpl-3.0.txt.
+# --
+
+package Kernel::Modules::AdminGenericInterfaceErrorHandlingRequestRetry;
+
+use strict;
+use warnings;
+
+use Kernel::System::VariableCheck qw(:all);
+use Kernel::Language qw(Translatable);
+
+our $ObjectManagerDisabled = 1;
+
+sub new {
+    my ( $Type, %Param ) = @_;
+
+    my $Self = {%Param};
+    bless( $Self, $Type );
+
+    return $Self;
+}
+
+sub Run {
+    my ( $Self, %Param ) = @_;
+
+    my $ParamObject  = $Kernel::OM->Get('Kernel::System::Web::Request');
+    my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
+
+    my $WebserviceID = $ParamObject->GetParam( Param => 'WebserviceID' );
+    if ( !IsPositiveInteger($WebserviceID) ) {
+        return $LayoutObject->ErrorScreen(
+            Message => Translatable('Need WebserviceID!'),
+        );
+    }
+
+    my $WebserviceData = $Kernel::OM->Get('Kernel::System::GenericInterface::Webservice')->WebserviceGet(
+        ID => $WebserviceID,
+    );
+    if ( !IsHashRefWithData($WebserviceData) ) {
+        return $LayoutObject->ErrorScreen(
+            Message =>
+                $LayoutObject->{LanguageObject}->Translate( 'Could not get data for WebserviceID %s', $WebserviceID ),
+        );
+    }
+
+    my $CommunicationType = $ParamObject->GetParam( Param => 'CommunicationType' );
+    if ( !IsStringWithData($CommunicationType) ) {
+        return $LayoutObject->ErrorScreen(
+            Message => Translatable('Need communication type!'),
+        );
+    }
+    if (
+        $CommunicationType ne 'Requester'
+        && $CommunicationType ne 'Provider'
+        )
+    {
+        return $LayoutObject->ErrorScreen(
+            Message => Translatable("Communication type needs to be 'Requester' or 'Provider'!"),
+        );
+    }
+
+    if ( $Self->{Subaction} eq 'Add' ) {
+        return $Self->_Add(
+            WebserviceID      => $WebserviceID,
+            WebserviceData    => $WebserviceData,
+            CommunicationType => $CommunicationType,
+        );
+    }
+    elsif ( $Self->{Subaction} eq 'AddAction' ) {
+
+        # Challenge token check for write action.
+        $LayoutObject->ChallengeTokenCheck();
+
+        return $Self->_AddAction(
+            WebserviceID      => $WebserviceID,
+            WebserviceData    => $WebserviceData,
+            CommunicationType => $CommunicationType,
+        );
+    }
+    elsif ( $Self->{Subaction} eq 'Change' ) {
+        return $Self->_Change(
+            WebserviceID      => $WebserviceID,
+            WebserviceData    => $WebserviceData,
+            CommunicationType => $CommunicationType,
+        );
+    }
+    elsif ( $Self->{Subaction} eq 'ChangeAction' ) {
+
+        # Challenge token check for write action.
+        $LayoutObject->ChallengeTokenCheck();
+
+        return $Self->_ChangeAction(
+            WebserviceID      => $WebserviceID,
+            WebserviceData    => $WebserviceData,
+            CommunicationType => $CommunicationType,
+        );
+    }
+
+    # Fall-back if missing or other sub-action.
+    return $LayoutObject->ErrorScreen(
+        Message => Translatable('Invalid Subaction!'),
+    );
+}
+
+sub _Add {
+    my ( $Self, %Param ) = @_;
+
+    my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
+
+    my $ErrorHandlingType = $Kernel::OM->Get('Kernel::System::Web::Request')->GetParam( Param => 'ErrorHandlingType' );
+    if ( !IsStringWithData($ErrorHandlingType) ) {
+        return $LayoutObject->ErrorScreen(
+            Message => Translatable('Need ErrorHandlingType!'),
+        );
+    }
+    if ( !$Self->_ErrorHandlingTypeCheck( ErrorHandlingType => $ErrorHandlingType ) ) {
+        return $LayoutObject->ErrorScreen(
+            Message => $LayoutObject->{LanguageObject}
+                ->Translate( 'ErrorHandlingType %s is not registered', $ErrorHandlingType ),
+        );
+    }
+
+    return $Self->_ShowScreen(
+        %Param,
+        Action              => 'Add',
+        ErrorHandlingConfig => {
+            Type => $ErrorHandlingType,
+        },
+    );
+}
+
+sub _AddAction {
+    my ( $Self, %Param ) = @_;
+
+    my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
+
+    my $ParamObject       = $Kernel::OM->Get('Kernel::System::Web::Request');
+    my $ErrorHandlingType = $ParamObject->GetParam( Param => 'ErrorHandlingType' );
+    if ( !IsStringWithData($ErrorHandlingType) ) {
+        return $LayoutObject->ErrorScreen(
+            Message => Translatable('Need ErrorHandlingType!'),
+        );
+    }
+    if ( !$Self->_ErrorHandlingTypeCheck( ErrorHandlingType => $ErrorHandlingType ) ) {
+        return $LayoutObject->ErrorScreen(
+            Message => $LayoutObject->{LanguageObject}
+                ->Translate( 'ErrorHandlingType %s is not registered', $ErrorHandlingType ),
+        );
+    }
+
+    my %Errors;
+    my $RequestParams = $Self->_RequestParamsGet();
+
+    # Check mandatory parameters.
+    NEEDED:
+    for my $Needed (qw(ScheduleRetry RetryIntervalStart RetryIntervalFactor RetryIntervalMax)) {
+        next NEEDED if IsStringWithData( $RequestParams->{$Needed} );
+
+        $Errors{ $Needed . 'ServerError' } = 'ServerError';
+    }
+
+    # Name already exists.
+    my $ErrorHandling = $ParamObject->GetParam( Param => 'ErrorHandling' );
+    if (
+        !IsStringWithData($ErrorHandling)
+        || $Param{WebserviceData}->{Config}->{ $Param{CommunicationType} }->{ErrorHandling}->{$ErrorHandling}
+        )
+    {
+        $Errors{ErrorHandlingServerError} = 'ServerError';
+    }
+
+    # Max retry count must be empty or an integer.
+    if (
+        IsStringWithData( $RequestParams->{RetryCountMax} )
+        && !IsPositiveInteger( $RequestParams->{RetryCountMax} )
+        )
+    {
+        $Errors{RetryCountMaxServerError} = 'ServerError';
+    }
+
+    my $ErrorHandlingConfig = {
+        %{$RequestParams},
+        Type => $ErrorHandlingType,
+    };
+
+    # Validation errors.
+    if (%Errors) {
+        return $Self->_ShowScreen(
+            %Param,
+            %Errors,
+            Action              => 'Add',
+            ErrorHandling       => $ErrorHandling,
+            ErrorHandlingConfig => {
+                %{$ErrorHandlingConfig},
+                ErrorHandling => $ErrorHandling,
+            },
+        );
+    }
+
+    # Add module to config.
+    $Param{WebserviceData}->{Config}->{ $Param{CommunicationType} }->{ErrorHandling}->{$ErrorHandling}
+        = $ErrorHandlingConfig;
+
+    # Add module to priority list.
+    my $WebserviceErrorHandlingPriority
+        = $Param{WebserviceData}->{Config}->{ $Param{CommunicationType} }->{ErrorHandlingPriority};
+    if ( IsArrayRefWithData($WebserviceErrorHandlingPriority) ) {
+        push @{$WebserviceErrorHandlingPriority}, $ErrorHandling;
+    }
+    else {
+        $Param{WebserviceData}->{Config}->{ $Param{CommunicationType} }->{ErrorHandlingPriority} = [$ErrorHandling];
+    }
+
+    my $UpdateSuccess = $Kernel::OM->Get('Kernel::System::GenericInterface::Webservice')->WebserviceUpdate(
+        %{ $Param{WebserviceData} },
+        UserID => $Self->{UserID},
+    );
+    if ( !$UpdateSuccess ) {
+        return $LayoutObject->ErrorScreen(
+            Message => Translatable('Could not update web service'),
+        );
+    }
+
+    # Save button: stay in edit mode.
+    my $RedirectURL =
+        'Action='
+        . $Self->{Action}
+        . ';Subaction=Change;WebserviceID='
+        . $Param{WebserviceID}
+        . ';ErrorHandling='
+        . $LayoutObject->LinkEncode($ErrorHandling)
+        . ';ErrorHandlingType='
+        . $LayoutObject->LinkEncode($ErrorHandlingType)
+        . ';CommunicationType='
+        . $LayoutObject->LinkEncode( $Param{CommunicationType} )
+        . ';';
+
+    return $LayoutObject->Redirect(
+        OP => $RedirectURL,
+    );
+
+}
+
+sub _Change {
+    my ( $Self, %Param ) = @_;
+
+    my $ErrorHandling = $Kernel::OM->Get('Kernel::System::Web::Request')->GetParam( Param => 'ErrorHandling' );
+
+    my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
+
+    if ( !IsStringWithData($ErrorHandling) ) {
+        return $LayoutObject->ErrorScreen(
+            Message => Translatable('Need ErrorHandling'),
+        );
+    }
+
+    my $ErrorHandlingConfig
+        = $Param{WebserviceData}->{Config}->{ $Param{CommunicationType} }->{ErrorHandling}->{$ErrorHandling};
+    if ( !IsHashRefWithData($ErrorHandlingConfig) ) {
+        return $LayoutObject->ErrorScreen(
+            Message =>
+                $LayoutObject->{LanguageObject}
+                ->Translate( 'Could not determine config for error handler %s', $ErrorHandling ),
+        );
+    }
+
+    return $Self->_ShowScreen(
+        %Param,
+        Action              => 'Change',
+        ErrorHandling       => $ErrorHandling,
+        ErrorHandlingConfig => {
+            %{$ErrorHandlingConfig},
+            ErrorHandling => $ErrorHandling,
+        },
+    );
+}
+
+sub _ChangeAction {
+    my ( $Self, %Param ) = @_;
+
+    my $ParamObject  = $Kernel::OM->Get('Kernel::System::Web::Request');
+    my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
+
+    my $OldErrorHandling = $ParamObject->GetParam( Param => 'OldErrorHandling' );
+    if ( !IsStringWithData($OldErrorHandling) ) {
+        return $LayoutObject->ErrorScreen(
+            Message =>
+                $LayoutObject->{LanguageObject}->Translate( 'Need %s', 'OldErrorHandling' ),
+        );
+    }
+
+    my %Errors;
+    my $ErrorHandling = $ParamObject->GetParam( Param => 'ErrorHandling' );
+    if ( !IsStringWithData($ErrorHandling) ) {
+        $Errors{ErrorHandlingServerError} = 'ServerError';
+    }
+
+    my $ErrorHandlingConfig = $Param{WebserviceData}->{Config}->{ $Param{CommunicationType} }->{ErrorHandling}
+        ->{$OldErrorHandling};
+    if ( !IsHashRefWithData($ErrorHandlingConfig) ) {
+        return $LayoutObject->ErrorScreen(
+            Message =>
+                $LayoutObject->{LanguageObject}
+                ->Translate( 'Could not determine config for error handler %s', $OldErrorHandling ),
+        );
+    }
+
+    # Error handler was renamed, avoid conflicts.
+    if ( $OldErrorHandling ne $ErrorHandling ) {
+
+        # New name already exists, bail out.
+        if (
+            $Param{WebserviceData}->{Config}->{ $Param{CommunicationType} }->{ErrorHandling}->{$ErrorHandling}
+            )
+        {
+            $Errors{ErrorHandlingServerError} = 'ServerError';
+        }
+
+        # OK, remove old error handler. New one will be added below.
+        if ( !%Errors ) {
+            delete $Param{WebserviceData}->{Config}->{ $Param{CommunicationType} }->{ErrorHandling}
+                ->{$OldErrorHandling};
+        }
+    }
+
+    my $RequestParams = $Self->_RequestParamsGet();
+
+    # Check mandatory parameters.
+    NEEDED:
+    for my $Needed (qw(ScheduleRetry RetryIntervalStart RetryIntervalFactor RetryIntervalMax)) {
+        next NEEDED if IsStringWithData( $RequestParams->{$Needed} );
+
+        $Errors{ $Needed . 'ServerError' } = 'ServerError';
+    }
+
+    # Max retry count must be empty or an integer.
+    if (
+        IsStringWithData( $RequestParams->{RetryCountMax} )
+        && !IsPositiveInteger( $RequestParams->{RetryCountMax} )
+        )
+    {
+        $Errors{RetryCountMaxServerError} = 'ServerError';
+    }
+
+    $ErrorHandlingConfig = {
+        %{$RequestParams},
+        Type => $ErrorHandlingConfig->{Type},
+    };
+
+    # Validation errors.
+    if (%Errors) {
+        return $Self->_ShowScreen(
+            %Param,
+            %Errors,
+            Action              => 'Change',
+            ErrorHandling       => $OldErrorHandling,
+            ErrorHandlingConfig => {
+                %{$ErrorHandlingConfig},
+                ErrorHandling => $ErrorHandling,
+            },
+        );
+    }
+
+    # Update config.
+    $Param{WebserviceData}->{Config}->{ $Param{CommunicationType} }->{ErrorHandling}->{$ErrorHandling}
+        = $ErrorHandlingConfig;
+
+    # Update priority array if necessary.
+    if ( $OldErrorHandling ne $ErrorHandling ) {
+        my $ErrorHandlingPriority
+            = $Param{WebserviceData}->{Config}->{ $Param{CommunicationType} }->{ErrorHandlingPriority};
+        my ($OldErrorHandlingIndex) = grep { $ErrorHandlingPriority->[$_] eq $OldErrorHandling }
+            ( 0 .. scalar @{$ErrorHandlingPriority} - 1 );
+        if ( IsStringWithData($OldErrorHandlingIndex) ) {
+            $ErrorHandlingPriority->[$OldErrorHandlingIndex] = $ErrorHandling;
+        }
+    }
+
+    my $UpdateSuccess = $Kernel::OM->Get('Kernel::System::GenericInterface::Webservice')->WebserviceUpdate(
+        %{ $Param{WebserviceData} },
+        UserID => $Self->{UserID},
+    );
+    if ( !$UpdateSuccess ) {
+        return $LayoutObject->ErrorScreen(
+            Message => Translatable('Could not update web service'),
+        );
+    }
+
+    # if the user would like to continue editing the queue, just redirect to the edit screen
+    my $RedirectURL;
+    if (
+        defined $ParamObject->GetParam( Param => 'ContinueAfterSave' )
+        && ( $ParamObject->GetParam( Param => 'ContinueAfterSave' ) eq '1' )
+        )
+    {
+        $RedirectURL =
+            'Action='
+            . $Self->{Action}
+            . ';Subaction=Change;WebserviceID='
+            . $Param{WebserviceID}
+            . ';ErrorHandling='
+            . $LayoutObject->LinkEncode($ErrorHandling)
+            . ';CommunicationType='
+            . $LayoutObject->LinkEncode( $Param{CommunicationType} )
+            . ';';
+    }
+    else {
+
+        # otherwise return to overview
+        $RedirectURL =
+            'Action=AdminGenericInterfaceWebservice;Subaction=Change;WebserviceID='
+            . $Param{WebserviceID}
+            . ';';
+    }
+
+    return $LayoutObject->Redirect(
+        OP => $RedirectURL,
+    );
+}
+
+sub _ShowScreen {
+    my ( $Self, %Param ) = @_;
+
+    my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
+
+    my $Output = $LayoutObject->Header();
+    $Output .= $LayoutObject->NavigationBar();
+
+    $LayoutObject->Block(
+        Name => 'Title' . $Param{Action},
+        Data => \%Param,
+    );
+    $LayoutObject->Block(
+        Name => 'Navigation' . $Param{Action},
+        Data => \%Param,
+    );
+
+    my %TemplateData = (
+        ErrorHandlingType         => $Param{ErrorHandlingConfig}->{Type},
+        Description               => $Param{ErrorHandlingConfig}->{Description},
+        ErrorCode                 => $Param{ErrorHandlingConfig}->{ErrorCode},
+        ErrorMessage              => $Param{ErrorHandlingConfig}->{ErrorMessage},
+        ErrorHandling             => $Param{ErrorHandlingConfig}->{ErrorHandling},
+        OldErrorHandling          => $Param{ErrorHandling},
+        ErrorMessageContentFilter => $Param{ErrorHandlingConfig}->{ErrorMessageContentFilter},
+        RetryCountMax             => $Param{ErrorHandlingConfig}->{RetryCountMax} // 10,
+    );
+
+    if ( $Param{Action} eq 'Change' ) {
+        $LayoutObject->AddJSData(
+            Key   => 'ErrorHandling',
+            Value => {
+                CommunicationType   => $Param{CommunicationType},
+                ErrorHandlingModule => $Param{ErrorHandling},
+                WebserviceID        => $Param{WebserviceID},
+                ErrorHandlingType   => $Param{ErrorHandlingConfig}->{Type},
+            },
+        );
+    }
+
+    my @ErrorStageFilter;
+
+    if ( $Param{CommunicationType} eq 'Requester' ) {
+
+        @ErrorStageFilter = (
+            {
+                Key   => 'RequesterRequestPrepare',
+                Value => Translatable('Invoker processing outgoing request data'),
+            },
+            {
+                Key   => 'RequesterRequestMap',
+                Value => Translatable('Mapping outgoing request data'),
+            },
+            {
+                Key   => 'RequesterRequestPerform',
+                Value => Translatable('Transport processing request into response'),
+            },
+            {
+                Key   => 'RequesterResponseMap',
+                Value => Translatable('Mapping incoming response data'),
+            },
+            {
+                Key   => 'RequesterResponseProcess',
+                Value => Translatable('Invoker processing incoming response data'),
+            },
+        );
+    }
+    else {
+
+        @ErrorStageFilter = (
+            {
+                Key   => 'ProviderRequestReceive',
+                Value => Translatable('Transport receiving incoming request data'),
+            },
+            {
+                Key   => 'ProviderRequestMap',
+                Value => Translatable('Mapping incoming request data'),
+            },
+            {
+                Key   => 'ProviderRequestProcess',
+                Value => Translatable('Operation processing incoming request data'),
+            },
+            {
+                Key   => 'ProviderResponseMap',
+                Value => Translatable('Mapping outgoing response data'),
+            },
+            {
+                Key   => 'ProviderResponseTransmit',
+                Value => Translatable('Transport sending outgoing response data'),
+            },
+        );
+    }
+    $TemplateData{ErrorStageFilterStrg} = $LayoutObject->BuildSelection(
+        Data         => \@ErrorStageFilter,
+        ID           => 'ErrorStageFilter',
+        Name         => 'ErrorStageFilter',
+        SelectedID   => $Param{ErrorHandlingConfig}->{ErrorStageFilter},
+        PossibleNone => 1,
+        Multiple     => 1,
+        Translate    => 1,
+        Class        => 'Modernize',
+    );
+
+    $TemplateData{StopAfterMatchStrg} = $LayoutObject->BuildSelection(
+        Data => {
+            'backend' => Translatable('skip same backend modules only'),
+            'all'     => Translatable('skip all modules'),
+        },
+        ID           => 'StopAfterMatch',
+        Name         => 'StopAfterMatch',
+        SelectedID   => $Param{ErrorHandlingConfig}->{StopAfterMatch},
+        PossibleNone => 1,
+        Translate    => 1,
+        Class        => 'Modernize',
+    );
+
+    if ( $Param{CommunicationType} eq 'Provider' ) {
+        my %Operations
+            = map { $_ => $_ } sort keys %{ $Param{WebserviceData}->{Config}->{Provider}->{Operation} || {} };
+        my $OperationDeletedText = $LayoutObject->{LanguageObject}->Translate('Operation deleted');
+        SELECTEDOPERATION:
+        for my $SelectedOperation ( @{ $Param{ErrorHandlingConfig}->{OperationFilter} || [] } ) {
+            next SELECTEDOPERATION if $Operations{$SelectedOperation};
+            $Operations{$SelectedOperation} = $SelectedOperation . " ($OperationDeletedText)";
+        }
+        my $OperationFilterStrg = $LayoutObject->BuildSelection(
+            Data         => \%Operations,
+            ID           => 'OperationFilter',
+            Name         => 'OperationFilter',
+            SelectedID   => $Param{ErrorHandlingConfig}->{OperationFilter},
+            Multiple     => 1,
+            PossibleNone => 1,
+            Translate    => 0,
+            Class        => 'Modernize',
+        );
+        $LayoutObject->Block(
+            Name => 'OperationFilter',
+            Data => {
+                OperationFilterStrg => $OperationFilterStrg,
+            },
+        );
+    }
+    else {
+        my %Invokers = map { $_ => $_ } sort keys %{ $Param{WebserviceData}->{Config}->{Requester}->{Invoker} || {} };
+        my $InvokerDeletedText = $LayoutObject->{LanguageObject}->Translate('Invoker deleted');
+        SELECTEDINVOKER:
+        for my $SelectedInvoker ( @{ $Param{ErrorHandlingConfig}->{InvokerFilter} || [] } ) {
+            next SELECTEDINVOKER if $Invokers{$SelectedInvoker};
+            $Invokers{$SelectedInvoker} = $SelectedInvoker . " ($InvokerDeletedText)";
+        }
+        my $InvokerFilterStrg = $LayoutObject->BuildSelection(
+            Data         => \%Invokers,
+            ID           => 'InvokerFilter',
+            Name         => 'InvokerFilter',
+            SelectedID   => $Param{ErrorHandlingConfig}->{InvokerFilter},
+            Multiple     => 1,
+            PossibleNone => 1,
+            Translate    => 0,
+            Class        => 'Modernize',
+        );
+        $LayoutObject->Block(
+            Name => 'InvokerFilter',
+            Data => {
+                InvokerFilterStrg => $InvokerFilterStrg,
+            },
+        );
+    }
+
+    $TemplateData{ScheduleRetryFieldsHidden} = $Param{ErrorHandlingConfig}->{ScheduleRetry} ? '' : 'Hidden';
+
+    $TemplateData{ScheduleRetryStrg} = $LayoutObject->BuildSelection(
+        Data => {
+            0 => Translatable('No'),
+            1 => Translatable('Yes'),
+        },
+        ID           => 'ScheduleRetry',
+        Name         => 'ScheduleRetry',
+        SelectedID   => $Param{ErrorHandlingConfig}->{ScheduleRetry} // 0,
+        PossibleNone => 0,
+        Translate    => 1,
+        Class        => 'Modernize Validate_Required Validate_Number',
+    );
+
+    # All possibly selectable time frames
+    my %DateSelection = (
+        0                => Translatable('0 seconds'),
+        15               => Translatable('15 seconds'),
+        30               => Translatable('30 seconds'),
+        45               => Translatable('45 seconds'),
+        60               => Translatable('1 minute'),
+        60 * 2           => Translatable('2 minutes'),
+        60 * 3           => Translatable('3 minutes'),
+        60 * 4           => Translatable('4 minutes'),
+        60 * 5           => Translatable('5 minutes'),
+        60 * 10          => Translatable('10 minutes'),
+        60 * 15          => Translatable('15 minutes'),
+        60 * 30          => Translatable('30 minutes'),
+        60 * 60          => Translatable('1 hour'),
+        60 * 60 * 2      => Translatable('2 hours'),
+        60 * 60 * 3      => Translatable('3 hours'),
+        60 * 60 * 4      => Translatable('4 hours'),
+        60 * 60 * 5      => Translatable('5 hours'),
+        60 * 60 * 6      => Translatable('6 hours'),
+        60 * 60 * 12     => Translatable('12 hours'),
+        60 * 60 * 18     => Translatable('18 hours'),
+        60 * 60 * 24     => Translatable('1 day'),
+        60 * 60 * 24 * 2 => Translatable('2 days'),
+        60 * 60 * 24 * 3 => Translatable('3 days'),
+        60 * 60 * 24 * 4 => Translatable('4 days'),
+        60 * 60 * 24 * 5 => Translatable('5 days'),
+        60 * 60 * 24 * 6 => Translatable('6 days'),
+        60 * 60 * 24 * 7 => Translatable('1 week'),
+    );
+
+    # Use all dates from 0 seconds to 1 day for RetryIntervalStart.
+    my %RetryIntervalStartSelection
+        = map { $_ => $DateSelection{$_} } grep { $_ >= 0 && $_ <= 60 * 60 * 24 } sort keys %DateSelection;
+    $TemplateData{RetryIntervalStartStrg} = $LayoutObject->BuildSelection(
+        Data         => \%RetryIntervalStartSelection,
+        ID           => 'RetryIntervalStart',
+        Name         => 'RetryIntervalStart',
+        SelectedID   => $Param{ErrorHandlingConfig}->{RetryIntervalStart} // 60,
+        PossibleNone => 0,
+        Translate    => 1,
+        Sort         => 'NumericKey',
+        Class        => 'Modernize Validate_Required Validate_Number',
+    );
+
+    $TemplateData{RetryIntervalFactorStrg} = $LayoutObject->BuildSelection(
+        Data => {
+            1   => '1',
+            1.5 => '1.5',
+            2   => '2',
+        },
+        ID           => 'RetryIntervalFactor',
+        Name         => 'RetryIntervalFactor',
+        SelectedID   => $Param{ErrorHandlingConfig}->{RetryIntervalFactor} || 2,
+        PossibleNone => 0,
+        Translate    => 0,
+        Class        => 'Modernize Validate_Required',
+    );
+
+    # Use all dates from 0 seconds to 1 day for RetryIntervalMax.
+    my %RetryIntervalMaxSelection
+        = map { $_ => $DateSelection{$_} } grep { $_ >= 0 && $_ <= 60 * 60 * 24 } sort keys %DateSelection;
+    $TemplateData{RetryIntervalMaxStrg} = $LayoutObject->BuildSelection(
+        Data         => \%RetryIntervalMaxSelection,
+        ID           => 'RetryIntervalMax',
+        Name         => 'RetryIntervalMax',
+        SelectedID   => $Param{ErrorHandlingConfig}->{RetryIntervalMax} // 60 * 60,
+        PossibleNone => 0,
+        Translate    => 1,
+        Sort         => 'NumericKey',
+        Class        => 'Modernize Validate_Required Validate_Number',
+    );
+
+    # Use all dates from 1 minute to 1 week for RetryPeriodMax.
+    my %RetryPeriodMaxSelection
+        = map { $_ => $DateSelection{$_} } grep { $_ >= 60 && $_ <= 60 * 60 * 24 * 7 } sort keys %DateSelection;
+    $TemplateData{RetryPeriodMaxStrg} = $LayoutObject->BuildSelection(
+        Data         => \%RetryPeriodMaxSelection,
+        ID           => 'RetryPeriodMax',
+        Name         => 'RetryPeriodMax',
+        SelectedID   => $Param{ErrorHandlingConfig}->{RetryPeriodMax} // 60 * 60 * 24,
+        PossibleNone => 1,
+        Translate    => 1,
+        Sort         => 'NumericKey',
+        Class        => 'Modernize Validate_Number',
+    );
+
+    $Output .= $LayoutObject->Output(
+        TemplateFile => $Self->{Action},
+        Data         => {
+            %Param,
+            %TemplateData,
+            ErrorHandling  => $Param{ErrorHandling},
+            WebserviceName => $Param{WebserviceData}->{Name},
+        },
+    );
+
+    $Output .= $LayoutObject->Footer();
+    return $Output;
+}
+
+sub _RequestParamsGet {
+    my ( $Self, %Param ) = @_;
+
+    my $ParamObject = $Kernel::OM->Get('Kernel::System::Web::Request');
+
+    my %GetParam;
+    for my $StringParam (
+        qw(
+        Description ErrorCode ErrorMessage
+        ErrorMessageContentFilter StopAfterMatch
+        ScheduleRetry RetryIntervalStart RetryIntervalFactor RetryIntervalMax RetryCountMax RetryPeriodMax
+        )
+        )
+    {
+        $GetParam{$StringParam} = $ParamObject->GetParam( Param => $StringParam ) // '';
+    }
+    for my $ArrayParam (qw(InvokerFilter OperationFilter ErrorStageFilter)) {
+        $GetParam{$ArrayParam} = [ $ParamObject->GetArray( Param => $ArrayParam ) ];
+    }
+
+    return \%GetParam;
+}
+
+=head2 _ErrorHandlingTypeCheck()
+
+checks if a given ErrorHandlingType is registered in the system.
+
+=cut
+
+sub _ErrorHandlingTypeCheck {
+    my ( $Self, %Param ) = @_;
+
+    return if !$Param{ErrorHandlingType};
+
+    my $ErrorHandlingConfig = $Kernel::OM->Get('Kernel::Config')->Get('GenericInterface::ErrorHandling::Module');
+    return if !IsHashRefWithData($ErrorHandlingConfig);
+
+    return if !IsHashRefWithData( $ErrorHandlingConfig->{ $Param{ErrorHandlingType} } );
+    return 1;
+}
+
+sub _JSONResponse {
+    my ( $Self, %Param ) = @_;
+
+    my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
+
+    # Build JSON output.
+    my $JSON = $LayoutObject->JSONEncode(
+        Data => {
+            Success => $Param{Success} // 0,
+        },
+    );
+
+    # Send JSON response.
+    return $LayoutObject->Attachment(
+        ContentType => 'application/json; charset=' . $LayoutObject->{Charset},
+        Content     => $JSON,
+        Type        => 'inline',
+        NoCache     => 1,
+    );
+}
+
+1;