ServiceCatalog 11.0.7 Rother OSS GmbH https://otobo.io/ GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Added translations (#9), fixed an import issue (#10), cleanup dynamic fields on uninstall (#16), fixed issing sysconfig for dynamic field screens (#23). Issue #15: Fix picture upload. Added Service and SLA Import and Export functionality to the UI. Fixed ServiceCatalog upgrade for postgres. Fixed Links to be opened in a new tab from the Service Catalog dashboard tile (Issue #11). Show service descriptions with CustomerUIStyles of OTOBO 11.0.11; Add some basic doc; Larger overhaul which brings translatable services, some changes to the responsive css, and shifts part of the functionality to ITSMCore for better usability together with other packages. Removed css for dashboard layout. Please edit Core.Dashboard.Default.css to your needs. Initial Release on OTOBO 11. Ein ausführlicher Leistungskatalog. A detailed service catalog. Catálogo de Servicios detallado. 11.0.x WELCOME! You are about to install the Rother OSS Service Catalog package. For more information visit: https://otobo.de Herzlich willkommen! Sie sind dabei, das Rother OSS Service Catalog-Paket zu installieren. Weitere Informationen finden Sie unter der URL: https://otobo.de BIENVENIDO! Usted está a punto de instalar el paquete del Catálogo de Servicios de Rother OSS. Para más información visite: https://otobo.de NOTE: To show the service catalog to your customers you have to enable the dashboard tile 'CustomerDashboard::Tiles###ServiceCatalog-01'. If you don't want to spend time setting your customer dashboard, and just have a look, we suggest to temporarily disable your other tile with order 7, which is on a standard installation '###InfoTile-01'. BEACHTE: Um den Service Catalog Ihren Kunden zugänglich zu machen, ist es nötig die Dashboard-Kachel 'CustomerDashboard::Tiles###ServiceCatalog-01' zu aktivieren. Um diese einfach erst einmal anzusehen, ohne das gesamte Dashboard neu setzen zu müssen, empfehlen wir vorübergehend die andere Kachel mit "order" 7 zu deaktivieren, auf einer Standart-Installation ist dies '###InfoTile-01'. NOTE: When upgrading from version 11.0.2 or lower, please check that 'CustomerDashboard::Tiles###ServiceCatalog-01' is still enabled. BEACHTE: Wenn Sie von Version 11.0.2 oder niedriger updaten, prüfen Sie bitte, ob 'CustomerDashboard::Tiles###ServiceCatalog-01' noch aktiviert ist. ITSMCore # create the package name my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content}; $Kernel::OM->Get($CodeModule)->CodeUpgradeFromLowerThan_11_0_3(); # create the package name my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content}; $Kernel::OM->Get($CodeModule)->CodeUninstall(); 3c01d5002e344a8b6ce7baeb92b60fc45515356d 2026-08-06 14:44:45 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 - e44c18aea9abc125fddf9ceeed204db4fab290e0 - Kernel/Modules/AdminService.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::AdminService;

use strict;
use warnings;

our $ObjectManagerDisabled = 1;
# ---
# ITSMCore
# ---
use Kernel::System::VariableCheck qw(:all);
# ---

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

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

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

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

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

# Rother OSS / ServiceCatalog
    # 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();
    }

    $Self->{DynamicFieldLookup} = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
        ObjectType => 'Service',
    );
# EO ServiceCatalog

    return $Self;
}

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

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

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

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

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

# Rother OSS / ServiceCatalog
    my $UploadCacheObject = $Kernel::OM->Get('Kernel::System::Web::UploadCache');
# EO ServiceCatalog

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

    # get the dynamic field for ITSMCriticality
    my $DynamicFieldConfigArrayRef = $DynamicFieldObject->DynamicFieldListGet(
        Valid       => 1,
        ObjectType  => [ 'Ticket' ],
        FieldFilter => {
            ITSMCriticality => 1,
        },
    );

    # get the dynamic field value for ITSMCriticality
    my %PossibleValues;
    DYNAMICFIELD:
    for my $DynamicFieldConfig ( @{ $DynamicFieldConfigArrayRef } ) {
        next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);

        # get PossibleValues
        $PossibleValues{ $DynamicFieldConfig->{Name} } = $DynamicFieldConfig->{Config}->{PossibleValues} || {};
    }

    # set the criticality list
    $Self->{CriticalityList} = $PossibleValues{ITSMCriticality};
# ---

    # ------------------------------------------------------------ #
    # service edit
    # ------------------------------------------------------------ #
    if ( $Self->{Subaction} eq 'ServiceEdit' ) {

        # header
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();

        # html output
        $Output .= $Self->_MaskNew(
            %Param,
        );
        $Output .= $LayoutObject->Footer();

        return $Output;
    }

    # ------------------------------------------------------------ #
    # service save
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'ServiceSave' ) {

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

        # get params
        my %GetParam;

# Rother OSS / ServiceCatalog
## ---
## ITSMCore
## ---
##        for (qw(ServiceID ParentID Name ValidID Comment)) {
#        for (qw(ServiceID ParentID Name ValidID Comment TypeID Criticality)) {
## ---

        @{ $GetParam{TicketTypeIDs} } = $ParamObject->GetArray( Param => 'TicketTypeIDs' );
        @{ $GetParam{LanguageID} }    = $ParamObject->GetArray( Param => 'LanguageID' );

        for (qw(ServiceID ParentID Name ValidID Comment Criticality CustomerDefaultService DestQueueID Keywords)) {
# EO ServiceCatalog
            $GetParam{$_} = $ParamObject->GetParam( Param => $_ ) || '';
        }

        my %Error;

# Rother OSS / ServiceCatalog

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

        # get the subject and body for all languages
        for my $LanguageID ( @{ $GetParam{LanguageID} } ) {

            my $DescriptionShort = $ParamObject->GetParam( Param => $LanguageID . '_DescriptionShort' ) || '';
            my $DescriptionLong  = $ParamObject->GetParam( Param => $LanguageID . '_DescriptionLong' )    || '';

            $GetParam{Descriptions}->{$LanguageID} = {
                DescriptionShort => $DescriptionShort,
                DescriptionLong  => $DescriptionLong,
                ContentType      => $GetParam{ContentType},
            };

            # set server error flag if field is empty
            if ( !$DescriptionShort ) {
                $Error{ $LanguageID . '_DescriptionShortServerError' } = "ServerError";
            }
        }

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

        for my $DynamicField ( @{ $Self->{DynamicFieldLookup} }) {

            $GetParam{ 'DynamicField_' . $DynamicField->{Name} } = $DynamicFieldBackendObject->EditFieldValueGet(
                DynamicFieldConfig => $DynamicField,
                ParamObject        => $ParamObject,
                LayoutObject       => $LayoutObject,
            );
        }
# EO ServiceCatalog

        if ( !$GetParam{Name} ) {
            $Error{'NameInvalid'} = 'ServerError';
        }

        my $ServiceName = '';
        if ( $GetParam{ParentID} ) {
            my $Prefix = $ServiceObject->ServiceLookup(
                ServiceID => $GetParam{ParentID},
            );

            if ($Prefix) {
                $ServiceName = $Prefix . "::";
            }
        }
        $ServiceName .= $GetParam{Name};

        if ( length $ServiceName > 200 ) {
            $Error{'NameInvalid'} = 'ServerError';
            $Error{LongName}      = 1;
        }

        if ( !%Error ) {

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

            # save to database
            if ( $GetParam{ServiceID} eq 'NEW' ) {
                $GetParam{ServiceID} = $ServiceObject->ServiceAdd(
                    %GetParam,
                    UserID => $Self->{UserID},
                );
                if ( !$GetParam{ServiceID} ) {
                    $Error{Message} = $LogObject->GetLogEntry(
                        Type => 'Error',
                        What => 'Message',
                    );
                }
            }
            else {
                my $Success = $ServiceObject->ServiceUpdate(
                    %GetParam,
                    UserID => $Self->{UserID},
                );
                if ( !$Success ) {
                    $Error{Message} = $LogObject->GetLogEntry(
                        Type => 'Error',
                        What => 'Message',
                    );
                }
            }

# Rother OSS / ServiceCatalog
            # set customer user service member
            $ServiceObject->CustomerUserServiceMemberAdd(
                CustomerUserLogin => '<DEFAULT>',
                ServiceID         => $GetParam{ServiceID},
                Active            => $GetParam{CustomerDefaultService},
                UserID            => $Self->{UserID},
            );
# EO ServiceCatalog

            if ( !%Error ) {

                # update preferences
                my %ServiceData = $ServiceObject->ServiceGet(
                    ServiceID => $GetParam{ServiceID},
                    UserID    => $Self->{UserID},
                );
                my %Preferences = ();
                if ( $ConfigObject->Get('ServicePreferences') ) {
                    %Preferences = %{ $ConfigObject->Get('ServicePreferences') };
                }
                for my $Item ( sort keys %Preferences ) {
                    my $Module = $Preferences{$Item}->{Module}
                        || 'Kernel::Output::HTML::ServicePreferences::Generic';

                    # load module
                    if ( !$Kernel::OM->Get('Kernel::System::Main')->Require($Module) ) {
                        return $LayoutObject->FatalError();
                    }

                    my $Object = $Module->new(
                        %{$Self},
                        ConfigItem => $Preferences{$Item},
                        Debug      => $Self->{Debug},
                    );
                    my $Note;
                    my @Params = $Object->Param( ServiceData => \%ServiceData );
                    if (@Params) {
                        my %GetParam = ();
                        for my $ParamItem (@Params) {
                            my @Array = $ParamObject->GetArray( Param => $ParamItem->{Name} );
                            $GetParam{ $ParamItem->{Name} } = \@Array;
                        }
                        if (
                            !$Object->Run(
                                GetParam    => \%GetParam,
                                ServiceData => \%ServiceData
                            )
                            )
                        {
                            $Note .= $LayoutObject->Notify( Info => $Object->Error() );
                        }
                    }
                }

# Rother OSS / ServiceCatalog

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

                # Get all existing attachments.
                my @ExistingAttachments = $ServiceObject->AttachmentIndex(
                    ServiceID  => $GetParam{ServiceID},
                    ShowInline => 1,
                    UserID     => $Self->{UserID},
                );

                for my $LanguageID ( @{ $GetParam{LanguageID} } ) {
                    # Lookup old inline attachments (initially loaded to AdminService.pm screen)
                    # and push to Attachments array if they still exist in the form.
                    ATTACHMENT:
                    for my $Attachment (@ExistingAttachments) {
                        if (
                            $GetParam{Descriptions}->{$LanguageID}->{DescriptionLong}
                            =~ m{ Action=AgentITSMServiceZoom;Subaction=DownloadAttachment;ServiceID=$GetParam{ServiceID};FileID=$Attachment->{FileID} }msx
                            )
                        {
                            # Get the existing inline attachment data.
                            my %File = $ServiceObject->AttachmentGet(
                                ServiceID => $GetParam{ServiceID},
                                FileID    => $Attachment->{FileID},
                                UserID    => $Self->{UserID},
                            );

                            push @Attachments, {
                                Content     => $File{Content},
                                ContentType => $File{ContentType},
                                Filename    => $File{Filename},
                                Filesize    => $File{Filesize},
                                Disposition => 'inline',
                                FileID      => $Attachment->{FileID},
                            };
                        }
                    }
                }

                # Build a lookup hash of the new attachments.
                my %NewAttachment;
                for my $Attachment (@Attachments) {

                    # The key is the filename + filesize + content type.
                    my $Key = $Attachment->{Filename}
                        . $Attachment->{Filesize}
                        . $Attachment->{ContentType};

                    # Append content id if available (for new inline images).
                    if ( $Attachment->{ContentID} ) {
                        $Key .= $Attachment->{ContentID};
                    }

                    # Store all of the new attachment data.
                    $NewAttachment{$Key} = $Attachment;
                }

                # Check the existing attachments.
                ATTACHMENT:
                for my $Attachment (@ExistingAttachments) {

                # The key is the filename + filesizeraw + content type (no content id, as existing attachments don't have it).
                    my $Key = $Attachment->{Filename}
                        . $Attachment->{FilesizeRaw}
                        . $Attachment->{ContentType};

                    # Attachment is already existing, we can delete it from the new attachment hash.
                    if ( $NewAttachment{$Key} ) {
                        delete $NewAttachment{$Key};
                    }

                    # Existing attachment is no longer in new attachments hash.
                    else {

                        # Delete the existing attachment.
                        my $DeleteSuccessful = $ServiceObject->AttachmentDelete(
                            ServiceID => $GetParam{ServiceID},
                            FileID    => $Attachment->{FileID},
                            UserID    => $Self->{UserID},
                        );
                        if ( !$DeleteSuccessful ) {
                            return $LayoutObject->FatalError();
                        }
                    }
                }

                for my $Attachment (@Attachments) {
                    # Upload attachments.
                    my $FileID = $ServiceObject->AttachmentAdd(
                        ServiceID   => $GetParam{ServiceID},
                        FileName    => $Attachment->{Filename},
                        ContentSize => $Attachment->{Filesize},
                        ContentType => $Attachment->{ContentType},
                        Content     => $Attachment->{Content},
                        Inline      => 1,
                        UserID      => $Self->{UserID},
                    );

                    if ( !$FileID ) {
                        return $LayoutObject->FatalError();
                    }

                    # Rewrite the URLs of the inline images for the uploaded pictures.
                    my $Success = $ServiceObject->ServiceInlineAttachmentURLUpdate(
                        Attachment => $Attachment,
                        FormID     => $Self->{FormID},
                        ServiceID  => $GetParam{ServiceID},
                        FileID     => $FileID,
                        UserID     => $Self->{UserID},
                    );
                    if ( !$Success ) {
                        $Kernel::OM->Get('Kernel::System::Log')->Log(
                            Priority => 'error',
                            Message  => "Could not update the inline image URLs "
                                . "for ServiceID '$GetParam{ServiceID}'!",
                        );
                    }
                }

                $UploadCacheObject->FormIDRemove( FormID => $Self->{FormID} );

                DYNAMICFIELD:
                for my $DynamicField ( @{ $Self->{DynamicFieldLookup} } ) {
                    my $ValueSet = $DynamicFieldBackendObject->ValueSet(
                        DynamicFieldConfig => $DynamicField,
                        ObjectID           => $GetParam{ServiceID},
                        Value              => $GetParam{ 'DynamicField_' . $DynamicField->{Name} },
                        UserID             => $Self->{UserID},
                    );

                    if ( !$ValueSet ) {
                        $Kernel::OM->Get('Kernel::System::Log')->Log(
                            Priority => 'error',
                            Message  => $LayoutObject->{LanguageObject}->Translate(
                                'Unable to set value for dynamic field %s!',
                                $DynamicField->{Name},
                            ),
                        );
                        next DYNAMICFIELD;
                    }
                }

                # Create Acl if config is enabled
                # We create one Acl per Ticket-Type
                if ( $ConfigObject->Get('ServiceCatalog::CreateTypeServiceRelatedAcls') ) {
                    for my $TicketType ( @{ $GetParam{TicketTypeIDs} } ) {
                        my $Success = $ServiceObject->UpdateTypServiceACL(
                            TicketTypeID => $TicketType,
                            ServiceID    => $GetParam{ServiceID},
                            ServiceValid => $GetParam{ValidID},
                            UserID       => 1,
                        );
                    }
                }
# EO ServiceCatalog

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

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

        # something went wrong
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();
        $Output .= $Error{Message}
            ? $LayoutObject->Notify(
                Priority => 'Error',
                Info     => $Error{Message},
            )
            : '';

        # html output
        $Output .= $Self->_MaskNew(
            %Error,
            %GetParam,
            %Param,
        );
        $Output .= $LayoutObject->Footer();
        return $Output;

    }

    # ------------------------------------------------------------ #
    # service overview
    # ------------------------------------------------------------ #
    else {

        # output header
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();

        # check if service is enabled to use it here
        if ( !$ConfigObject->Get('Ticket::Service') ) {
            $Output .= $LayoutObject->Notify(
                Priority => 'Error',
                Data     => $LayoutObject->{LanguageObject}->Translate( "Please activate %s first!", "Service" ),
                Link     =>
                    $LayoutObject->{Baselink}
                    . 'Action=AdminSystemConfiguration;Subaction=View;Setting=Ticket%3A%3AService;',
            );
        }

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

        $LayoutObject->Block( Name => 'ActionList' );
        $LayoutObject->Block( Name => 'ActionAdd' );
        $LayoutObject->Block(
            Name => 'IncludeInvalid',
            Data => {
                IncludeInvalid        => $Self->{IncludeInvalid},
                IncludeInvalidChecked => $Self->{IncludeInvalid} ? 'checked' : '',
            },
        );
        $LayoutObject->Block( Name => 'Filter' );
# Rother OSS / ServiceCatalog
        $LayoutObject->Block( Name => 'ImportExportWidget' );
# EO ServiceCatalog

        # output overview result
        $LayoutObject->Block(
            Name => 'OverviewList',
            Data => { %Param, },
        );

        # get service list
        my $ServiceList = $ServiceObject->ServiceListGet(
            Valid  => $Self->{IncludeInvalid} ? 0 : 1,
            UserID => $Self->{UserID},
        );

        # if there are any services defined, they are shown
        if ( @{$ServiceList} ) {

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

            # sort the service list by long service name
            @{$ServiceList} = sort { $a->{Name} . '::' cmp $b->{Name} . '::' } @{$ServiceList};

            for my $ServiceData ( @{$ServiceList} ) {

                # output row
                $LayoutObject->Block(
                    Name => 'OverviewListRow',
                    Data => {
                        %{$ServiceData},
                        Valid => $ValidList{ $ServiceData->{ValidID} },
                    },
                );
            }

        }

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

        # generate output
        $Output .= $LayoutObject->Output(
            TemplateFile => 'AdminService',
            Data         => \%Param,
        );
        $Output .= $LayoutObject->Footer();

        return $Output;
    }
    return;
}

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

    my $ServiceObject = $Kernel::OM->Get('Kernel::System::Service');
    my %ServiceData;

    # get params
    $ServiceData{ServiceID} = $Kernel::OM->Get('Kernel::System::Web::Request')->GetParam( Param => "ServiceID" );
    if ( $ServiceData{ServiceID} ne 'NEW' ) {
        %ServiceData = $ServiceObject->ServiceGet(
            ServiceID => $ServiceData{ServiceID},
            UserID    => $Self->{UserID},
        );

# Rother OSS / ServiceCatalog
        $Param{Descriptions} = $ServiceData{Descriptions};
# EO ServiceCatalog
    } 

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

# Rother OSS / ServiceCatalog
    $Param{FormID} = $Self->{FormID};

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

    # output overview
    $LayoutObject->Block(
        Name => 'Overview',
        Data => {
            ServiceID   => $ServiceData{ServiceID},
            ServiceName => $ServiceData{Name},
            %Param,
        },
    );

# Rother OSS / ServiceCatalog
    # output service option reference
    $LayoutObject->Block(
        Name => 'ServiceReference',
    );
# EO ServiceCatalog

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

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

    # get list type
    my $ListType = $ConfigObject->Get('Ticket::Frontend::ListType');

    # generate ParentOptionStrg
    my $KeepChildren = $ConfigObject->Get('Ticket::Service::KeepChildren') // 0;
    my %ServiceList  = $ServiceObject->ServiceList(
        Valid        => !$KeepChildren,
        KeepChildren => $KeepChildren,
        UserID       => $Self->{UserID},
    );
    $ServiceData{ParentOptionStrg} = $LayoutObject->BuildSelection(
        Data           => \%ServiceList,
        Name           => 'ParentID',
        SelectedID     => $Param{ParentID} || $ServiceData{ParentID},
        PossibleNone   => 1,
        TreeView       => ( $ListType eq 'tree' ) ? 1 : 0,
        DisabledBranch => $ServiceData{Name},
        Translation    => 0,
        Class          => 'Modernize',
    );

# Rother OSS / ServiceCatalog
## ---
## ITSMCore
## ---
#    # generate TypeOptionStrg
#    my $TypeList = $Kernel::OM->Get('Kernel::System::GeneralCatalog')->ItemList(
#        Class => 'ITSM::Service::Type',
#    );
#
#    # build the type dropdown
#    $ServiceData{TypeOptionStrg} = $LayoutObject->BuildSelection(
#        Data       => $TypeList,
#        Name       => 'TypeID',
#        SelectedID => $Param{TypeID} || $ServiceData{TypeID},
#        Class      => 'Modernize',
#    );

    my %TicketTypeList = $Kernel::OM->Get('Kernel::System::Type')->TypeList(
        Valid => 1,
    );

    # Build ticket type selection.
    $ServiceData{TicketTypeOptionStrg} = $LayoutObject->BuildSelection(
        Data         => \%TicketTypeList,
        Name         => 'TicketTypeIDs',
        Multiple     => 1,
        PossibleNone => 1,
        SelectedID   => $Param{TicketTypeIDs} || $ServiceData{TicketTypeIDs},
        Class        => 'Modernize',
    );

    # Move Ticket to queue
    my %TicketQueueList = $Kernel::OM->Get('Kernel::System::Queue')->GetAllQueues(
        Valid => 1,
    );

    # Build ticket queue selection.
    $ServiceData{TicketQueueOptionStrg} = $LayoutObject->BuildSelection(
        Data         => \%TicketQueueList,
        Name         => 'DestQueueID',
        Multiple     => 0,
        PossibleNone => 1,
        TreeView       => ( $ListType eq 'tree' ) ? 1 : 0,
        SelectedID   => $Param{DestQueueID} || $ServiceData{DestQueueID},
        Class        => 'Modernize',
    );

    my %DefaultServices = $ServiceObject->CustomerUserServiceMemberList(
        CustomerUserLogin => '<DEFAULT>',
        Result            => 'HASH',
        DefaultServices   => 1,
    );

    $ServiceData{CustomerServiceChecked} = '';

    DEFAULTSERVICE:
    for my $DefService ( keys %DefaultServices ) {

        if ( $ServiceData{ServiceID} eq $DefService ) {
            $ServiceData{CustomerServiceChecked} = 'checked';
            last DEFAULTSERVICE;
        }
    }

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

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

    # build the criticality dropdown
    $ServiceData{CriticalityOptionStrg} = $LayoutObject->BuildSelection(
        Data       => $Self->{CriticalityList},
        Name       => 'Criticality',
        SelectedID => $Param{Criticality} || $ServiceData{Criticality},
        Class      => 'Modernize',
    );
# ---

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

    $ServiceData{ValidOptionStrg} = $LayoutObject->BuildSelection(
        Data       => \%ValidList,
        Name       => 'ValidID',
        SelectedID => $ServiceData{ValidID} || $ValidListReverse{valid},
        Class      => 'Modernize',
    );

    # output service edit
    $LayoutObject->Block(
        Name => 'ServiceEdit',
        Data => { %Param, %ServiceData, },
    );

# Rother OSS / ServiceCatalog
    # Get dynamic field backend object.
    my $DynamicFieldBackendObject = $Kernel::OM->Get('Kernel::System::DynamicField::Backend');
    my $ParamObject               = $Kernel::OM->Get('Kernel::System::Web::Request');

    DYNAMICFIELD:
    for my $DynamicField ( @{ $Self->{DynamicFieldLookup} } ) {

        my $ValueGet = $DynamicFieldBackendObject->ValueGet(
            DynamicFieldConfig => $DynamicField,
            ObjectID           => $ServiceData{ServiceID},
            UserID             => $Self->{UserID},
        );

        # Get HTML for dynamic field
        my $DynamicFieldHTML = $DynamicFieldBackendObject->EditFieldRender(
            DynamicFieldConfig => $DynamicField,
            Value              => $ValueGet,
            # Mandatory          => 0,
            LayoutObject       => $LayoutObject,
            ParamObject        => $ParamObject,

            # Server error, if any
            # %{ $Param{Errors}->{ $Entry->[0] } },
        );

        next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldHTML);

        $LayoutObject->Block(
            Name => 'DynamicField',
            Data => {
                Name  => $DynamicField->{Name},
                Label => $DynamicFieldHTML->{Label},
                Field => $DynamicFieldHTML->{Field},
            },
        );
    }

    # get names of languages in English
    my %DefaultUsedLanguages = %{ $ConfigObject->Get('DefaultUsedLanguages') || {} };

    # get native names of languages
    my %DefaultUsedLanguagesNative = %{ $ConfigObject->Get('DefaultUsedLanguagesNative') || {} };    

    my %Languages;
    LANGUAGEID:
    for my $LanguageID ( sort keys %DefaultUsedLanguages ) {

        # next language if there is not set any name for current language
        if ( !$DefaultUsedLanguages{$LanguageID} && !$DefaultUsedLanguagesNative{$LanguageID} ) {
            next LANGUAGEID;
        }

        # get texts in native and default language
        my $Text        = $DefaultUsedLanguagesNative{$LanguageID} || '';
        my $TextEnglish = $DefaultUsedLanguages{$LanguageID}       || '';

        # translate to current user's language
        my $TextTranslated =
            $Kernel::OM->Get('Kernel::Output::HTML::Layout')->{LanguageObject}->Translate($TextEnglish);

        if ( $TextTranslated && $TextTranslated ne $Text ) {
            $Text .= ' - ' . $TextTranslated;
        }

        # next language if there is not set English nor native name of language.
        next LANGUAGEID if !$Text;

        $Languages{$LanguageID} = $Text;
    }

    # copy original list of languages which will be used for rebuilding language selection
    my %OriginalDefaultUsedLanguages = %Languages;

    # get language ids from Descriptions parameter, use English if no Descriptions is given
    # make sure English is the first language
    my @LanguageIDs;
    if ( IsHashRefWithData( $Param{Descriptions} ) ) {
        if ( $Param{Descriptions}->{en} ) {
            push @LanguageIDs, 'en';
        }
        LANGUAGEID:
        for my $LanguageID ( sort keys %{ $Param{Descriptions} } ) {
            next LANGUAGEID if $LanguageID eq 'en';
            push @LanguageIDs, $LanguageID;
        }
    }
    elsif ( $DefaultUsedLanguages{en} ) {
        push @LanguageIDs, 'en';
    }
    else {
        push @LanguageIDs, ( sort keys %DefaultUsedLanguages )[0];
    }

    for my $LanguageID (@LanguageIDs) {
        # format the content according to the content type
        if ( $LayoutObject->{BrowserRichText} ) {

            # make sure DescriptionLong is rich text (if DescriptionLong is based on config)
            if (
                $Param{Descriptions}->{$LanguageID}->{ContentType}
                && $Param{Descriptions}->{$LanguageID}->{ContentType} =~ m{text\/plain}xmsi
                )
            {
                $Param{Descriptions}->{$LanguageID}->{DescriptionLong} = $HTMLUtilsObject->ToHTML(
                    String => $Param{Descriptions}->{$LanguageID}->{DescriptionLong},
                );
            }
        }
        else {

            # reformat from HTML to plain
            if (
                $Param{Descriptions}->{$LanguageID}->{ContentType}
                && $Param{Descriptions}->{$LanguageID}->{ContentType} =~ m{text\/html}xmsi
                && $Param{Descriptions}->{$LanguageID}->{DescriptionLong}
                )
            {
                $Param{Descriptions}->{$LanguageID}->{DescriptionLong} = $HTMLUtilsObject->ToAscii(
                    String => $Param{Descriptions}->{$LanguageID}->{DescriptionLong},
                );
            }
        }

        # show the descriptions for this language
        $LayoutObject->Block(
            Name => 'ServiceLanguage',
            Data => {
                %Param,
                DescriptionShort            => $Param{Descriptions}->{$LanguageID}->{DescriptionShort} || '',
                DescriptionLong             => $Param{Descriptions}->{$LanguageID}->{DescriptionLong}  || '',
                LanguageID                  => $LanguageID,
                Language                    => $Languages{$LanguageID},
                DescriptionShortServerError => $Param{ $LanguageID . '_DescriptionShortServerError' } || ''
            },
        );

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

        # delete language from drop-down list because it is already shown
        delete $Languages{$LanguageID};
    }

    $Param{LanguageStrg} = $LayoutObject->BuildSelection(
        Data         => \%Languages,
        Name         => 'Language',
        Class        => 'Modernize W50pc LanguageAdd',
        Translation  => 1,
        PossibleNone => 1,
        HTMLQuote    => 0,
    );

    $Param{LanguageOrigStrg} = $LayoutObject->BuildSelection(
        Data         => \%OriginalDefaultUsedLanguages,
        Name         => 'LanguageOrig',
        Translation  => 1,
        PossibleNone => 1,
        HTMLQuote    => 0,
    );

    $LayoutObject->Block(
        Name => 'LanguageOptions',
        Data => \%Param,
    );
# EO ServiceCatalog

    # show each preferences setting
    my %Preferences = ();
    if ( $ConfigObject->Get('ServicePreferences') ) {
        %Preferences = %{ $ConfigObject->Get('ServicePreferences') };
    }
    for my $Item ( sort keys %Preferences ) {
        my $Module = $Preferences{$Item}->{Module}
            || 'Kernel::Output::HTML::ServicePreferences::Generic';

        # load module
        if ( !$Kernel::OM->Get('Kernel::System::Main')->Require($Module) ) {
            return $LayoutObject->FatalError();
        }
        my $Object = $Module->new(
            %{$Self},
            ConfigItem => $Preferences{$Item},
            Debug      => $Self->{Debug},
        );
        my @Params = $Object->Param( ServiceData => \%ServiceData );
        if (@Params) {
            for my $ParamItem (@Params) {
                $LayoutObject->Block(
                    Name => 'Item',
                    Data => { %Param, },
                );
                if (
                    ref( $ParamItem->{Data} ) eq 'HASH'
                    || ref( $Preferences{$Item}->{Data} ) eq 'HASH'
                    )
                {
                    my %BuildSelectionParams = (
                        %{ $Preferences{$Item} },
                        %{$ParamItem},
                    );
                    $BuildSelectionParams{Class} = join( ' ', $BuildSelectionParams{Class} // '', 'Modernize' );

                    $ParamItem->{'Option'} = $LayoutObject->BuildSelection(
                        %BuildSelectionParams,
                    );
                }
                $LayoutObject->Block(
                    Name => $ParamItem->{Block} || $Preferences{$Item}->{Block} || 'Option',
                    Data => {
                        %{ $Preferences{$Item} },
                        %{$ParamItem},
                    },
                );
            }
        }
    }

    # generate output
    return $LayoutObject->Output(
        TemplateFile => 'AdminService',
        Data         => \%Param
    );
}

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 - e44c18aea9abc125fddf9ceeed204db4fab290e0 - Kernel/Modules/AdminSLA.pm
# --
# $origin: otobo - e44c18aea9abc125fddf9ceeed204db4fab290e0 - Kernel/Modules/AdminSLA.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::AdminSLA;

use strict;
use warnings;

our $ObjectManagerDisabled = 1;

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

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

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

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

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

    return $Self;
}

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

    my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
    my $ParamObject  = $Kernel::OM->Get('Kernel::System::Web::Request');
    my $ConfigObject = $Kernel::OM->Get('Kernel::Config');
    my $SLAObject    = $Kernel::OM->Get('Kernel::System::SLA');
    my %Error        = ();

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

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

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

    # ------------------------------------------------------------ #
    # sla edit
    # ------------------------------------------------------------ #
    if ( $Self->{Subaction} eq 'SLAEdit' ) {

        # header
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();

        # html output
        $Output .= $Self->_MaskNew(
            %Param,
            Subaction => $Self->{Subaction},
        );
        $Output .= $LayoutObject->Footer();

        return $Output;
    }

    # ------------------------------------------------------------ #
    # sla save
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'SLASave' ) {

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

        # get params
        my %GetParam;
        for my $Param (
# ---
# ITSMCore
# ---
#            qw(SLAID Name Calendar FirstResponseTime FirstResponseNotify SolutionTime SolutionNotify UpdateTime UpdateNotify ValidID Comment)
            qw(SLAID Name Calendar FirstResponseTime FirstResponseNotify SolutionTime SolutionNotify UpdateTime UpdateNotify ValidID Comment TypeID MinTimeBetweenIncidents)
# ---
            )
        {
            $GetParam{$Param} = $ParamObject->GetParam( Param => $Param ) || '';
        }

        # check needed stuff
        %Error = ();
        if ( !$GetParam{Name} ) {
            $Error{'NameInvalid'} = 'ServerError';
        }

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

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

            # get service ids
            my @ServiceIDs = $ParamObject->GetArray( Param => 'ServiceIDs' );
            $GetParam{ServiceIDs} = \@ServiceIDs;

            # save to database
            if ( !$GetParam{SLAID} ) {

                # add a new sla
                $GetParam{SLAID} = $SLAObject->SLAAdd(
                    %GetParam,
                    UserID => $Self->{UserID},
                );
                if ( !$GetParam{SLAID} ) {
                    $Error{Message} = $LogObject->GetLogEntry(
                        Type => 'Error',
                        What => 'Message',
                    );
                }
            }
            else {

                # update the sla
                my $Success = $SLAObject->SLAUpdate(
                    %GetParam,
                    UserID => $Self->{UserID},
                );
                if ( !$Success ) {
                    $Error{Message} = $LogObject->GetLogEntry(
                        Type => 'Error',
                        What => 'Message',
                    );
                }
            }

            if ( !%Error ) {

                # update preferences
                my %SLAData = $SLAObject->SLAGet(
                    SLAID  => $GetParam{SLAID},
                    UserID => $Self->{UserID},
                );
                my %Preferences = ();
                if ( $ConfigObject->Get('SLAPreferences') ) {
                    %Preferences = %{ $ConfigObject->Get('SLAPreferences') };
                }
                for my $Item ( sort keys %Preferences ) {
                    my $Module = $Preferences{$Item}->{Module}
                        || 'Kernel::Output::HTML::SLAPreferences::Generic';

                    # load module
                    if ( !$Kernel::OM->Get('Kernel::System::Main')->Require($Module) ) {
                        return $LayoutObject->FatalError();
                    }

                    my $Object = $Module->new(
                        %{$Self},
                        ConfigItem => $Preferences{$Item},
                        Debug      => $Self->{Debug},
                    );
                    my $Note;
                    my @Params = $Object->Param( SLAData => \%SLAData );
                    if (@Params) {
                        my %GetParam = ();
                        for my $ParamItem (@Params) {
                            my @Array = $ParamObject->GetArray( Param => $ParamItem->{Name} );
                            $GetParam{ $ParamItem->{Name} } = \@Array;
                        }
                        if (
                            !$Object->Run(
                                GetParam => \%GetParam,
                                SLAData  => \%SLAData
                            )
                            )
                        {
                            $Note .= $LayoutObject->Notify( Info => $Object->Error() );
                        }
                    }
                }

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

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

        }

        # header
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();
        $Output .= $Error{Message}
            ? $LayoutObject->Notify(
                Priority => 'Error',
                Info     => $Error{Message},
            )
            : '';

        # html output
        $Output .= $Self->_MaskNew(
            %Param,
            %GetParam,
            %Error,
        );

        $Output .= $LayoutObject->Footer();
        return $Output;
    }

    # ------------------------------------------------------------ #
    # sla overview
    # ------------------------------------------------------------ #
    else {

        # output header
        my $Output = $LayoutObject->Header();
        $Output .= $LayoutObject->NavigationBar();

        # check if service is enabled to use it here
        if ( !$ConfigObject->Get('Ticket::Service') ) {
            $Output .= $LayoutObject->Notify(
                Priority => 'Error',
                Data     => $LayoutObject->{LanguageObject}->Translate( "Please activate %s first!", "Service" ),
                Link     =>
                    $LayoutObject->{Baselink}
                    . 'Action=AdminSystemConfiguration;Subaction=View;Setting=Ticket%3A%3AService;',
            );
        }

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

        $LayoutObject->Block( Name => 'ActionList' );
        $LayoutObject->Block( Name => 'ActionAdd' );
        $LayoutObject->Block(
            Name => 'IncludeInvalid',
            Data => {
                IncludeInvalid        => $Self->{IncludeInvalid},
                IncludeInvalidChecked => $Self->{IncludeInvalid} ? 'checked' : '',
            },
        );
        $LayoutObject->Block( Name => 'Filter' );
# Rother OSS / ServiceCatalog
        $LayoutObject->Block( Name => 'ImportExportWidget' );
# EO ServiceCatalog

        # output overview result
        $LayoutObject->Block(
            Name => 'OverviewList',
            Data => {
                %Param,
            },
        );

        # get service list
        my %ServiceList = $Kernel::OM->Get('Kernel::System::Service')->ServiceList(
            Valid  => 0,
            UserID => $Self->{UserID},
        );

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

        # get sla list
        my %SLAList = $SLAObject->SLAList(
            Valid  => $Self->{IncludeInvalid} ? 0 : 1,
            UserID => $Self->{UserID},
        );

        # if there are any SLA's defined, they are shown
        if (%SLAList) {
            SLAID:
            for my $SLAID ( sort { lc $SLAList{$a} cmp lc $SLAList{$b} } keys %SLAList ) {

                # get the sla data
                my %SLAData = $SLAObject->SLAGet(
                    SLAID  => $SLAID,
                    UserID => $Self->{UserID},
                );

                # build the service list
                my @ServiceList;
                for my $ServiceID (
                    sort { lc $ServiceList{$a} cmp lc $ServiceList{$b} }
                    @{ $SLAData{ServiceIDs} }
                    )
                {
                    push @ServiceList, $ServiceList{$ServiceID} || '-';
                }

                # output overview list row
                $LayoutObject->Block(
                    Name => 'OverviewListRow',
                    Data => {
                        %SLAData,
                        Service => $ServiceList[0] || '-',
                        Valid   => $ValidList{ $SLAData{ValidID} },
                    },
                );

                next SLAID if scalar @ServiceList <= 1;

                # remove the first service id
                shift @ServiceList;

                for my $ServiceName (@ServiceList) {

                    # output overview list row
                    $LayoutObject->Block(
                        Name => 'OverviewListRow',
                        Data => {
                            Service => $ServiceName,
                        },
                    );
                }
            }
        }

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

        # generate output
        $Output .= $LayoutObject->Output(
            TemplateFile => 'AdminSLA',
            Data         => \%Param,
        );
        $Output .= $LayoutObject->Footer();

        return $Output;
    }
}

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

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

    # get params
    my %SLAData;
    $SLAData{SLAID} = $ParamObject->GetParam( Param => 'SLAID' ) || '';

    if ( $SLAData{SLAID} ) {

        # get sla data
        %SLAData = $Kernel::OM->Get('Kernel::System::SLA')->SLAGet(
            SLAID  => $SLAData{SLAID},
            UserID => $Self->{UserID},
        );
    }
    else {
        $SLAData{ServiceID} = $ParamObject->GetParam( Param => 'ServiceID' );
    }

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

    # get list type
    my $ListType = $ConfigObject->Get('Ticket::Frontend::ListType');

    # get service list
    my %ServiceList = $Kernel::OM->Get('Kernel::System::Service')->ServiceList(
        Valid        => 1,
        KeepChildren => $ConfigObject->Get('Ticket::Service::KeepChildren') // 0,
        UserID       => $Self->{UserID},
    );

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

    # generate ServiceOptionStrg
    $Param{ServiceOptionStrg} = $LayoutObject->BuildSelection(
        Data        => \%ServiceList,
        Name        => 'ServiceIDs',
        SelectedID  => $SLAData{ServiceIDs} || [],
        Multiple    => 1,
        Size        => 5,
        Translation => 0,
        TreeView    => ( $ListType eq 'tree' ) ? 1 : 0,
        Max         => 200,
        Class       => 'Modernize',
    );
# ---
# ITSMCore
# ---
        # generate TypeOptionStrg
        my $TypeList = $Kernel::OM->Get('Kernel::System::GeneralCatalog')->ItemList(
            Class => 'ITSM::SLA::Type',
        );
        $Param{TypeOptionStrg} = $LayoutObject->BuildSelection(
            Data       => $TypeList,
            Name       => 'TypeID',
            SelectedID => $SLAData{TypeID},
            Class      => 'Modernize',
        );
# ---

    # generate CalendarOptionStrg
    my %CalendarList;

    my $Maximum = $ConfigObject->Get("MaximumCalendarNumber") || 50;

    for my $CalendarNumber ( '', 1 .. $Maximum ) {
        if ( $ConfigObject->Get("TimeVacationDays::Calendar$CalendarNumber") ) {
            $CalendarList{$CalendarNumber} = "Calendar $CalendarNumber - "
                . $ConfigObject->Get( "TimeZone::Calendar" . $CalendarNumber . "Name" );
        }
    }
    $SLAData{CalendarOptionStrg} = $LayoutObject->BuildSelection(
        Data         => \%CalendarList,
        Name         => 'Calendar',
        SelectedID   => $Param{Calendar} || $SLAData{Calendar},
        Translation  => 0,
        PossibleNone => 1,
        Class        => 'Modernize',
    );
    my %NotifyLevelList = (
        10 => '10%',
        20 => '20%',
        30 => '30%',
        40 => '40%',
        50 => '50%',
        60 => '60%',
        70 => '70%',
        80 => '80%',
        90 => '90%',
    );
    $SLAData{FirstResponseNotifyOptionStrg} = $LayoutObject->BuildSelection(
        Data         => \%NotifyLevelList,
        Name         => 'FirstResponseNotify',
        SelectedID   => $Param{FirstResponseNotify} || $SLAData{FirstResponseNotify},
        Translation  => 0,
        PossibleNone => 1,
        Class        => 'Modernize',
    );
    $SLAData{UpdateNotifyOptionStrg} = $LayoutObject->BuildSelection(
        Data         => \%NotifyLevelList,
        Name         => 'UpdateNotify',
        SelectedID   => $Param{UpdateNotify} || $SLAData{UpdateNotify},
        Translation  => 0,
        PossibleNone => 1,
        Class        => 'Modernize',
    );
    $SLAData{SolutionNotifyOptionStrg} = $LayoutObject->BuildSelection(
        Data         => \%NotifyLevelList,
        Name         => 'SolutionNotify',
        SelectedID   => $Param{SolutionNotify} || $SLAData{SolutionNotify},
        Translation  => 0,
        PossibleNone => 1,
        Class        => 'Modernize',
    );

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

    $SLAData{ValidOptionStrg} = $LayoutObject->BuildSelection(
        Data       => \%ValidList,
        Name       => 'ValidID',
        SelectedID => $Param{ValidID} || $SLAData{ValidID} || $ValidListReverse{valid},
        Class      => 'Modernize',
    );

    # output sla edit
    $LayoutObject->Block(
        Name => 'Overview',
        Data => {
            SLAID     => $SLAData{SLAID},
            SLAName   => $SLAData{Name},
            Subaction => $Param{Subaction},
            %Param
        },
    );

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

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

    # shows header
    if ( $SLAData{SLAID} ) {
        $LayoutObject->Block( Name => 'HeaderEdit' );
    }
    else {
        $LayoutObject->Block( Name => 'HeaderAdd' );
    }

    # show each preferences setting
    my %Preferences = ();
    if ( $ConfigObject->Get('SLAPreferences') ) {
        %Preferences = %{ $ConfigObject->Get('SLAPreferences') };
    }
    for my $Item ( sort keys %Preferences ) {
        my $Module = $Preferences{$Item}->{Module}
            || 'Kernel::Output::HTML::SLAPreferences::Generic';

        # load module
        if ( !$Kernel::OM->Get('Kernel::System::Main')->Require($Module) ) {
            return $LayoutObject->FatalError();
        }
        my $Object = $Module->new(
            %{$Self},
            ConfigItem => $Preferences{$Item},
            Debug      => $Self->{Debug},
        );
        my @Params = $Object->Param( SLAData => \%SLAData );
        if (@Params) {
            for my $ParamItem (@Params) {
                $LayoutObject->Block(
                    Name => 'SLAItem',
                    Data => { %Param, },
                );
                if (
                    ref( $ParamItem->{Data} ) eq 'HASH'
                    || ref( $Preferences{$Item}->{Data} ) eq 'HASH'
                    )
                {
                    my %BuildSelectionParams = (
                        %{ $Preferences{$Item} },
                        %{$ParamItem},
                    );
                    $BuildSelectionParams{Class} = join( ' ', $BuildSelectionParams{Class} // '', 'Modernize' );

                    $ParamItem->{'Option'} = $LayoutObject->BuildSelection(
                        %BuildSelectionParams,
                    );
                }
                $LayoutObject->Block(
                    Name => $ParamItem->{Block} || $Preferences{$Item}->{Block} || 'Option',
                    Data => {
                        %{ $Preferences{$Item} },
                        %{$ParamItem},
                    },
                );
            }
        }
    }

    # get output back
    return $LayoutObject->Output(
        TemplateFile => 'AdminSLA',
        Data         => \%Param
    );
}

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 -  - Kernel/Modules/AgentITSMServiceZoom.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::AgentITSMServiceZoom;

use strict;
use warnings;

use Kernel::Language qw(Translatable);
# Rother OSS / ServiceCatalog
use Kernel::System::VariableCheck qw(IsHashRefWithData);
# EO ServiceCatalog

our $ObjectManagerDisabled = 1;

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

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

    return $Self;
}

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

    # get params
    my $ServiceID = $Kernel::OM->Get('Kernel::System::Web::Request')->GetParam( Param => 'ServiceID' );

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

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

    # get service
    my %Service = $Kernel::OM->Get('Kernel::System::Service')->ServiceGet(
        ServiceID     => $ServiceID,
        IncidentState => 1,
        UserID        => $Self->{UserID},
    );
    if ( !$Service{ServiceID} ) {
        return $LayoutObject->ErrorScreen(
            Message => $LayoutObject->{LanguageObject}->Translate( 'ServiceID %s not found in database!', $ServiceID ),
            Comment => Translatable('Please contact the administrator.'),
        );
    }

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

# Rother OSS / ServiceCatalog
   # ---------------------------------------------------------- #
    # HTMLView Subaction
    # ---------------------------------------------------------- #
    if ( $Self->{Subaction} eq 'HTMLView' ) {

        $Service{DescriptionLong} = $LayoutObject->HTMLLinkQuote(
            String => $Service{Descriptions}{$LayoutObject->{UserLanguage}}{DescriptionLong}
                || $Service{Descriptions}{$Kernel::OM->Get('Kernel::Config')->Get('DefaultLanguage')}{DescriptionLong}
                || $Service{Descriptions}{'en'}{DescriptionLong}
                || $LayoutObject->{LanguageObject}->Translate( 'Description not available.' ),
        );

        # add needed HTML headers
        $Service{DescriptionLong} = $Kernel::OM->Get('Kernel::System::HTMLUtils')->DocumentComplete(
            String  => $Service{DescriptionLong},
            Charset => 'utf-8',
        );

        # return complete HTML as an attachment
        return $LayoutObject->Attachment(
            Type        => 'inline',
            ContentType => 'text/html',
            Content     => $Service{DescriptionLong},
        );
    }
    # ---------------------------------------------------------- #
    # DownloadAttachment Subaction
    # ---------------------------------------------------------- #
    elsif ( $Self->{Subaction} eq 'DownloadAttachment' ) {

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

        if ( !defined $FileID ) {
            return $LayoutObject->FatalError(
                Message => Translatable('Need FileID!'),
            );
        }

        # Get attachments.
        my %File = $Kernel::OM->Get('Kernel::System::Service')->AttachmentGet(
            ServiceID => $ServiceID,
            FileID    => $FileID,
            UserID    => $Self->{UserID},
        );
        if (%File) {
            return $LayoutObject->Attachment(%File);
        }
        else {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Message  => "No such attachment ($FileID)! May be an attack!!!",
                Priority => 'error',
            );
            return $LayoutObject->ErrorScreen();
        }
    }

    $Service{DescriptionShort} = $Service{Descriptions}{$LayoutObject->{UserLanguage}}{DescriptionShort} ||
            $Service{Descriptions}{$Kernel::OM->Get('Kernel::Config')->Get('DefaultLanguage')}{DescriptionShort} ||
            $Service{Descriptions}{'en'}{DescriptionShort} ||
            $LayoutObject->{LanguageObject}->Translate( 'Description not available.' );

    # build dynamic fields.
    my @DynamicFieldList;
    my $DynamicFieldLookup = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
        ObjectType => 'Service',
    );

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

    DYNAMICFIELD:
    for my $DynamicField ( @{$DynamicFieldLookup} ) {
        next DYNAMICFIELD if !IsHashRefWithData($DynamicField);

        my $ValueGet = $DynamicFieldBackendObject->ValueGet(
            DynamicFieldConfig => $DynamicField,
            ObjectID           => $ServiceID,
            UserID             => $Self->{UserID},
        );

        next DYNAMICFIELD if !$ValueGet;

        # use translation here to be able to reduce the character length in the template
        my $Label = $LayoutObject->{LanguageObject}->Translate( $DynamicField->{Label} );

        my $ValueStrg = $DynamicFieldBackendObject->DisplayValueRender(
            DynamicFieldConfig => $DynamicField,
            Value              => $ValueGet,
            LayoutObject       => $LayoutObject,
            ValueMaxChars      => 130,
        );

        push @DynamicFieldList, {
            $DynamicField->{Name} => $ValueStrg->{Title},
            Name                  => $DynamicField->{Name},
            Title                 => $ValueStrg->{Title},
            Value                 => $ValueStrg->{Value},
            Label                 => $Label,
            Link                  => $ValueStrg->{Link},
            LinkPreview           => $ValueStrg->{LinkPreview},
            TitleFieldConfig      => ( $DynamicField->{FieldType} eq 'Title' ) ? $DynamicField->{Config} : undef,

            # Include unique parameter with dynamic field name in case of collision with others.
            #   Please see bug#13362 for more information.
            "DynamicField_$DynamicField->{Name}" => $ValueStrg->{Title},
        };
    }

    # output dynamic fields
    FIELD:
    for my $Field (@DynamicFieldList) {

        # handle titles separately
        if ( $Field->{TitleFieldConfig} ) {
            my $Style = "padding-left:4px;font-size:$Field->{TitleFieldConfig}{FontSize}px;color:$Field->{TitleFieldConfig}{FontColor};";

            if ( $Field->{TitleFieldConfig}{CBFontStyleUnderLineValue} ) {
                $Style .= "text-decoration:underline;";
            }
            if ( $Field->{TitleFieldConfig}{CBFontStyleItalicValue} ) {
                $Style .= "font-style:italic;";
            }
            if ( $Field->{TitleFieldConfig}{CBFontStyleBoldValue} ) {
                $Style .= "font-weight:bold;";
            }

            $LayoutObject->Block(
                Name => 'TicketDynamicField',
                Data => {
                    Text       => $Field->{Label},
                    Style      => $Style,
                    TitleField => 1,
                },
            );

            next FIELD;
        }

        $LayoutObject->Block(
            Name => 'ServiceDynamicField',
            Data => {
                Label => $Field->{Label},
            },
        );

        if ( $Field->{Link} ) {
            $LayoutObject->Block(
                Name => 'ServiceDynamicFieldLink',
                Data => {
                    $Field->{Name} => $Field->{Title},
                    Value          => $Field->{Value},
                    Title          => $Field->{Title},
                    Link           => $Field->{Link},
                    LinkPreview    => $Field->{LinkPreview},

                    # Include unique parameter with dynamic field name in case of collision with others.
                    #   Please see bug#13362 for more information.
                    "DynamicField_$Field->{Name}" => $Field->{Title},
                },
            );
        }
        else {
            $LayoutObject->Block(
                Name => 'ServiceDynamicFieldPlain',
                Data => {
                    Value => $Field->{Value},
                    Title => $Field->{Title},
                },
            );
        }
    }
# EO ServiceCatalog

    # run config item menu modules
    if ( ref $ConfigObject->Get('ITSMService::Frontend::MenuModule') eq 'HASH' ) {
        my %Menus   = %{ $ConfigObject->Get('ITSMService::Frontend::MenuModule') };
        my $Counter = 0;
        for my $Menu ( sort keys %Menus ) {

            # load module
            if ( $Kernel::OM->Get('Kernel::System::Main')->Require( $Menus{$Menu}->{Module} ) ) {
                my $Object = $Menus{$Menu}->{Module}->new(
                    %{$Self},
                    ServiceID => $Service{ServiceID},
                );

                # set classes
                if ( $Menus{$Menu}->{Target} ) {
                    if ( $Menus{$Menu}->{Target} eq 'PopUp' ) {
                        $Menus{$Menu}->{MenuClass} = 'AsPopup';
                    }
                    elsif ( $Menus{$Menu}->{Target} eq 'Back' ) {
                        $Menus{$Menu}->{MenuClass} = 'HistoryBack';
                    }
                }

                # run module
                $Counter = $Object->Run(
                    %Param,
                    Service => \%Service,
                    Counter => $Counter,
                    Config  => $Menus{$Menu},
                );
            }
            else {
                return $LayoutObject->FatalError();
            }
        }
    }

    # get sla object
    my $SLAObject = $Kernel::OM->Get('Kernel::System::SLA');

    # get sla list
    my %SLAList = $SLAObject->SLAList(
        ServiceID => $ServiceID,
        UserID    => $Self->{UserID},
    );
    if (%SLAList) {

        # output row
        $LayoutObject->Block(
            Name => 'SLA',
        );

        for my $SLAID ( sort { $SLAList{$a} cmp $SLAList{$b} } keys %SLAList ) {

            # get sla data
            my %SLA = $SLAObject->SLAGet(
                SLAID  => $SLAID,
                UserID => $Self->{UserID},
            );

            # output row
            $LayoutObject->Block(
                Name => 'SLARow',
                Data => {
                    %SLA,
                },
            );
        }
    }

    # get linked objects
    my $LinkListWithData = $Kernel::OM->Get('Kernel::System::LinkObject')->LinkListWithData(
        Object => 'Service',
        Key    => $ServiceID,
        State  => 'Valid',
        UserID => $Self->{UserID},
    );

    # get link table view mode
    my $LinkTableViewMode = $ConfigObject->Get('LinkObject::ViewMode');

    # create the link table
    my $LinkTableStrg = $LayoutObject->LinkObjectTableCreate(
        LinkListWithData => $LinkListWithData,
        ViewMode         => $LinkTableViewMode,
        Object           => 'Service',
        Key              => $ServiceID,
    );

    # output the link table
    if ($LinkTableStrg) {
        $LayoutObject->Block(
            Name => 'LinkTable' . $LinkTableViewMode,
            Data => {
                LinkTableStrg => $LinkTableStrg,
            },
        );
    }

    # set incident signal
    my %InciSignals = (
        Translatable('operational') => 'greenled',
        Translatable('warning')     => 'yellowled',
        Translatable('incident')    => 'redled',
    );

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

    # get create user data
    $Service{CreateByName} = $UserObject->UserName(
        UserID => $Service{CreateBy},
    );

    # get change user data
    $Service{ChangeByName} = $UserObject->UserName(
        UserID => $Service{ChangeBy},
    );

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

    # output header
    my $Output = $LayoutObject->Header();
    $Output .= $LayoutObject->NavigationBar();

    # generate output
    $Output .= $LayoutObject->Output(
        TemplateFile => 'AgentITSMServiceZoom',
        Data         => {
            %Param,
            %Service,
            CurInciSignal => $InciSignals{ $Service{CurInciStateType} },
        },
    );
    $Output .= $LayoutObject->Footer();

    return $Output;
}

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

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

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

    [% IF Data.ServiceID == "NEW"  %]
        [% BreadcrumbPath.push({ Name => Translate("Add Service"),}) %]
    [% ELSIF Data.ServiceID %]
        [% USE EditTitle = String(Translate("Edit Service")) %]
        [% BreadcrumbPath.push({ Name => EditTitle.append( ': ', Data.ServiceName ) }) %]
    [% END %]

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

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

[% RenderBlockStart("Filter") %]
        <div class="WidgetSimple">
            <div class="Header">
                <h2><label for="FilterServices">[% Translate("Filter for Services") | html %]</label></h2>
            </div>
            <div class="Content">
                <input type="text" id="FilterServices" class="FilterBox" placeholder="[% Translate("Just start typing to filter...") | html %]" name="FilterServices" value="" title="[% Translate("Filter for services") | html %]">
            </div>
        </div>
[% RenderBlockEnd("Filter") %]
# Rother OSS / ServiceCatalog
[% RenderBlockStart("ImportExportWidget") %]
        <div class='WidgetSimple' id='ServiceImportExportWidget'>
            <div class='Header'>
                <h1 class="InvisibleText">
                    [% Translate("Import / Export") | html %]
                </h1>
            </div>

            [% BreadcrumbPath = [
                    {
                        Name => Translate('Import / Export'),
                    },
                ]
            %]

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

            <div class='Content'>
                <p class='FieldExplanation'>
                    [% Translate('Here you can upload a configuration file to import services to your system. The file needs to be in .yml format as exported by the service management module.') | html %]
                </p>
                <ul class='ActionList SpacingTop'>
                    <li>
                        <form action='[% Env("CGIHandle") %]' method='post' enctype='multipart/form-data' class='Validate PreventMultipleSubmits'>
                            <input type='hidden' name='ChallengeToken' value=[% Env("UserChallengeToken") | JSON %]>
                            <input type='hidden' name='Action' value='AdminServiceImportExport'/>
                            <input type='hidden' name='Subaction' value='Import'/>
                            <input name='FileUpload' id='FileUpload' type='file' size='18' class='Fixed W100pc Validate_Required [% Data.FileUploadInvalid | html %]'/>
                            <div id='FileUploadError' class='TooltipErrorMessage'>
                                <p>
                                    [% Translate('This field is required.') | html %]
                                </p>
                            </div>
                            <div id='FileUploadServerError' class='TooltipErrorMessage'>
                                <p>
                                    % Translate('This field is required.') | html %]
                                </p>
                            </div>
                            <fieldset class='SpacingTop'>
                                <input type='checkbox' id='OverwriteExistingEntitiesExample' name='OverwriteExistingEntities' value='1'/>
                                <label for='OverwriteExistingEntitiesExample'>
                                    [% Translate('Overwrite existing entities') | html %]
                                </label>
                            </fieldset>
                            <button class='CallForAction Fullsize Center SpacingTop' id='ServiceImport' type='submit'>
                                <span><i class='fa fa-upload'></i>
                                    [% Translate('Services Import') | html %]
                                </span>
                            </button>
                        </form>
                    </li>
                    <li>
                        <a href='[% Env("Baselink") %]Action=AdminServiceImportExport;Subaction=Export' id='ServiceExport' class='CallForAction Fullsize Center'>
                            <span><i class='fa fa-download'></i>
                                [% Translate('Services Export') | html %]
                            </span>
                        </a>
                    </li>
                </ul>
            </div>
        </div>
[% RenderBlockEnd("ImportExportWidget") %]
# EO ServiceCatalog
    </div>

    <div class="ContentColumn">
# Rother OSS / Service Catalog
#        <div class="WidgetSimple">
[% RenderBlockStart("OverviewList") %]
        <div class="WidgetSimple">
# EO Service Catalog
            <div class="Header">
                <h2>[% Translate("List") | html %]</h2>
            </div>
            <div class="Content">

                <table class="DataTable" id="Services">
                    <thead>
                        <tr>
                            <th>[% Translate("Service") | html %]</th>
                            <th>[% Translate("Comment") | html %]</th>
                            <th>[% Translate("Validity") | html %]</th>
                            <th>[% Translate("Changed") | html %]</th>
                            <th>[% Translate("Created") | html %]</th>
                        </tr>
                    </thead>
                    <tbody>
[% RenderBlockStart("NoDataFoundMsg") %]
                        <tr>
                            <td colspan="5">
                                [% Translate("No data found.") | html %]
                            </td>
                        </tr>
[% RenderBlockEnd("NoDataFoundMsg") %]
[% RenderBlockStart("OverviewListRow") %]
                        <tr [% IF Data.ValidID != 1%]class="Invalid"[% END %]>
                            <td title="[% Data.Name | html %]">[% Data.LevelSpace | html %]<a class="AsBlock" href="[% Env("Baselink") %]Action=[% Env("Action") %];Subaction=ServiceEdit;ServiceID=[% Data.ServiceID | uri %]">[% Data.Name | truncate(80) | html %]</a></td>
                            <td title="[% Data.Comment | html %]">[% Data.Comment | truncate(20) | html %]</td>
                            <td>[% Translate(Data.Valid) | html %]</td>
                            <td>[% Data.ChangeTime | Localize("TimeShort") %]</td>
                            <td>[% Data.CreateTime | Localize("TimeShort") %]</td>
                        </tr>
[% RenderBlockEnd("OverviewListRow") %]
                        <tr class="FilterMessage Hidden">
                            <td colspan="5">[% Translate("No matches found.") | html %]</td>
                        </tr>
                    </tbody>
                </table>

            </div>
# Rother OSS / Service Catalog
        </div>
# EO ServiceCatalog
[% RenderBlockEnd("OverviewList") %]

[% RenderBlockStart("ServiceEdit") %]
# Rother OSS / ServiceCatalog
## instead of
##       <div class="WidgetSimple">
##           <div class="Content">
##               <form>
## we just set the form as the outer most element
## to include the languages as separate widget
#
#            <div class="Header">
#            [% IF Data.ServiceID == 'NEW' %]
#                <h2>[% Translate("Add Service") | html %]</h2>
#            [% ELSE %]
#                <h2>[% Translate("Edit Service") | html %]</h2>
#            [% END %]
#            </div>
#            <div class="Content">
#
#                <form action="[% Env("CGIHandle") %]" method="post" class="Validate PreventMultipleSubmits">
#                    <input type="hidden" name="Action" value="[% Env("Action") %]"/>
#                    <input type="hidden" name="Subaction" value="ServiceSave"/>
#                    <input type="hidden" name="ServiceID" value="[% Data.ServiceID | html %]"/>
#                    [% IF Data.ServiceID != 'NEW' %]
#                        <input type="hidden" name="ContinueAfterSave" id="ContinueAfterSave" value=""/>
#                    [% END %]
        <form action="[% Env("CGIHandle") %]" method="post" class="Validate PreventMultipleSubmits">
            <input type="hidden" name="FormID" value="[% Data.FormID | html %]"/>
            <input type="hidden" name="Action" value="[% Env("Action") %]"/>
            <input type="hidden" name="Subaction" value="ServiceSave"/>
            <input type="hidden" name="ServiceID" value="[% Data.ServiceID | html %]"/>
            [% IF Data.ServiceID != 'NEW' %]
                <input type="hidden" name="ContinueAfterSave" id="ContinueAfterSave" value=""/>
            [% END %]

            <div class="WidgetSimple">
                <div class="Header">
                [% IF Data.ServiceID == 'NEW' %]
                    <h2>[% Translate("Add Service") | html %]</h2>
                [% ELSE %]
                    <h2>[% Translate("Edit Service") | html %]</h2>
                [% END %]
                </div>
                <div class="Content">
# EO ServiceCatalog

                    <fieldset class="TableLike">

                        <label class="Mandatory" for="Name"><span class="Marker">*</span> [% Translate("Service") | html %]:</label>
                        <div class="Field">
                            <input type="text" name="Name" id="Name" value="[% Data.NameShort | html %]" class="W50pc Validate_Required [% Data.NameInvalid | html %]" maxlength="200"/>
                            <div id="NameError" class="TooltipErrorMessage" ><p>[% Translate("This field is required.") | html %]</p></div>
                            [% IF Data.LongName %]
                            <div id="NameServerError" class="TooltipErrorMessage" ><p>[% Translate("Service name maximum length is 200 characters (with Sub-service).") | html %]</p></div>
                            [% ELSE %]
                            <div id="NameServerError" class="TooltipErrorMessage" ><p>[% Translate("This field is required.") | html %]</p></div>
                            [% END %]
                        </div>
                        <div class="Clear"></div>

                        <label for="ParentID">[% Translate("Sub-service of") | html %]: </label>
                        <div class="Field">
                            [% Data.ParentOptionStrg %]
                        </div>
                        <div class="Clear"></div>
# Rother OSS / ServiceCatalog
## ---
## ITSMCore
## ---
#                        <label for="TypeID">[% Translate("Type") | html %]: </label>
#                        <div class="Field">
#                            [% Data.TypeOptionStrg %]
#                        </div>
#                        <div class="Clear"></div>
#
#                        <label for="Criticality">[% Translate("Criticality") | html %]: </label>
#                        <div class="Field">
#                            [% Data.CriticalityOptionStrg %]
#                        </div>
#                        <div class="Clear"></div>
## ---
                        <label for="TicketTypeIDs">[% Translate("Service depends on the following ticket types") | html %]: </label>
                        <div class="Field">
                            [% Data.TicketTypeOptionStrg %]
                        </div>
                        <div class="Clear"></div>

                        <label for="DestQueueID">[% Translate("Ticket destination queue") | html %]: </label>
                        <div class="Field">
                            [% Data.TicketQueueOptionStrg %]
                        </div>
                        <div class="Clear"></div>
                        <label for="CustomerDefaultService">[% Translate("Customer default service") | html %]: </label>
                        <div class="Field">
                            <input type="checkbox" name="CustomerDefaultService" title="[% Translate("Toggle active state for %s", Data.Name) | html %]" value="[% Data.ServiceID | html %]" [% Data.CustomerServiceChecked | html %]/>
                        </div>
                        <div class="Clear"></div>
                        <label for="Criticality">[% Translate("Criticality") | html %]: </label>
                        <div class="Field">
                            [% Data.CriticalityOptionStrg %]
                        </div>
                        <div class="Clear"></div>

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

[% RenderBlockStart("DynamicField") %]
                        <div class="Row Row_DynamicField_[% Data.Name | html %]">
                            [% Data.Label %]
                            <div class="Field">
                                [% Data.Field %]
                            </div>
                            <div class="Clear"></div>
                        </div>
[% RenderBlockEnd("DynamicField") %]
# EO ServiceCatalog

                        <label class="Mandatory" for="ValidID"><span class="Marker">*</span> [% Translate("Validity") | html %]:</label>
                        <div class="Field">
                            [% Data.ValidOptionStrg %]
                        </div>
                        <div class="Clear"></div>

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

[% RenderBlockStart("Item") %]
[% RenderBlockStart("InputKey") %]
                        <label for="[% Data.Name | html %]">[% Translate(Data.Label) | html %] [% Translate(Data.Key) | html %]: </label>
                        <div class="Field">
                            <input type="text" name="[% Data.Name | html %]" id="[% Data.Name | html %]" value="[% Data.SelectedID | html %]" class="W25pc"/>
                        </div>
                        <div class="Clear"></div>
[% RenderBlockEnd("InputKey") %]
[% RenderBlockStart("Input") %]
                        <label for="[% Data.Name | html %]">[% Translate(Data.Label) | html %]: </label>
                        <div class="Field">
                            <input type="text" name="[% Data.Name | html %]" id="[% Data.Name | html %]" value="[% Data.SelectedID | html %]" class="W25pc"/>
                            <p class="FieldExplanation">[% Translate(Data.Desc) | html %]</p>
                        </div>
                        <div class="Clear"></div>
[% RenderBlockEnd("Input") %]
[% RenderBlockStart("TextArea") %]
                        <label for="[% Data.Name | html %]">[% Translate(Data.Label) | html %]: </label>
                        <div class="Field">
                            <textarea name="[% Data.Name | html %]" id="[% Data.Name | html %]" rows="[% Data.Rows | html %]" cols="[% Data.Cols | html %]">[% Data.SelectedID | html %]</textarea>
                            <p class="FieldExplanation">[% Translate(Data.Desc) | html %]</p>
                        </div>
                        <div class="Clear"></div>
[% RenderBlockEnd("TextArea") %]
[% RenderBlockStart("Option") %]
                        <label for="[% Data.Name | html %]">[% Translate(Data.Label) | html %] [% Translate(Data.Key) | html %]:</label>
                        <div class="Field">
                            [% Data.Option %]
                            <p class="FieldExplanation">[% Translate(Data.Desc) | html %]</p>
                        </div>
                        <div class="Clear"></div>
[% RenderBlockEnd("Option") %]
[% RenderBlockStart("Upload") %]
                        <label for="[% Data.Name | html %]">[% Translate(Data.Label) | html %] [% Translate(Data.Key) | html %]</label>
                        <div class="Field">
                            <input name="[% Data.Name | html %]" id="[% Data.Name | html %]" type="file" size="30" class="fixed"/><br/>
                            <a href="">[% Data.Filename | html %]</a>
                        </div>
                        <div class="Clear"></div>
[% RenderBlockEnd("Upload") %]
[% RenderBlockStart("Password") %]
                        <label for="[% Data.Name | html %]">[% Translate(Data.Label) | html %] [% Translate(Data.Key) | html %]: </label>
                        <div class="Field">
                            <input type="password" class="W25pc" name="[% Data.Name | html %]" id="[% Data.Name | html %]" value="" />
                        </div>
                        <div class="Clear"></div>
[% RenderBlockEnd("Password") %]
[% RenderBlockEnd("Item") %]

# Rother OSS / ServiceCatalog
                    </fieldset>
                </div>
            </div>
            <div class="WidgetSimple">
                <div class="Header">
                    <div class="WidgetAction Toggle">
                        <a href="#" title="[% Translate("Toggle this widget") | html %]"><i class="fa fa-caret-right"></i><i class="fa fa-caret-down"></i></a>
                    </div>
                    <h2>[% Translate("Service Description") | html %]</h2>
                </div>
                <div class="Content">
                    <div class ="ServiceLanguageContainer">
[% RenderBlockStart("ServiceLanguage") %]
                        <div class="ServiceLanguage">
                            <div class="WidgetSimple SpacingTop [% IF !Data.Language %] Collapsed [% END %] ">
                                <div class="Header">
                                    <div class="WidgetAction Toggle">
                                        <a href="#" title="[% Translate("Toggle this widget") | html %]"><i class="fa fa-caret-right"></i><i class="fa fa-caret-down"></i></a>
                                    </div>
                                    <h2 class="Title">
                                        [% IF Data.Language %]
                                          [% Translate(Data.Language) | html %]
                                        [% ELSE %]
                                           <span class="Warning">'[% Data.LanguageID | html %]' &mdash; [% Translate("This language is not present or enabled on the system. This service description could be deleted if it is not needed anymore.") | html %]</span>
                                        [% END %]
                                    </h2>
[% RenderBlockStart("ServiceLanguageRemoveButton") %]
                                    <div class="AdditionalInformation">
                                        <a value="Remove Language" class="RemoveButton LanguageRemove" id="[% Data.LanguageID | html %]_Language_Remove" href="" name="Data.LanguageID_Language_Remove"><i class="fa fa-minus-square-o"></i><span class="InvisibleText">[% Translate("Remove Service Description Language") | html %]</span></a>
                                    </div>
[% RenderBlockEnd("ServiceLanguageRemoveButton") %]
                                </div>
                                <div class="Content">
                                    <fieldset class="TableLike">
                                        <input type="hidden" name="LanguageID" class="LanguageID" value="[% Data.LanguageID | html %]"/>
                                        <label for="[% Data.LanguageID | html %]_DescriptionShort" id="[% Data.LanguageID | html %]_Label_DescriptionShort" class="Mandatory">
                                            <span class="Marker">*</span>
                                            [% Translate("Description (short)") | html %]:
                                        </label>
                                        <div class="Field">
                                            <input type="text" name="[% Data.LanguageID | html %]_DescriptionShort" id="[% Data.LanguageID | html %]_DescriptionShort" value="[% Data.DescriptionShort | html %]" class="W75pc Validate_Required [% Data.DescriptionShortServerError | html %]" maxlength="200"/>
                                            <div id="[% Data.LanguageID | html %]_DescriptionShortError" class="TooltipErrorMessage">
                                                <p>[% Translate("This field is required.") | html %]</p>
                                            </div>
                                            <div id="[% Data.LanguageID | html %]_DescriptionShortServerError" class="TooltipErrorMessage">
                                                <p>[% Translate("This field is required.") | html %]</p>
                                            </div>
                                        </div>
                                        <div class="Clear"></div>
                                        <label for="[% Data.LanguageID | html %]_DescriptionLong" id="[% Data.LanguageID | html %]_Label_DescriptionLong">
                                            [% Translate("Description (long)") | html %]:
                                        </label>
                                        <div class="RichTextField">
                                            <textarea name="[% Data.LanguageID | html %]_DescriptionLong" id="[% Data.LanguageID | html %]_DescriptionLong" class="RichText" title="[% Translate("Description (long)") | html %]" rows="10" cols="[% Config("Ticket::Frontend::TextAreaNote") | html %]">[% Data.DescriptionLong | html %]</textarea>
                                        </div>
                                        <div class="Clear"></div>
                                    </fieldset>
                                </div>
                            </div>
                        </div>
[% RenderBlockEnd("ServiceLanguage") %]
                        <div class="Hidden Template ServiceLanguage">
                            <div class="WidgetSimple SpacingTop">
                                <div class="Header">
                                    <div class="WidgetAction Toggle">
                                        <a href="#" title="[% Translate("Toggle this widget") | html %]"><i class="fa fa-caret-right"></i><i class="fa fa-caret-down"></i></a>
                                    </div>
                                    <h2 class="Title"></h2>
                                    <div class="AdditionalInformation">
                                        <a value="Remove Language" class="RemoveButton LanguageRemove" id="Template_Language_Remove" href="" name="Template_Language_Remove"><i class="fa fa-minus-square-o"></i><span class="InvisibleText">[% Translate("Remove Service Description Language") | html %]</span></a>
                                    </div>
                                </div>
                                <div class="Content">
                                    <fieldset class="TableLike">
                                        <input type="hidden" name="" class="LanguageID" value=""/>
                                        <label for="Template_DescriptionShort" id="Template_Label_DescriptionShort" class="Mandatory">
                                            <span class="Marker">*</span>
                                            [% Translate("Description (short)") | html %]:
                                        </label>
                                        <div class="Field">
                                            <input type="text" name="Template_DescriptionShort" id="Template_DescriptionShort" value="" class="W75pc" maxlength="200"/>
                                            <div id="Template_DescriptionShortError" class="TooltipErrorMessage">
                                                <p>[% Translate("This field is required.") | html %]</p>
                                            </div>
                                        </div>
                                        <div class="Clear"></div>

                                        <label for="Template_DescriptionLong" id="Template_Label_DescriptionLong">
                                            [% Translate("Description (long)") | html %]:
                                        </label>
                                        <div class="RichTextField">
                                            <textarea id="Template_DescriptionLong" class="" name="Template_DescriptionLong" title="[% Translate("Description (long)") | html %]" rows="15" cols="[% Config("Ticket::Frontend::TextAreaNote") | html %]"></textarea>
                                            <div id="Template_DescriptionLongError" class="TooltipErrorMessage">
                                                <p>[% Translate("This field is required.") | html %]</p>
                                            </div>
                                        </div>
                                        <div class="Clear"></div>
                                    </fieldset>
                                </div>
                            </div>
                        </div>
                    </div>
[% RenderBlockStart("LanguageOptions") %]
                    <fieldset class="TableLike">
                        <label for="Language">[% Translate("Add new service description language") | html %]:</label>
                        <div class="Field">
                            [% Data.LanguageStrg %]
                        </div>
                        <div class="Clear"></div>
                    </fieldset>
                    <div class="Hidden">
                        [% Data.LanguageOrigStrg %]
                    </div>
[% RenderBlockEnd("LanguageOptions") %]
                </div>
            </div>
            <div class="WidgetSimple">
                <div class="Header">
                    <h2>[% Translate("Save Changes") | html %]</h2>
                </div>
                <div class="Content">
                    <fieldset class="TableLike">
# EO ServiceCatalog
                        <div class="Field SpacingTop">
                            [% IF Data.ServiceID != 'NEW' %]
                                <button class="CallForAction Primary" id="SubmitAndContinue" type="button" value="[% Translate("Save") | html %]"><span>[% Translate("Save") | html %]</span></button>
                                [% Translate("or") | html %]
                                <button class="CallForAction Primary" id="Submit" type="submit" value="[% Translate("Save") | html %]"><span>[% Translate("Save and finish") | html %]</span></button>
                            [% ELSE %]
                                <button class="CallForAction Primary" id="Submit" type="submit" value="[% Translate("Save") | html %]"><span>[% Translate("Save") | html %]</span></button>
                            [% END %]
                            [% Translate("or") | html %]
                            <a href="[% Env("Baselink") %]Action=[% Env("Action") %]">[% Translate("Cancel") | html %]</a>
                        </div>
                        <div class="Clear"></div>
                    </fieldset>
# Rother OSS / ServiceCatalog
#                </form>
#            </div>
                </div>
            </form>
        </div>
# EO ServiceCatalog
[% RenderBlockEnd("ServiceEdit") %]
# Rother OSS / ServiceCatalog
#        </div>
# EO ServiceCatalog

# Rother OSS / ServiceCatalog
[% RenderBlockStart("ServiceReference") %]
        <div class="WidgetSimple SpacingTop Collapsed">
            <div class="Header">
                <div class="WidgetAction Toggle">
                    <a href="#" title="[% Translate("Toggle this widget") | html %]"><i class="fa fa-caret-right"></i><i class="fa fa-caret-down"></i></a>
                </div>
                <h2>[% Translate("Option Reference") | html %]</h2>
            </div>
            <div class="Content">

                <p>[% Translate("You can use the following options") | html %]:</p>
                <dl>
                    <dt>[% Translate("Service depends on the following ticket types") | html %]:</dt>
                    <dd>
                        [% Translate('Within the ServiceCatalogue tile in the customer dashboard, it is possible to show ticket types for preconfigured ticket creation inside the service description. Furthermore, it is possible to restrict the services for other screens using the ticket types set here. If you wish to do this, please activate the options "ServiceCatalog::CreateTypeServiceRelatedAcls" and "ServiceCatalog::CreateTypeServiceRelatedAcls::Options" in the OTOBO system configuration. The restriction is made via automatically generated ACLs, which can be viewed under "Admin -> Access Control Lists (ACL)". If necessary, please adjust the option "ServiceCatalog::CreateTypeServiceRelatedAcls::Options" according to your requirements.') | html %]
                    </dd>

                    <dt>[% Translate("Ticket destination queue") | html %]:</dt>
                    <dd>
                        [% Translate('If we work service-based, we do not want to offer the customer a choice of queues in the customer portal when creating a ticket, but decide on the basis of the service into which queue (or which team of agents) the ticket should be processed first. In order to use this option sensibly, please deactivate the option "Ticket::Frontend::CustomerTicketMessage###Queue" and set a sensible default queue in the option "Ticket::Frontend::CustomerTicketMessage###QueueDefault". As soon as you set a "Ticket destination queue" here in the service, the ticket will immediately be created in this queue. If the field remains empty, the default queue configured above will be used.') | html %]
                    </dd>

                    <dt>[% Translate("Customer default service") | html %]:</dt>
                    <dd>
                        [% Translate("If you do not assign services to customers or companies individually, but all services are initially offered to your customers for selection, the step of releasing each service as a \"default\" service under \"Admin -> Customer user <-> Service\" (or \"Customer <-> Service\") can be bypassed here. Of course, in the next step it is possible to restrict the services via ACLs.") | html %]
                    </dd>

                    <dt>[% Translate("Criticality") | html %]:</dt>
                    <dd>
                        [% Translate("Here, there is the possibility to automatically calculate the correct ticket priority in the background based on the dynamic field \"ITSMCriticality\" and \"ITSMImpact\". Please activate the option \"Ticket::EventModulePost###9700-SetDynamicFieldCriticalityFromService\" and the option \"Ticket::EventModulePost###9800-SetPriorityFromCriticalityAndImpactMatrix\". In the next step, you have the possibility using \"Admin -> Criticality ↔ Impact ↔ Priority\" to set the priority using a matrix.") | html %]
                    </dd>

                    <dt>[% Translate("Keywords") | html %]:</dt>
                    <dd>
                        [% Translate("Keywords to facilitate the search for services within the service catalog.") | html %]
                    </dd>

                    <dt>[% Translate("Service Description") | html %]:</dt>
                    <dd>
                        [% Translate("Service descriptions (short & long) specified by User Language.") | html %]
                    </dd>

                    <dt>[% Translate("Description (short)") | html %]:</dt>
                    <dd>
                        [% Translate("Short summary of the service, mainly used in the CustomerDashboard.") | html %]
                    </dd>

                    <dt>[% Translate("Description (long)") | html %]:</dt>
                    <dd>
                        [% Translate("Description of the service. Screenshots and tables are also allowed. Please ensure the correct width of the image for screenshots. This can be adjusted in the ckeditor after uploading the screenshot. A width of 600px has proven to be useful or you can configure a \"max-width\" of 95% under Advanced.") | html %]
                    </dd>

                    <dt>[% Translate("Add more service catalog fields") | html %]:</dt>
                    <dd>
                        [% Translate("You have the option of adding further fields here in the service catalog at any time. To do this, please go to \"Admin -> DynamicFields\" and create the new field of the object type \"Service\". You can then activate the field for the customer dashboard under \"Admin -> DynamicField Screens\" by assigning it under \"CustomerDashboardTile ServiceCatalog\".") | html %]
                    </dd>

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

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

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

    [% IF Data.SLAID %]
        [% USE EditTitle = String(Translate("Edit SLA")) %]
        [% BreadcrumbPath.push({ Name => EditTitle.append( ': ', Data.SLAName ) }) %]
    [% ELSIF Data.Subaction == "SLAEdit"  %]
        [% BreadcrumbPath.push({ Name => Translate("Add SLA"),}) %]
    [% END %]

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

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

[% RenderBlockStart("IncludeInvalid") %]
        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("Filter by valid state") | html %]</h2>
            </div>
            <div class="Content">
                <input type="checkbox" id="IncludeInvalid" name="IncludeInvalid" value="1" title="[% Translate("Include invalid SLAs") | html %]" [% Data.IncludeInvalidChecked | html %]/>
                <label for="IncludeInvalid">[% Translate("Include invalid SLAs") | html %]</label>
            </div>
        </div>
[% RenderBlockEnd("IncludeInvalid") %]
[% RenderBlockStart("ActionList") %]
        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("Actions") | html %]</h2>
            </div>
            <div class="Content">
                <ul class="ActionList">

[% RenderBlockStart("ActionOverview") %]
                    <li>
                        <a href="[% Env("Baselink") %]Action=[% Env("Action") %]" class="CallForAction Fullsize Center"><span><i class="fa fa-caret-left"></i>[% Translate("Go to overview") | html %]</span></a>
                    </li>
[% RenderBlockEnd("ActionOverview") %]

[% RenderBlockStart("ActionAdd") %]
                    <li>
                        <a class="CallForAction Fullsize Center" href="[% Env("Baselink") %]Action=[% Env("Action") %];Subaction=SLAEdit">
                            <span><i class="fa fa-plus-square"></i>[% Translate("Add SLA") | html %]</span>
                        </a>
                    </li>
[% RenderBlockEnd("ActionAdd") %]

                </ul>
            </div>
        </div>
[% RenderBlockEnd("ActionList") %]
[% RenderBlockStart("Filter") %]
        <div class="WidgetSimple">
            <div class="Header">
                <h2><label for="FilterSLAs">[% Translate("Filter for SLAs") | html %]</label></h2>
            </div>
            <div class="Content">
                <input type="text" id="FilterSLAs" class="FilterBox" placeholder="[% Translate("Just start typing to filter...") | html %]" name="FilterSLAs" value="" title="[% Translate("Filter for SLAs") | html %]">
            </div>
        </div>
[% RenderBlockEnd("Filter") %]
# Rother OSS / ServiceCatalog
[% RenderBlockStart("ImportExportWidget") %]
        <div class='WidgetSimple' id='SLAImportExportWidget'>
            <div class='Header'>
                <h1 class="InvisibleText">
                    [% Translate("Import / Export") | html %]
                </h1>
            </div>

            [% BreadcrumbPath = [
                    {
                        Name => Translate('Import / Export'),
                    },
                ]
            %]

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

            <div class='Content'>
                <p class='FieldExplanation'>
                    [% Translate('Here you can upload a configuration file to import SLAs to your system. The file needs to be in .yml format as exported by SLA management module.') | html %]
                </p>
                <ul class='ActionList SpacingTop'>
                    <li>
                        <form action='[% Env("CGIHandle") %]' method='post' enctype='multipart/form-data' class='Validate PreventMultipleSubmits'>
                            <input type='hidden' name='ChallengeToken' value=[% Env("UserChallengeToken") | JSON %]>
                            <input type='hidden' name='Action' value='AdminSLAImportExport'/>
                            <input type='hidden' name='Subaction' value='Import'/>
                            <input name='FileUpload' id='FileUpload' type='file' size='18' class='Fixed W100pc Validate_Required [% Data.FileUploadInvalid | html %]'/>
                            <div id='FileUploadError' class='TooltipErrorMessage'>
                                <p>
                                    [% Translate('This field is required.') | html %]
                                </p>
                            </div>
                            <div id='FileUploadServerError' class='TooltipErrorMessage'>
                                <p>
                                    % Translate('This field is required.') | html %]
                                </p>
                            </div>
                            <fieldset class='SpacingTop'>
                                <input type='checkbox' id='OverwriteExistingEntitiesExample' name='OverwriteExistingEntities' value='1'/>
                                <label for='OverwriteExistingEntitiesExample'>
                                    [% Translate('Overwrite existing entities') | html %]
                                </label>
                            </fieldset>
                            <button class='CallForAction Fullsize Center SpacingTop' id='SLAImport' type='submit'>
                                <span><i class='fa fa-upload'></i>
                                    [% Translate('SLAs Import') | html %]
                                </span>
                            </button>
                        </form>
                    </li>
                    <li>
                        <a href='[% Env("Baselink") %]Action=AdminSLAImportExport;Subaction=Export' id='SLAExport' class='CallForAction Fullsize Center'>
                            <span><i class='fa fa-download'></i>
                                [% Translate('SLAs Export') | html %]
                            </span>
                        </a>
                    </li>
                </ul>
            </div>
        </div>
[% RenderBlockEnd("ImportExportWidget") %]
# EO SLACatalog
    </div>

    <div class="ContentColumn">
        <div class="WidgetSimple">
[% RenderBlockStart("OverviewList") %]
            <div class="Header">
                <h2>[% Translate("List") | html %]</h2>
            </div>
            <div class="Content">

                <table class="DataTable" id="SLAs">
                    <thead>
                        <tr>
                            <th>[% Translate("SLA") | html %]</th>
                            <th>[% Translate("Service") | html %]</th>
                            <th>[% Translate("Comment") | html %]</th>
                            <th>[% Translate("Validity") | html %]</th>
                            <th>[% Translate("Changed") | html %]</th>
                            <th>[% Translate("Created") | html %]</th>
                        </tr>
                    </thead>
                    <tbody>
[% RenderBlockStart("NoDataFoundMsg") %]
                        <tr>
                            <td colspan="6">
                                [% Translate("No data found.") | html %]
                            </td>
                        </tr>
[% RenderBlockEnd("NoDataFoundMsg") %]
[% RenderBlockStart("OverviewListRow") %]
                        <tr [% IF Data.ValidID && Data.ValidID != 1 %]class="Invalid"[% END %]>
                            <td><a class="AsBlock" href="[% Env("Baselink") %]Action=[% Env("Action") %];Subaction=SLAEdit;SLAID=[% Data.SLAID | uri %]">[% Data.Name | html %]</a></td>
                            <td>[% Data.Service | html %]</td>
                            <td title="[% Data.Comment | html %]">[% Data.Comment | truncate(26) | html %]</td>
                            <td>[% Translate(Data.Valid) | html %]</td>
                            <td>[% Data.ChangeTime | Localize("TimeShort") %]</td>
                            <td>[% Data.CreateTime | Localize("TimeShort") %]</td>
                        </tr>
[% RenderBlockEnd("OverviewListRow") %]
                        <tr class="FilterMessage Hidden">
                            <td colspan="6">[% Translate("No matches found.") | html %]</td>
                        </tr>
                    </tbody>
                </table>
            </div>
[% RenderBlockEnd("OverviewList") %]

[% RenderBlockStart("SLAEdit") %]
            <div class="Header">
            [% IF !Data.SLAID %]
                <h2>[% Translate("Add SLA") | html %]</h2>
            [% ELSE %]
                <h2>[% Translate("Edit SLA") | html %]</h2>
            [% END %]
            </div>
            <div class="Content">

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

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

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

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

                        <label for="FirstResponseTime">[% Translate("Escalation - first response time") | html %] ([% Translate("minutes") | html %]):</label>
                        <div class="Field">
                            <input type="text" name="FirstResponseTime" id="FirstResponseTime" value="[% Data.FirstResponseTime | html %]" class="W50px Validate_Number" maxlength="10"/>
                            <div id="FirstResponseTimeError" class="TooltipErrorMessage"><p>[% Translate("Please write only numbers!") | html %]</p></div>
                            (<label for="FirstResponseNotify">[% Translate("Notify by") | html %]</label> [% Data.FirstResponseNotifyOptionStrg %])
                            <p class="FieldExplanation">
                                [% Translate("0 = no escalation") | html %] - 24 [% Translate("hours") | html %] = 1440 [% Translate("minutes") | html %] - [% Translate("Only business hours are counted.") | html %]
                            </p>
                        </div>
                        <div class="Clear"></div>

                        <label for="UpdateTime">[% Translate("Escalation - update time") | html %] ([% Translate("minutes") | html %]):</label>
                        <div class="Field">
                            <input type="text" name="UpdateTime" id="UpdateTime" value="[% Data.UpdateTime | html %]" class="W50px Validate_Number" maxlength="10"/>
                            <div id="UpdateTimeError" class="TooltipErrorMessage"><p>[% Translate("Please write only numbers!") | html %]</p></div>
                            (<label for="UpdateNotify">[% Translate("Notify by") | html %]</label> [% Data.UpdateNotifyOptionStrg %])
                            <p class="FieldExplanation">
                                [% Translate("0 = no escalation") | html %] - 24 [% Translate("hours") | html %] = 1440 [% Translate("minutes") | html %] - [% Translate("Only business hours are counted.") | html %]
                            </p>
                        </div>
                        <div class="Clear"></div>

                        <label for="SolutionTime">[% Translate("Escalation - solution time") | html %] ([% Translate("minutes") | html %]):</label>
                        <div class="Field">
                            <input type="text" name="SolutionTime" id="SolutionTime" value="[% Data.SolutionTime | html %]" class="W50px Validate_Number" maxlength="10"/>
                            <div id="SolutionTimeError" class="TooltipErrorMessage"><p>[% Translate("Please write only numbers!") | html %]</p></div>
                            (<label for="SolutionNotify">[% Translate("Notify by") | html %]</label> [% Data.SolutionNotifyOptionStrg %])
                            <p class="FieldExplanation">
                                [% Translate("0 = no escalation") | html %] - 24 [% Translate("hours") | html %] = 1440 [% Translate("minutes") | html %] - [% Translate("Only business hours are counted.") | html %]
                            </p>
                        </div>
                        <div class="Clear"></div>
# ---
# ITSMCore
# ---
                        <label for="MinTimeBetweenIncidents">[% Translate("Minimum Time Between Incidents") | html %] ([% Translate("minutes") | html %]):</label>
                        <div class="Field">
                            <input type="text" name="MinTimeBetweenIncidents" id="MinTimeBetweenIncidents" value="[% Data.MinTimeBetweenIncidents | html %]" class="W25pc Validate_Number" maxlength="15"/>
                            <div id="MinTimeBetweenIncidentsError" class="TooltipErrorMessage"><p>[% Translate("Please write only numbers!") | html %]</p></div>
                        </div>
                        <div class="Clear"></div>
# ---

                        <label class="Mandatory" for="ValidID"><span class="Marker">*</span> [% Translate("Validity") | html %]:</label>
                        <div class="Field">
                            [% Data.ValidOptionStrg %]
                        </div>
                        <div class="Clear"></div>

                        <label for="Comment">[% Translate("Comment") | html %]:</label>
                        <div class="Field">
                            <input type="text" name="Comment" id="Comment" value="[% Data.Comment | html %]" class="W50pc" maxlength="250"/>
                        </div>
                        <div class="Clear"></div>
[% RenderBlockStart("SLAItem") %]
[% RenderBlockStart("InputKey") %]
                        <label for="[% Data.Name | html %]">[% Translate(Data.Label) | html %] [% Translate(Data.Key) | html %]:</label>
                        <div class="Field">
                            <input type="text" name="[% Data.Name | html %]" id="[% Data.Name | html %]" value="[% Data.SelectedID | html %]" class="W50pc"/>
                        </div>
                        <div class="Clear"></div>
[% RenderBlockEnd("InputKey") %]
[% RenderBlockStart("Input") %]
                        <label for="[% Data.Name | html %]">[% Translate(Data.Label) | html %]:</label>
                        <div class="Field">
                            <input type="text" name="[% Data.Name | html %]" id="[% Data.Name | html %]" value="[% Data.SelectedID | html %]" class="W50pc"/>
                            <p class="FieldExplanation">
                                [% Translate(Data.Desc) | html %]
                            </p>
                        </div>
                        <div class="Clear"></div>
[% RenderBlockEnd("Input") %]
[% RenderBlockStart("TextArea") %]
                        <label for="[% Data.Name | html %]">[% Translate(Data.Label) | html %]:</label>
                        <div class="Field">
                            <textarea name="[% Data.Name | html %]" id="[% Data.Name | html %]" rows="[% Data.Rows | html %]" cols="[% Data.Cols | html %]">[% Data.SelectedID | html %]</textarea>
                            <p class="FieldExplanation">
                                [% Translate(Data.Desc) | html %]
                            </p>
                        </div>
                        <div class="Clear"></div>

[% RenderBlockEnd("TextArea") %]
[% RenderBlockStart("Option") %]
                        <label for="[% Data.Name | html %]">[% Translate(Data.Label) | html %] [% Translate(Data.Key) | html %]:</label>
                        <div class="Field">
                            [% Data.Option %]
                            <p class="FieldExplanation">
                                [% Translate(Data.Desc) | html %]
                            </p>
                        </div>
                        <div class="Clear"></div>
[% RenderBlockEnd("Option") %]
[% RenderBlockStart("Upload") %]
                        <label for="[% Data.Name | html %]">[% Translate(Data.Label) | html %] [% Translate(Data.Key) | html %]:</label>
                        <div class="Field">
                            <input name="[% Data.Name | html %]" id="[% Data.Name | html %]" type="file" class="fixed"/>
                            <a href="">[% Data.Filename | html %]</a>
                        </div>
                        <div class="Clear"></div>
[% RenderBlockEnd("Upload") %]
[% RenderBlockStart("Password") %]
                        <label for="[% Data.Name | html %]">[% Translate(Data.Label) | html %] [% Translate(Data.Key) | html %]:</label>
                        <div class="Field">
                            <input type="password" name="[% Data.Name | html %]" id="[% Data.Name | html %]" value="" class="W50pc"/>
                        </div>
                        <div class="Clear"></div>
[% RenderBlockEnd("Password") %]
[% RenderBlockEnd("SLAItem") %]
                        <div class="Field SpacingTop">
                            [% IF Data.SLAID %]
                                <button class="CallForAction Primary" id="SubmitAndContinue" type="button" value="[% Translate("Save") | html %]"><span>[% Translate("Save") | html %]</span></button>
                                [% Translate("or") | html %]
                                <button class="CallForAction Primary" id="Submit" type="submit" value="[% Translate("Save") | html %]"><span>[% Translate("Save and finish") | html %]</span></button>
                            [% ELSE %]
                                <button class="CallForAction Primary" id="Submit" type="submit" value="[% Translate("Save") | html %]"><span>[% Translate("Save") | html %]</span></button>
                            [% END %]
                            [% Translate("or") | html %]
                            <a href="[% Env("Baselink") %]Action=[% Env("Action") %]">[% Translate("Cancel") | html %]</a>
                        </div>
                        <div class="Clear"></div>
                    </fieldset>
                </form>
            </div>
[% RenderBlockEnd("SLAEdit") %]
        </div>
    </div>
    <div class="Clear"></div>
</div>
[% RenderBlockEnd("Overview") %]
 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 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# $origin: otobo -  - Kernel/Output/HTML/Templates/Standard/AgentITSMServiceZoom.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/>.
# --

<div class="MainBox ARIARoleMain">
    <div class="ClearLeft"></div>
    <div class="Headline">
        <div class="Flag" title="[% Translate(Data.CurInciState) | html %]">
            <span class="[% Data.CurInciSignal | html %]"></span>
        </div>
        <h1 title="[% Translate("Service") | html %]: [% Data.Name | html %]">
            [% Translate("Service") | html %]: [% Data.Name | html %]
        </h1>
    </div>
    <div class="LayoutFixedSidebar SidebarLast">
        <div class="SidebarColumn">
            <div class="WidgetSimple">
                <div class="Header">
                    <div class="WidgetAction Toggle">
                        <a href="#" title="[% Translate("Show or hide the content") | html %]"><i class="fa fa-caret-right"></i><i class="fa fa-caret-down"></i></a>
                    </div>
                    <h2>[% Translate("Service Information") | html %]</h2>
                </div>
                <div class="Content">
                    <fieldset class="TableLike FixedLabelSmall Tight">

                        <label>[% Translate("Current incident state") | html %]:</label>
                        <div class="Value">
                            <div class="Flag Small">
                                <span class="[% Data.CurInciSignal | html %]"></span>
                            </div>
                            [% Translate(Data.CurInciState) | html %]
                        </div>
                        <div class="Clear"></div>

                        <label>[% Translate("Created") | html %]:</label>
                        <p class="Value">[% Data.CreateTime | Localize("TimeLong") %]</p>
                        <div class="Clear"></div>

                        <label>[% Translate("Created by") | html %]:</label>
                        <p class="Value">
                            [% Data.CreateByName | html %]
                        </p>
                        <div class="Clear"></div>

                        <label>[% Translate("Last changed") | html %]:</label>
                        <p class="Value">
                            [% Data.ChangeTime | Localize("TimeLong") %]
                        </p>
                        <div class="Clear"></div>

                        <label>[% Translate("Last changed by") | html %]:</label>
                        <p class="Value">
                            [% Data.ChangeByName | html %]
                        </p>
                        <div class="Clear"></div>
                    </fieldset>
                </div>
            </div>

[% RenderBlockStart("LinkTableSimple") %]
            <div class="WidgetSimple DontPrint">
                <div class="Header">
                    <h2>[% Translate("Linked Objects") | html %]</h2>
                </div>
                <div class="Content">
                    [% Data.LinkTableStrg %]
                </div>
            </div>
[% RenderBlockEnd("LinkTableSimple") %]
        </div>

        <div class="ContentColumn">
            <div class="ControlRow">
            </div>
            <div class="ActionRow">
                <ul class="Actions">
[% RenderBlockStart("MenuItem") %]
                    <li>
                        <a href="[% Env("Baselink") %][% Data.Link | Interpolate %]" class="[% Data.MenuClass | html %]" title="[% Translate(Data.Description) | html %]">[% Translate(Data.Name) | html %]</a>
                    </li>
[% RenderBlockEnd("MenuItem") %]
                </ul>
                <div class="Clear"></div>
            </div>

            <div class="WidgetBox SpacingTop Expanded">
                <div class="LightRow Header">
                    <div class="WidgetAction Toggle"><a href="#" title="[% Translate("Show or hide the content.") | html %]"><i class="fa fa-caret-right"></i><i class="fa fa-caret-down"></i></a></div>
                    <h2>[% Translate("Service") | html %]: [% Data.Name | html %]</h2>
                </div>
                <div class="Content AutoHeight">
                    <fieldset class="TableLike FixedLabelSmall">
                        <label title="[% Translate("Type") | html %]">[% Translate("Type") | html %]: </label>
                        <div class="Field">
                            [% Translate(Data.Type) | html %]
                        </div>
                        <div class="Clear"></div>

                        <label>[% Translate("Criticality") | html %]: </label>
                        <div class="Field">
                            [% Translate(Data.Criticality) | html %]
                        </div>
                        <div class="Clear"></div>
# ---
# Rother OSS / ServiceCatalog
# ---
                        <label title="[% Translate("Description (short)") | html %]">[% Translate("Description (short)") | html %]: </label>
                        <div class="Field">
                            [% Translate(Data.DescriptionShort) | html %]
                        </div>
                        <div class="Clear"></div>

                        <label title="[% Translate("Description (long)") | html %]">[% Translate("Description (long)") | html %]: </label>
                        <div class="Field">
                            <iframe sandbox="allow-same-origin allow-popups ms-allow-popups allow-popups-to-escape-sandbox" width="100%" frameborder="0" id="ServiceID[% Data.ServiceID | html %]" onload="Core.Agent.ITSMServiceZoom.ResizeIframe(this);" src="[% Env("Baselink") %]Action=AgentITSMServiceZoom;Subaction=HTMLView;ServiceID=[% Data.ServiceID | html %][% IF !Config("SessionUseCookie") %][% Env("SessionName") | html %]=[% Env("SessionID") | html %][% END %]"></iframe>
                        </div>
                        <div class="Clear"></div>

# ToDo: Move this to a custom CSS when porting into the core.
<style>
    .MainBox .ContentColumn .Content > fieldset.TableLike.FixedLabelSmall > label {
        width: 140px !important;
    }

    .ContentColumn > .WidgetBox > .Content > fieldset.TableLike.FixedLabelSmall > .Field,
    .ContentColumn > .WidgetBox > .Content > fieldset.TableLike.FixedLabelSmall > .Row > .Field,
    .ContentColumn > .WidgetBox > .Content > fieldset.TableLike.FixedLabelSmall > .Value,
    .ContentColumn > .WidgetBox > .Content > fieldset.TableLike.FixedLabelSmall > .Row > .Value {
        margin-left: 140px !important;
    }
</style>

[% RenderBlockStart("ServiceDynamicField") %]
[% IF Data.TitleField %]
                        <p title="[% Data.Text | html %]" style="[% Data.Style | html %]">[% Data.Text | html %]</p>
[% ELSE %]
                        <label>[% Translate(Data.Label) | html %]:</label>
                        <p class="Value">
[% RenderBlockStart("ServiceDynamicFieldLink") %]
                            <span title="[% Data.Title %]"><a href="[% Data.Link | Interpolate %]"[% IF Data.LinkPreview %] data-trigger="floater" data-floater-url="[% Data.LinkPreview | Interpolate %]"[% END %] target="_blank" class="DynamicFieldLink">[% Data.Value %]</a></span>
[% RenderBlockEnd("ServiceDynamicFieldLink") %]
[% RenderBlockStart("ServiceDynamicFieldPlain") %]
                            <span title="[% Data.Title %]">[% Data.Value %]</span>
[% RenderBlockEnd("ServiceDynamicFieldPlain") %]
                        </p>
                        <div class="Clear"></div>
[% END %]
[% RenderBlockEnd("ServiceDynamicField") %]

# EOC ServiceCatalog
                        <label title="[% Translate("Comment") | html %]">[% Translate("Comment") | html %]: </label>
                        <div class="Field">
                            [% Translate(Data.Comment) | html %]
                        </div>
                        <div class="Clear"></div>

                    </fieldset>
                </div>
            </div>

[% RenderBlockStart("SLA") %]
            <div class="WidgetSimple DontPrint SpacingTop  SpacingBottomMedium">
                <div class="Header">
                    <div class="WidgetAction Toggle">
                        <a href="#" title="[% Translate("Show or hide the content") | html %]"><i class="fa fa-caret-right"></i><i class="fa fa-caret-down"></i></a>
                    </div>
                    <h2>[% Translate("Associated SLAs") | html %]</h2>
                </div>
                <div class="Content">
                    <table class="DataTable">
                        <thead>
                            <tr>
                                <th>[% Translate("SLA") | html %]</th>
                                <th>[% Translate("Comment") | html %]</th>
                                <th>[% Translate("Type") | html %]</th>
                                <th>[% Translate("Changed") | html %]</th>
                            </tr>
                        </thead>
                        <tbody>
[% RenderBlockStart("SLARow") %]
                            <tr>
                                <td>
                                    <a class="AsBlock" href="[% Env("Baselink") %]Action=AgentITSMSLAZoom;SLAID=[% Data.SLAID | uri %]">
                                        [% Data.Name | html %]
                                    </a>
                                </td>
                                <td title="[% Data.Comment | html %]">[% Data.Comment | truncate(100) | html %]</td>
                                <td>[% Translate(Data.Type) | html %]</td>
                                <td>[% Data.ChangeTime | Localize("TimeLong") %]</td>
                            </tr>
[% RenderBlockEnd("SLARow") %]
                        </tbody>
                    </table>
                </div>
            </div>
[% RenderBlockEnd("SLA") %]

[% RenderBlockStart("LinkTableComplex") %]
            <div class="Content">
                [% Data.LinkTableStrg %]
            </div>
[% RenderBlockEnd("LinkTableComplex") %]

        </div>
        <div class="Clear"></div>
    </div>
</div>
 # --
# 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 -  - Kernel/Output/HTML/Templates/Standard/AgentITSMSLAZoom.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/>.
# --

<div class="MainBox ARIARoleMain">
    <div class="ClearLeft"></div>
    <div class="Headline">
        <h1>[% Translate("SLA") | html %]: [% Data.Name | html %]</h1>
    </div>

    <div class="LayoutFixedSidebar SidebarLast">
        <div class="SidebarColumn">
            <div class="WidgetSimple">
                <div class="Header">
                    <div class="WidgetAction Toggle">
                        <a href="#" title="[% Translate("Show or hide the content") | html %]"><i class="fa fa-caret-right"></i><i class="fa fa-caret-down"></i></a>
                    </div>
                    <h2>[% Translate("SLA Information") | html %]</h2>
                </div>
                <div class="Content">
                    <fieldset class="TableLike FixedLabelSmall Tight">
                        <label>[% Translate("Created") | html %]:</label>
                        <p class="Value">[% Data.CreateTime | Localize("TimeLong") %]</p>
                        <div class="Clear"></div>

                        <label>[% Translate("Created by") | html %]:</label>
                        <p class="Value">
                            [% Data.CreateByName | html %]
                        </p>
                        <div class="Clear"></div>

                        <label>[% Translate("Last changed") | html %]:</label>
                        <p class="Value">
                            [% Data.ChangeTime | Localize("TimeLong") %]
                        </p>
                        <div class="Clear"></div>

                        <label>[% Translate("Last changed by") | html %]:</label>
                        <p class="Value">
                            [% Data.ChangeByName | html %]
                        </p>
                        <div class="Clear"></div>
                    </fieldset>
                </div>
            </div>
        </div>


        <div class="ContentColumn">
            <div class="ControlRow">
            </div>
            <div class="ActionRow">
                <ul class="Actions">
[% RenderBlockStart("MenuItem") %]
                    <li>
                        <a href="[% Env("Baselink") %][% Data.Link | Interpolate %]" class="[% Data.MenuClass | html %]" title="[% Translate(Data.Description) | html %]">[% Translate(Data.Name) | html %]</a>
                    </li>
[% RenderBlockEnd("MenuItem") %]
                </ul>
            </div>

            <div class="WidgetBox SpacingTop Expanded">
                <div class="LightRow Header">
                    <div class="WidgetAction Toggle"><a href="#" title="[% Translate("Show or hide the content.") | html %]"><i class="fa fa-caret-right"></i><i class="fa fa-caret-down"></i></a></div>
                    <h2>[% Translate("SLA") | html %]: [% Data.Name | html %]</h2>
                </div>
                <div class="Content AutoHeight">
                    <fieldset class="TableLike FixedLabel">
                        <label>[% Translate("Type") | html %]: </label>
                        <div class="Field">
                            [% Translate(Data.Type) | html %]
                        </div>
                        <div class="Clear"></div>

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

                        <label>[% Translate("First Response Time") | html %]: </label>
                        <div class="Field">
                            [% Data.FirstResponseTime | html %] [% Translate("minutes") | html %]
                        </div>
                        <div class="Clear"></div>

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

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

                        <label>[% Translate("Minimum Time Between Incidents") | html %]: </label>
                        <div class="Field">
                            [% Data.MinTimeBetweenIncidents | html %] [% Translate("minutes") | html %]
                        </div>
                        <div class="Clear"></div>

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

                    </fieldset>
                </div>
            </div>

[% RenderBlockStart("Service") %]
            <div class="WidgetSimple SpacingTop SpacingBottomMedium">
                <div class="Header">
                    <div class="WidgetAction Toggle">
                        <a href="#" title="[% Translate("Show or hide the content") | html %]"><i class="fa fa-caret-right"></i><i class="fa fa-caret-down"></i></a>
                    </div>
                    <h2>[% Translate("Associated Services") | html %]</h2>
                </div>
                <div class="Content">
                    <table class="DataTable">
                        <thead>
                            <tr>
                                <th>[% Translate("State") | html %]</th>
                                <th>[% Translate("Service") | html %]</th>
# Rother OSS / ServiceCatalog
#                                 <th>[% Translate("Comment") | html %]</th>
                                <th>[% Translate("Description (short)") | html %]</th>
# EO ServiceCatalog
                                <th>[% Translate("Type") | html %]</th>
                                <th>[% Translate("Criticality") | html %]</th>
                                <th>[% Translate("Changed") | html %]</th>
                            </tr>
                        </thead>
                        <tbody>
[% RenderBlockStart("ServiceRow") %]
                            <tr>
                                <td>
                                    <div class="Flag Small">
                                        <span class="[% Data.CurInciSignal | html %]" title="[% Translate(Data.CurInciState) | html %]"></span>
                                    </div>
                                </td>
                                <td>
                                    <a href="[% Env("Baselink") %]Action=AgentITSMServiceZoom;ServiceID=[% Data.ServiceID | uri %]">
                                        [% Data.Name | html %]
                                    </a>
                                </td>
# Rother OSS / ServiceCatalog
#                                 <td title="[% Data.Comment | html %]">[% Data.Comment | truncate(100) | html %]</td>
                                <td title="[% Data.DescriptionShort | html %]">[% Data.DescriptionShort | truncate(100) | html %]</td>
# EO ServiceCatalog
                                <td>[% Translate(Data.Type) | html %]</td>
                                <td>[% Translate(Data.Criticality) | html %]</td>
                                <td>[% Data.ChangeTime | Localize("TimeLong") %]</td>
                            </tr>
[% RenderBlockEnd("ServiceRow") %]
                        </tbody>
                    </table>
                </div>
            </div>
[% RenderBlockEnd("Service") %]

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

package Kernel::System::Console::Command::Admin::Service::Add;

use strict;
use warnings;
# ---
# ITSMCore
# ---
use Kernel::System::VariableCheck qw(:all);
# ---

use parent qw(Kernel::System::Console::BaseCommand);

our @ObjectDependencies = (
    'Kernel::System::Service',
# Rother OSS / ServiceCatalog
    'Kernel::Config',
# EO ServiceCatalog
# ---
# ITSMCore
# ---
    'Kernel::System::DynamicField',
    'Kernel::System::GeneralCatalog',
# ---
);

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

    $Self->Description('Add new service.');
    $Self->AddOption(
        Name        => 'name',
        Description => "Name of the new service.",
        Required    => 1,
        HasValue    => 1,
        ValueRegex  => qr/.*/smx,
    );
# Rother OSS / ServiceCatalog
    $Self->AddOption(
        Name        => 'description',
        Description => "Description of the new service. Note that the language of the description is the default language of the system and that the content is used as both short and long description.",
        Required    => 1,
        HasValue    => 1,
        ValueRegex  => qr/.*/smx,
    );
# EO ServiceCatalog
# ---
# ITSMCore
# ---
    $Self->AddOption(
        Name        => 'criticality',
        Description => "Criticality of the new service.",
        Required    => 1,
        HasValue    => 1,
        ValueRegex  => qr/.*/smx,
    );
    $Self->AddOption(
        Name        => 'type',
        Description => "Type of the new service.",
        Required    => 1,
        HasValue    => 1,
        ValueRegex  => qr/.*/smx,
    );
# ---
    $Self->AddOption(
        Name        => 'parent-name',
        Description => "Parent service name. If given, the new service will be a subservice of the given parent.",
        Required    => 0,
        HasValue    => 1,
        ValueRegex  => qr/.*/smx,
    );
    $Self->AddOption(
        Name        => 'comment',
        Description => "Comment for the new service.",
        Required    => 0,
        HasValue    => 1,
        ValueRegex  => qr/.*/smx,
    );

    return;
}

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

    # Get all services.
    $Self->{Name} = $Self->GetOption('name');
    my %ServiceList = $Kernel::OM->Get('Kernel::System::Service')->ServiceList(
        Valid  => 0,
        UserID => 1,
    );
    my %Reverse = reverse %ServiceList;

    $Self->{ParentName} = $Self->GetOption('parent-name');
    if ( $Self->{ParentName} ) {

        # Check if Parent service exists.
        $Self->{ParentID} = $Kernel::OM->Get('Kernel::System::Service')->ServiceLookup(
            Name   => $Self->{ParentName},
            UserID => 1,
        );
        die "Parent service $Self->{ParentName} does not exist.\n" if !$Self->{ParentID};

        # Check if Parent::Child service combination exists.
        my $ServiceName = $Self->{ParentName} . '::' . $Self->{Name};
        die "Service '$ServiceName' already exists!\n" if $Reverse{$ServiceName};
    }
    else {

        # Check if service already exists.
        die "Service '$Self->{Name}' already exists!\n" if $Reverse{ $Self->{Name} };
    }
# ---
# ITSMCore
# ---

    # get the dynamic field config for ITSMCriticality
    my $DynamicFieldConfigArrayRef = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
        Valid       => 1,
        ObjectType  => [ 'Ticket' ],
        FieldFilter => {
            ITSMCriticality => 1,
        },
    );

    # get the dynamic field values for ITSMCriticality
    my %PossibleValues;
    DYNAMICFIELD:
    for my $DynamicFieldConfig ( @{ $DynamicFieldConfigArrayRef } ) {
        next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);

        # get PossibleValues
        $PossibleValues{ $DynamicFieldConfig->{Name} } = $DynamicFieldConfig->{Config}->{PossibleValues} || {};
    }

    my %Criticality = %{ $PossibleValues{ITSMCriticality} };

    $Self->{Criticality} = $Criticality{ $Self->GetOption('criticality') };

    if ( !$Self->{Criticality} ) {
        die "Criticality '" . $Self->GetOption('criticality') . "' does not exist.\n";
    }

    # get service type list
    my $ServiceTypeList = $Kernel::OM->Get('Kernel::System::GeneralCatalog')->ItemList(
        Class => 'ITSM::Service::Type',
    );

    my %ServiceType = reverse %{$ServiceTypeList};

    $Self->{TypeID} = $ServiceType{ $Self->GetOption('type') };

    if ( !$Self->{TypeID} ) {
        die "Type '" . $Self->GetOption('type') . "' does not exist.\n";
    }
# ---

    return;
}

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

    $Self->Print("<yellow>Adding a new service...</yellow>\n");

    my $Language = $Kernel::OM->Get('Kernel::Config')->Get('DefaultLanguage') || 'en';

    # add service
    if (
        !$Kernel::OM->Get('Kernel::System::Service')->ServiceAdd(
            UserID   => 1,
            ValidID  => 1,
            Name     => $Self->{Name},
            Comment  => $Self->GetOption('comment'),
# Rother OSS / ServiceCatalog
            Descriptions => {
                $Language => {
                    DescriptionShort => $Self->GetOption('description'),
                    DescriptionLong  => $Self->GetOption('description'),
                    ContentType      => 'text/html',
                },
            },
# EO ServiceCatalog
            ParentID => $Self->{ParentID},
# ---
# ITSMCore
# ---
            TypeID      => $Self->{TypeID},
            Criticality => $Self->{Criticality},
# ---
        )
        )
    {
        $Self->PrintError("Can't add service.");
        return $Self->ExitCodeError();
    }

    $Self->Print("<green>Done.</green>\n");
    return $Self->ExitCodeOk();
}

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 - e44c18aea9abc125fddf9ceeed204db4fab290e0 - Kernel/System/Service.pm
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

package Kernel::System::Service;

use strict;
use warnings;

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

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::System::Cache',
    'Kernel::System::CheckItem',
    'Kernel::System::DB',
# ---
# ITSMCore
# ---
    'Kernel::System::DynamicField',
    'Kernel::System::GeneralCatalog',
    'Kernel::System::LinkObject',
# ---
    'Kernel::System::Log',
    'Kernel::System::Main',
    'Kernel::System::Translations',
    'Kernel::System::Valid',
# RotherOSS ServiceCatalog    
    'Kernel::System::ACL::DB::ACL',
    'Kernel::System::Encode',
    'Kernel::System::Service',
    'Kernel::System::Type'
# EO ServiceCatalog    
);

=head1 NAME

Kernel::System::Service - service lib

=head1 DESCRIPTION

All service functions.

=head1 PUBLIC INTERFACE

=head2 new()

create an object

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

=cut

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

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

    $Self->{CacheType} = 'Service';
    $Self->{CacheTTL}  = 60 * 60 * 24 * 20;
# ---
# ITSMCore
# ---

    # get the dynamic field for ITSMCriticality
    my $DynamicFieldConfigArrayRef = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
        Valid       => 1,
        ObjectType  => [ 'Ticket' ],
        FieldFilter => {
            ITSMCriticality => 1,
        },
    );

    # get the dynamic field value for ITSMCriticality
    my %PossibleValues;
    DYNAMICFIELD:
    for my $DynamicFieldConfig ( @{ $DynamicFieldConfigArrayRef } ) {
        next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);

        # get PossibleValues
        $PossibleValues{ $DynamicFieldConfig->{Name} } = $DynamicFieldConfig->{Config}->{PossibleValues} || {};
    }

    # set the criticality list
    $Self->{CriticalityList} = $PossibleValues{ITSMCriticality};
# ---

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

    return $Self;
}

=head2 ServiceList()

return a hash list of services

    my %ServiceList = $ServiceObject->ServiceList(
        Valid  => 0,   # (optional) default 1 (0|1)
        UserID => 1,
    );

=cut

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

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

    # check valid param
    if ( !defined $Param{Valid} ) {
        $Param{Valid} = 1;
    }

    # read cache
    my $CacheKey = 'ServiceList::Valid::' . $Param{Valid};

    if ( $Param{Valid} && defined $Param{KeepChildren} && $Param{KeepChildren} eq '1' ) {
        $CacheKey .= '::KeepChildren::' . $Param{KeepChildren};
    }

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

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

    # ask database
    $DBObject->Prepare(
        SQL => 'SELECT id, name, valid_id FROM service',
    );

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

    if ( !$Param{Valid} ) {
        $Kernel::OM->Get('Kernel::System::Cache')->Set(
            Type  => $Self->{CacheType},
            TTL   => $Self->{CacheTTL},
            Key   => $CacheKey,
            Value => \%ServiceList,
        );
        return %ServiceList if !$Param{Valid};
    }

    # get valid ids
    my @ValidIDs = $Kernel::OM->Get('Kernel::System::Valid')->ValidIDsGet();

    # duplicate service list
    my %ServiceListTmp = %ServiceList;

    # add suffix for correct sorting
    for my $ServiceID ( sort keys %ServiceListTmp ) {
        $ServiceListTmp{$ServiceID} .= '::';
    }

    my %ServiceInvalidList;
    SERVICEID:
    for my $ServiceID ( sort { $ServiceListTmp{$a} cmp $ServiceListTmp{$b} } keys %ServiceListTmp )
    {

        my $Valid = scalar grep { $_ eq $ServiceValidList{$ServiceID} } @ValidIDs;

        next SERVICEID if $Valid;

        $ServiceInvalidList{ $ServiceList{$ServiceID} } = 1;
        delete $ServiceList{$ServiceID};
    }

    # delete invalid services and children
    if ( !defined $Param{KeepChildren} || !$Param{KeepChildren} ) {
        for my $ServiceID ( sort keys %ServiceList ) {

            INVALIDNAME:
            for my $InvalidName ( sort keys %ServiceInvalidList ) {

                if ( $ServiceList{$ServiceID} =~ m{ \A \Q$InvalidName\E :: }xms ) {
                    delete $ServiceList{$ServiceID};
                    last INVALIDNAME;
                }
            }
        }
    }

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

    return %ServiceList;
}

=head2 ServiceListGet()

return a list of services with the complete list of attributes for each service

    my $ServiceList = $ServiceObject->ServiceListGet(
        Valid  => 0,   # (optional) default 1 (0|1)
        UserID => 1,
    );

    returns

    $ServiceList = [
        {
            ServiceID  => 1,
            ParentID   => 0,
            Name       => 'MyService',
            NameShort  => 'MyService',
            ValidID    => 1,
            Comment    => 'Some Comment'
            CreateTime => '2011-02-08 15:08:00',
            ChangeTime => '2011-06-11 17:22:00',
            CreateBy   => 1,
            ChangeBy   => 1,
# ---
# ITSMCore
# ---
            TypeID           => 16,
            Type             => 'Backend',
            Criticality      => '3 normal',
            CurInciStateID   => 1,
            CurInciState     => 'Operational',
            CurInciStateType => 'operational',
# ---
# Rother OSS / ServiceCatalog
            Descriptions => {
                en => {
                    DescriptionShort  => 'Service A',
                    DescriptionLong   => 'This is Service A.',
                    ContentType       => 'text/html',
                },
                de => {
                    DescriptionShort  => 'Service A',
                    DescriptionLong   => 'Das ist Service A.',
                    ContentType       => 'text/html',
                },
            }
            TicketTypeIDs    => [ 1, 2, 3 ],
            Keywords         => 'service hints for filter',
# EO ServiceCatalog
        },
        {
            ServiceID  => 2,
            ParentID   => 1,
            Name       => 'MyService::MySubService',
            NameShort  => 'MySubService',
            ValidID    => 1,
            Comment    => 'Some Comment'
            CreateTime => '2011-02-08 15:08:00',
            ChangeTime => '2011-06-11 17:22:00',
            CreateBy   => 1,
            ChangeBy   => 1,
# ---
# ITSMCore
# ---
            TypeID           => 16,
            Type             => 'Backend',
            Criticality      => '3 normal',
            CurInciStateID   => 1,
            CurInciState     => 'Operational',
            CurInciStateType => 'operational',
# ---
        },
        # ...
    ];

=cut

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

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

    # check valid param
    if ( !defined $Param{Valid} ) {
        $Param{Valid} = 1;
    }

    # check cached results
    my $CacheKey = 'Cache::ServiceListGet::Valid::' . $Param{Valid};
    my $Cache    = $Kernel::OM->Get('Kernel::System::Cache')->Get(
        Type => $Self->{CacheType},
        Key  => $CacheKey,
    );
    return $Cache if defined $Cache;

    # create SQL query
    my $SQL = 'SELECT id, name, valid_id, comments, create_time, create_by, change_time, change_by '
# ---
# ITSMCore
# ---
        . ", type_id, criticality "
# ---
# RotherOSS / ServiceCatalog
        . ", keywords "
# EO ServiceCatalog
        . 'FROM service';

    if ( $Param{Valid} ) {
        $SQL .= ' WHERE valid_id IN (' . join ', ',
            $Kernel::OM->Get('Kernel::System::Valid')->ValidIDsGet() . ')';
    }

    $SQL .= ' ORDER BY name';

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

    # ask database
    $DBObject->Prepare(
        SQL => $SQL,
    );

    # fetch the result
    my @ServiceList;
    my %ServiceName2ID;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        my %ServiceData;
        $ServiceData{ServiceID}  = $Row[0];
        $ServiceData{Name}       = $Row[1];
        $ServiceData{ValidID}    = $Row[2];
        $ServiceData{Comment}    = $Row[3] || '';
        $ServiceData{CreateTime} = $Row[4];
        $ServiceData{CreateBy}   = $Row[5];
        $ServiceData{ChangeTime} = $Row[6];
        $ServiceData{ChangeBy}   = $Row[7];
# ---
# ITSMCore
# ---
        $ServiceData{TypeID}      = $Row[8];
        $ServiceData{Criticality} = $Row[9] || '';
# ---
# RotherOSS / ServiceCatalog
        $ServiceData{Keywords}         = $Row[10];
# EO ServiceCatalog
        # add service data to service list
        push @ServiceList, \%ServiceData;

        # build service id lookup hash
        $ServiceName2ID{ $ServiceData{Name} } = $ServiceData{ServiceID};
    }

    for my $ServiceData (@ServiceList) {

        # create short name and parentid
        $ServiceData->{NameShort} = $ServiceData->{Name};
        if ( $ServiceData->{Name} =~ m{ \A (.*) :: (.+?) \z }xms ) {
            my $ParentName = $1;
            $ServiceData->{NameShort} = $2;
            $ServiceData->{ParentID}  = $ServiceName2ID{$ParentName};
        }

        # get service preferences
        my %Preferences = $Self->ServicePreferencesGet(
            ServiceID => $ServiceData->{ServiceID},
        );

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

# RotherOSS / ServiceCatalog
        # Get all linked ticket type IDs.
        $DBObject->Prepare(
            SQL =>
                'SELECT ticket_type_id FROM service_type WHERE service_id = ?',
            Bind  => [ \$ServiceData->{ServiceID} ],
        );

        my @TicketTypeIDs;
        while ( my @Row = $DBObject->FetchrowArray() ) {
            push @TicketTypeIDs, $Row[0];
        }
        $ServiceData->{TicketTypeIDs} = \@TicketTypeIDs;
# EO ServiceCatalog

# ---
# ITSMCore
# ---
        # get current incident state, calculated from related config items and child services
        my %NewServiceData = $Self->_ServiceGetCurrentIncidentState(
            ServiceData => $ServiceData,
            Preferences => \%Preferences,
            UserID      => $Param{UserID},
        );
        $ServiceData = \%NewServiceData;
# ---

# RotherOSS / ServiceCatalog

        # get service descriptions data
        $DBObject->Prepare(
            SQL => '
                SELECT description_short, description_long, content_type, language
                FROM service_description
                WHERE service_id = ?',
            Bind => [ \$ServiceData->{ServiceID} ],
        );

        my %Descriptions;

        while ( my @Row = $DBObject->FetchrowArray() ) {

            # add to descriptions hash with the language as key
            $Descriptions{ $Row[3] } = {
                DescriptionShort => $Row[0],
                DescriptionLong  => $Row[1],
                ContentType      => $Row[2],
            };
        }

        $ServiceData->{Descriptions} = \%Descriptions;

# EO ServiceCatalog
    }

    if (@ServiceList) {

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

    return \@ServiceList;
}

=head2 ServiceGet()

return a service as hash

Return
    $ServiceData{ServiceID}
    $ServiceData{ParentID}
    $ServiceData{Name}
    $ServiceData{NameShort}
    $ServiceData{ValidID}
    $ServiceData{Comment}
    $ServiceData{CreateTime}
    $ServiceData{CreateBy}
    $ServiceData{ChangeTime}
    $ServiceData{ChangeBy}
# Rother OSS / ServiceCatalog
    Descriptions => {
        en => {
            DescriptionShort  => 'Service A',
            DescriptionLong   => 'This is Service A.',
            ContentType       => 'text/html',
        },
        de => {
            DescriptionShort  => 'Service A',
            DescriptionLong   => 'Das ist Service A.',
            ContentType       => 'text/html',
        },
    }
    $ServiceData{TicketTypeIDs}
    $ServiceData{DestQueueID}
    $ServiceData{Keywords}
# EO ServiceCatalog
# ---
# ITSMCore
# ---
    $ServiceData{TypeID}
    $ServiceData{Type}
    $ServiceData{Criticality}
    $ServiceData{CurInciStateID}    # Only if IncidentState is 1
    $ServiceData{CurInciState}      # Only if IncidentState is 1
    $ServiceData{CurInciStateType}  # Only if IncidentState is 1

    my %ServiceData = $ServiceObject->ServiceGet(
        ServiceID     => 123,
        IncidentState => 1, # Optional, returns CurInciState etc.
        UserID        => 1,
    );
# ---

    my %ServiceData = $ServiceObject->ServiceGet(
        ServiceID => 123,
        UserID    => 1,
    );

    my %ServiceData = $ServiceObject->ServiceGet(
        Name    => 'Service::SubService',
        UserID  => 1,
    );

=cut

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

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

    # either ServiceID or Name must be passed
    if ( !$Param{ServiceID} && !$Param{Name} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need ServiceID or Name!',
        );
        return;
    }

    # check that not both ServiceID and Name are given
    if ( $Param{ServiceID} && $Param{Name} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Need either ServiceID OR Name - not both!',
        );
        return;
    }

    # lookup the ServiceID
    if ( $Param{Name} ) {
        $Param{ServiceID} = $Self->ServiceLookup(
            Name => $Param{Name},
        );
    }

    # check cached results
    my $CacheKey = 'Cache::ServiceGet::' . $Param{ServiceID};
# ---
# ITSMCore
# ---
    # add the IncidentState parameter to the cache key
    $Param{IncidentState} ||= 0;
    $CacheKey .= '::IncidentState::' . $Param{IncidentState};
# ---
    my $Cache    = $Kernel::OM->Get('Kernel::System::Cache')->Get(
        Type => $Self->{CacheType},
        Key  => $CacheKey,
    );
    return %{$Cache} if ref $Cache eq 'HASH';

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

    # get service from db
    $DBObject->Prepare(
        SQL =>
            'SELECT id, name, valid_id, comments, create_time, create_by, change_time, change_by '
# ---
# ITSMCore
# ---
            . ", type_id, criticality "
# ---
# Rother OSS / ServiceCatalog
            . ", dest_queueid, keywords "
# EO ServiceCatalog
            . 'FROM service WHERE id = ?',
        Bind  => [ \$Param{ServiceID} ],
        Limit => 1,
    );

    # fetch the result
    my %ServiceData;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $ServiceData{ServiceID}  = $Row[0];
        $ServiceData{Name}       = $Row[1];
        $ServiceData{ValidID}    = $Row[2];
        $ServiceData{Comment}    = $Row[3] || '';
        $ServiceData{CreateTime} = $Row[4];
        $ServiceData{CreateBy}   = $Row[5];
        $ServiceData{ChangeTime} = $Row[6];
        $ServiceData{ChangeBy}   = $Row[7];
# ---
# ITSMCore
# ---
        $ServiceData{TypeID}      = $Row[8];
        $ServiceData{Criticality} = $Row[9] || '';
# ---
# Rother OSS / ServiceCatalog
        $ServiceData{DestQueueID}      = $Row[10];
        $ServiceData{Keywords}         = $Row[11];
# EO ServiceCatalog
    }

# Rother OSS / ServiceCatalog
    # get service descriptions data
    $DBObject->Prepare(
        SQL => '
            SELECT description_short, description_long, content_type, language
            FROM service_description
            WHERE service_id = ?',
        Bind => [ \$ServiceData{ServiceID} ],
    );

    while ( my @Row = $DBObject->FetchrowArray() ) {

        # add to descriptions hash with the language as key
        $ServiceData{Descriptions}->{ $Row[3] } = {
            DescriptionShort => $Row[0],
            DescriptionLong  => $Row[1],
            ContentType      => $Row[2],
        };
    }

    # Get all linked ticket type IDs.
    $DBObject->Prepare(
        SQL =>
            'SELECT ticket_type_id FROM service_type WHERE service_id = ?',
        Bind  => [ \$Param{ServiceID} ],
    );

    my @TicketTypeIDs;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        push @TicketTypeIDs, $Row[0];
    }
    $ServiceData{TicketTypeIDs} = \@TicketTypeIDs;
# EO ServiceCatalog

    # check service
    if ( !$ServiceData{ServiceID} ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "No such ServiceID ($Param{ServiceID})!",
        );
        return;
    }

    # create short name and parentid
    $ServiceData{NameShort} = $ServiceData{Name};
    if ( $ServiceData{Name} =~ m{ \A (.*) :: (.+?) \z }xms ) {
        $ServiceData{NameShort} = $2;

        # lookup parent
        my $ServiceID = $Self->ServiceLookup(
            Name => $1,
        );
        $ServiceData{ParentID} = $ServiceID;
    }

    # get service preferences
    my %Preferences = $Self->ServicePreferencesGet(
        ServiceID => $Param{ServiceID},
    );

    # merge hash
    if (%Preferences) {
        %ServiceData = ( %ServiceData, %Preferences );
    }
# ---
# ITSMCore
# ---
    if ( $Param{IncidentState} ) {
        # get current incident state, calculated from related config items and child services
        %ServiceData = $Self->_ServiceGetCurrentIncidentState(
            ServiceData => \%ServiceData,
            Preferences => \%Preferences,
            UserID      => $Param{UserID},
        );
    }
# ---

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

    return %ServiceData;
}

=head2 ServiceLookup()

return a service name and id

    my $ServiceName = $ServiceObject->ServiceLookup(
        ServiceID => 123,
    );

    or

    my $ServiceID = $ServiceObject->ServiceLookup(
        Name => 'Service::SubService',
    );

=cut

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

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

    if ( $Param{ServiceID} ) {

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

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

        # lookup
        $DBObject->Prepare(
            SQL   => 'SELECT name FROM service WHERE id = ?',
            Bind  => [ \$Param{ServiceID} ],
            Limit => 1,
        );

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

        $Kernel::OM->Get('Kernel::System::Cache')->Set(
            Type  => $Self->{CacheType},
            TTL   => $Self->{CacheTTL},
            Key   => $CacheKey,
            Value => $Result,
        );

        return $Result;
    }
    else {

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

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

        # lookup
        $DBObject->Prepare(
            SQL   => 'SELECT id FROM service WHERE name = ?',
            Bind  => [ \$Param{Name} ],
            Limit => 1,
        );

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

        $Kernel::OM->Get('Kernel::System::Cache')->Set(
            Type  => $Self->{CacheType},
            TTL   => $Self->{CacheTTL},
            Key   => $CacheKey,
            Value => $Result,
        );

        return $Result;
    }
}

=head2 ServiceAdd()

add a service

    my $ServiceID = $ServiceObject->ServiceAdd(
        Name     => 'Service Name',
        ParentID => 1,           # (optional)
        ValidID  => 1,
        Comment  => 'Comment',    # (optional)
        UserID   => 1,
# ---
# ITSMCore
# ---
        TypeID      => 2,
        Criticality => '3 normal',
# ---
# Rother OSS / ServiceCatalog
        Descriptions => {
            en => {
                DescriptionShort  => 'Service A',
                DescriptionLong   => 'This is Service A.',
                ContentType       => 'text/html',
            },
            de => {
                DescriptionShort  => 'Service A',
                DescriptionLong   => 'Das ist Service A.',
                ContentType       => 'text/html',
            },
        },
        TicketTypeIDs    => [ 1, 2, 3 ],
        Keywords         => 'service hints for filter',
# EO ServiceCatalog
    );

=cut

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

    # check needed stuff
# Rother OSS / ServiceCatalog
## ---
## ITSMCore
## ---
##    for my $Argument (qw(Name ValidID UserID)) {
#     for my $Argument (qw(Name ValidID UserID TypeID Criticality)) {
## ---
    for my $Argument (qw(Name ValidID UserID Descriptions Criticality)) {
# EO ServiceCatalog
        if ( !$Param{$Argument} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # set comment
    $Param{Comment} ||= '';

# Rother OSS / ServiceCatalog
    $Param{DestQueueID} ||= '';
# EO ServiceCatalog

    # cleanup given params
    for my $Argument (qw(Name Comment)) {
        $Kernel::OM->Get('Kernel::System::CheckItem')->StringClean(
            StringRef         => \$Param{$Argument},
            RemoveAllNewlines => 1,
            RemoveAllTabs     => 1,
        );
    }

    # check service name
    if ( $Param{Name} =~ m{ :: }xms ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Can't add service! Invalid Service name '$Param{Name}'!",
        );
        return;
    }

# Rother OSS / ServiceCatalog
    # check service descriptions parameter
    if ( !IsHashRefWithData( $Param{Descriptions} ) ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Need Service descriptions!",
        );
        return;
    }

    # check each argument for each service descriptions language
    for my $Language ( sort keys %{ $Param{Descriptions} } ) {

        for my $Argument (qw(DescriptionShort ContentType)) {

            # error if message data is incomplete
            if ( !$Param{Descriptions}->{$Language}->{$Argument} ) {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => "Need service description argument '$Argument' for language '$Language'!",
                );
                return;
            }

            # fix some bad stuff from some browsers (Opera)!
            $Param{Descriptions}->{$Language}->{DescriptionLong} ||= '';
            $Param{Descriptions}->{$Language}->{DescriptionLong} =~ s/(\n\r|\r\r\n|\r\n|\r)/\n/g;
        }
    }
# EO ServiceCatalog

    # create full name
    $Param{FullName} = $Param{Name};

    # get parent name
    if ( $Param{ParentID} ) {
        my $ParentName = $Self->ServiceLookup(
            ServiceID => $Param{ParentID},
        );
        if ($ParentName) {
            $Param{FullName} = $ParentName . '::' . $Param{Name};
        }
    }

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

    # find existing service
    $DBObject->Prepare(
        SQL   => 'SELECT id FROM service WHERE name = ?',
        Bind  => [ \$Param{FullName} ],
        Limit => 1,
    );

    my $Exists;
    while ( $DBObject->FetchrowArray() ) {
        $Exists = 1;
    }

    # add service to database
    if ($Exists) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "A service with the name and parent '$Param{FullName}' already exists.",
        );
        return;
    }

    return if !$DBObject->Do(
# Rother OSS / ServiceCatalog
## ---
## ITSMCore
## ---
##        SQL => 'INSERT INTO service '
##            . '(name, valid_id, comments, create_time, create_by, change_time, change_by) '
##            . 'VALUES (?, ?, ?, current_timestamp, ?, current_timestamp, ?)',
##        Bind => [
##            \$Param{FullName}, \$Param{ValidID}, \$Param{Comment},
##            \$Param{UserID}, \$Param{UserID},
##        ],
#         SQL => 'INSERT INTO service '
#             . '(name, valid_id, comments, create_time, create_by, change_time, change_by, '
#             . 'type_id, criticality) '
#             . 'VALUES (?, ?, ?, current_timestamp, ?, current_timestamp, ?, ?, ?)',
#         Bind => [
#             \$Param{FullName}, \$Param{ValidID}, \$Param{Comment},
#             \$Param{UserID}, \$Param{UserID}, \$Param{TypeID}, \$Param{Criticality},
#         ],
## ---
        SQL => 'INSERT INTO service '
            . '(name, valid_id, comments, create_time, create_by, change_time, change_by, '
            . 'type_id, criticality, dest_queueid, keywords) '
            . 'VALUES (?, ?, ?, current_timestamp, ?, current_timestamp, ?, ?, ?, ?, ?)',
        Bind => [
            \$Param{FullName}, \$Param{ValidID}, \$Param{Comment},
            \$Param{UserID}, \$Param{UserID}, \$Param{TypeID}, \$Param{Criticality},
            \$Param{DestQueueID}, \$Param{Keywords},
        ],
# EO ServiceCatalog
    );

    # get service id
    $DBObject->Prepare(
        SQL   => 'SELECT id FROM service WHERE name = ?',
        Bind  => [ \$Param{FullName} ],
        Limit => 1,
    );
    my $ServiceID;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        $ServiceID = $Row[0];
    }

# Rother OSS / ServiceCatalog
    # Insert new ticket type relations.
    TICKETTYPEID:
    for my $TicketTypeID ( @{ $Param{TicketTypeIDs} } ) {
        next TICKETTYPEID if !$TicketTypeID;

        return if !$DBObject->Do(
            SQL => 'INSERT INTO service_type '
                . '(service_id, ticket_type_id, create_time, create_by) '
                . 'VALUES (?, ?, current_timestamp, ?)',
            Bind => [ \$ServiceID, \$TicketTypeID, \$Param{UserID} ]
        );
    }

    # insert service descriptions data
    for my $Language ( sort keys %{ $Param{Descriptions} } ) {

        my %Description = %{ $Param{Descriptions}->{$Language} };

        return if !$DBObject->Do(
            SQL => '
                INSERT INTO service_description
                    (service_id, description_short, description_long, content_type, language)
                VALUES (?, ?, ?, ?, ?)',
            Bind => [
                \$ServiceID,
                \$Description{DescriptionShort},
                \$Description{DescriptionLong},
                \$Description{ContentType},
                \$Language,
            ],
        );
    }
# EO ServiceCatalog

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

    my %Services = $Self->ServiceList(
        UserID => $Param{UserID},
    );

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

    return $ServiceID;
}

=head2 ServiceUpdate()

update an existing service

    my $True = $ServiceObject->ServiceUpdate(
        ServiceID => 123,
        ParentID  => 1,           # (optional)
        Name      => 'Service Name',
        ValidID   => 1,
        Comment   => 'Comment',    # (optional)
        UserID    => 1,
# ---
# ITSMCore
# ---
        TypeID      => 2,
        Criticality => '3 normal',
# ---
# Rother OSS / ServiceCatalog
        Descriptions => {
            en => {
                DescriptionShort  => 'Service A',
                DescriptionLong   => 'This is Service A.',
                ContentType       => 'text/html',
            },
            de => {
                DescriptionShort  => 'Service A',
                DescriptionLong   => 'Das ist Service A.',
                ContentType       => 'text/html',
            },
        },
        TicketTypeIDs    => [ 1, 2, 3 ],
        Keyword          => 'service hints for filter',
# EO ServiceCatalog
    );

=cut

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

    # check needed stuff
# Rother OSS / ServiceCatalog
## ---
## ITSMCore
## ---
##    for my $Argument (qw(ServiceID Name ValidID UserID)) {
#    for my $Argument (qw(ServiceID Name ValidID UserID TypeID Criticality)) {
## ---
    for my $Argument (qw(ServiceID Name Descriptions ValidID UserID Criticality)) {
# EO ServiceCatalog
        if ( !$Param{$Argument} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # set default comment
    $Param{Comment} ||= '';

# Rother OSS / ServiceCatalog
    $Param{DestQueueID} ||= '';
# EO ServiceCatalog

    # cleanup given params
    for my $Argument (qw(Name Comment)) {
        $Kernel::OM->Get('Kernel::System::CheckItem')->StringClean(
            StringRef         => \$Param{$Argument},
            RemoveAllNewlines => 1,
            RemoveAllTabs     => 1,
        );
    }

    # check service name
    if ( $Param{Name} =~ m{ :: }xms ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Can't update service! Invalid Service name '$Param{Name}'!",
        );
        return;
    }

    # get old name of service
    my $OldServiceName = $Self->ServiceLookup(
        ServiceID => $Param{ServiceID},
    );

    if ( !$OldServiceName ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Can't update service! Service '$Param{ServiceID}' does not exist.",
        );
        return;
    }

# Rother OSS / ServiceCatalog
    # check service descriptions parameter
    if ( !IsHashRefWithData( $Param{Descriptions} ) ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Need Service descriptions!",
        );
        return;
    }

    # check each argument for each service descriptions language
    for my $Language ( sort keys %{ $Param{Descriptions} } ) {

        for my $Argument (qw(DescriptionShort ContentType)) {

            # error if message data is incomplete
            if ( !$Param{Descriptions}->{$Language}->{$Argument} ) {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => "Need service description argument '$Argument' for language '$Language'!",
                );
                return;
            }

            # fix some bad stuff from some browsers (Opera)!
            $Param{Descriptions}->{$Language}->{DescriptionLong} ||= '';
            $Param{Descriptions}->{$Language}->{DescriptionLong} =~ s/(\n\r|\r\r\n|\r\n|\r)/\n/g;
        }
    }    
# EO ServiceCatalog

    # create full name
    $Param{FullName} = $Param{Name};

    # get parent name
    if ( $Param{ParentID} ) {

        # lookup service
        my $ParentName = $Self->ServiceLookup(
            ServiceID => $Param{ParentID},
        );

        if ($ParentName) {
            $Param{FullName} = $ParentName . '::' . $Param{Name};
        }

        # check, if selected parent was a child of this service
        if ( $Param{FullName} =~ m{ \A ( \Q$OldServiceName\E ) :: }xms ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => 'Can\'t update service! Invalid parent was selected.'
            );
            return;
        }
    }

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

    # find exists service
    $DBObject->Prepare(
        SQL   => 'SELECT id FROM service WHERE name = ?',
        Bind  => [ \$Param{FullName} ],
        Limit => 1,
    );
    my $Exists;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        if ( $Param{ServiceID} ne $Row[0] ) {
            $Exists = 1;
        }
    }

    # update service
    if ($Exists) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "A service with the name and parent '$Param{FullName}' already exists.",
        );
        return;

    }

# Rother OSS / ServiceCatalog
    # Delete existing ticket type relations.
    return if !$DBObject->Do(
        SQL  => 'DELETE FROM service_type WHERE service_id = ?;',
        Bind => [ \$Param{ServiceID}, ],
    );
# EO ServiceCatalog

    # update service
    return if !$DBObject->Do(
# Rother OSS / ServiceCatalog
## ---
## ITSMCore
## ---
##        SQL => 'UPDATE service SET name = ?, valid_id = ?, comments = ?, '
##            . ' change_time = current_timestamp, change_by = ? WHERE id = ?',
##        Bind => [
##            \$Param{FullName}, \$Param{ValidID}, \$Param{Comment},
##            \$Param{UserID}, \$Param{ServiceID},
##        ],
#        SQL => 'UPDATE service SET name = ?, valid_id = ?, comments = ?, '
#            . ' change_time = current_timestamp, change_by = ?, type_id = ?, criticality = ?'
#            . ' WHERE id = ?',
#        Bind => [
#            \$Param{FullName}, \$Param{ValidID}, \$Param{Comment},
#            \$Param{UserID}, \$Param{TypeID}, \$Param{Criticality}, \$Param{ServiceID},
#        ],
## ---
        SQL => 'UPDATE service SET name = ?, valid_id = ?, comments = ?, '
            . ' change_time = current_timestamp, change_by = ?, criticality = ?, '
            . ' dest_queueid = ?, keywords = ?'
            . ' WHERE id = ?',
        Bind => [
            \$Param{FullName}, \$Param{ValidID}, \$Param{Comment},
            \$Param{UserID}, \$Param{Criticality},
            \$Param{DestQueueID}, \$Param{Keywords}, \$Param{ServiceID},
        ],
# EO ServiceCatalog
    );

# Rother OSS / ServiceCatalog
    # Insert new ticket type relations.
    TICKETTYPEID:
    for my $TicketTypeID ( @{ $Param{TicketTypeIDs} } ) {
        next TICKETTYPEID if !$TicketTypeID;
        return if !$DBObject->Do(
            SQL => 'INSERT INTO service_type '
                . '(service_id, ticket_type_id, create_time, create_by) '
                . 'VALUES (?, ?, current_timestamp, ?)',
            Bind => [ \$Param{ServiceID}, \$TicketTypeID, \$Param{UserID} ]
        );
    }
# EO ServiceCatalog

    my $LikeService = $DBObject->Quote( $OldServiceName, 'Like' ) . '::%';

    # find all childs
    $DBObject->Prepare(
        SQL  => "SELECT id, name FROM service WHERE name LIKE ?",
        Bind => [ \$LikeService ],
    );

    my @Childs;
    while ( my @Row = $DBObject->FetchrowArray() ) {
        my %Child;
        $Child{ServiceID} = $Row[0];
        $Child{Name}      = $Row[1];
        push @Childs, \%Child;
    }

    # update childs
    for my $Child (@Childs) {
        $Child->{Name} =~ s{ \A ( \Q$OldServiceName\E ) :: }{$Param{FullName}::}xms;
        $DBObject->Do(
            SQL  => 'UPDATE service SET name = ? WHERE id = ?',
            Bind => [ \$Child->{Name}, \$Child->{ServiceID} ],
        );
    }

# Rother OSS / ServiceCatalog
    # Delete existing service descriptions data.
    $DBObject->Do(
        SQL  => 'DELETE FROM service_description WHERE service_id = ?',
        Bind => [ \$Param{ServiceID} ],
    );

    # Insert new service descriptions data.
    for my $Language ( sort keys %{ $Param{Descriptions} // {} } ) {

        my %Descriptions = %{ $Param{Descriptions}->{$Language} };

        $DBObject->Do(
            SQL => '
                INSERT INTO service_description
                    (service_id, description_short, description_long, content_type, language)
                VALUES (?, ?, ?, ?, ?)',
            Bind => [
                \$Param{ServiceID},
                \$Descriptions{DescriptionShort},
                \$Descriptions{DescriptionLong},
                \$Descriptions{ContentType},
                \$Language,
            ],
        );
    }    
# EO ServiceCatalog

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

    my %Services = $Self->ServiceList(
        UserID => $Param{UserID},
    );

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

    return 1;
}

=head2 ServiceSearch()

return service ids as an array

    my @ServiceList = $ServiceObject->ServiceSearch(
        Name   => 'Service Name', # (optional)
        Limit  => 122,            # (optional) default 1000
        UserID => 1,
# ---
# ITSMCore
# ---
        TypeIDs       => 2,
        Criticalities => [ '2 low', '3 normal' ],
# ---
    );

=cut

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

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

    # set default limit
    $Param{Limit} ||= 1000;

    # create sql query
    my $SQL = "SELECT id FROM service WHERE valid_id IN ( ${\(join ', ', $Kernel::OM->Get('Kernel::System::Valid')->ValidIDsGet())} )";
    my @Bind;

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

    if ( $Param{Name} ) {

        # quote
        $Param{Name} = $DBObject->Quote( $Param{Name}, 'Like' );

        # replace * with % and clean the string
        $Param{Name} =~ s{ \*+ }{%}xmsg;
        $Param{Name} =~ s{ %+ }{%}xmsg;
        my $LikeString = '%' . $Param{Name} . '%';
        push @Bind, \$LikeString;

        $SQL .= " AND name LIKE ?";
    }
# ---
# ITSMCore
# ---
    # add type ids
    if ( $Param{TypeIDs} && ref $Param{TypeIDs} eq 'ARRAY' && @{ $Param{TypeIDs} } ) {

        # quote as integer
        for my $TypeID ( @{ $Param{TypeIDs} } ) {
            $TypeID = $Self->{DBObject}->Quote( $TypeID, 'Integer' );
        }

        $SQL .= " AND type_id IN (" . join(', ', @{ $Param{TypeIDs} }) . ") ";
    }

    # add criticalities
    if ($Param{Criticalities} && ref $Param{Criticalities} eq 'ARRAY' && @{ $Param{Criticalities} } ) {

        # quote and wrap in single quotes
        for my $Criticality ( @{ $Param{Criticalities} } ) {
            $Criticality = "'" . $Self->{DBObject}->Quote( $Criticality ) . "'";
        }

        $SQL .= "AND criticality IN (" . join(', ', @{ $Param{Criticalities} }) . ") ";
    }
# ---

    $SQL .= ' ORDER BY name';

    # search service in db
    $DBObject->Prepare(
        SQL  => $SQL,
        Bind => \@Bind,
    );

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

    return @ServiceList;
}

=head2 CustomerUserServiceMemberList()

returns a list of customeruser/service members

    ServiceID: service id
    CustomerUserLogin: customer user login
    DefaultServices: activate or deactivate default services

    Result: HASH -> returns a hash of key => service id, value => service name
            Name -> returns an array of user names
            ID   -> returns an array of user ids

    Example (get services of customer user):

    $ServiceObject->CustomerUserServiceMemberList(
        CustomerUserLogin => 'Test',
        Result            => 'HASH',
        DefaultServices   => 0,
    );

    Example (get customer user of service):

    $ServiceObject->CustomerUserServiceMemberList(
        ServiceID => $ID,
        Result    => 'HASH',
    );

=cut

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

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

    # set default (only 1 or 0 is allowed to correctly set the cache key)
    if ( !defined $Param{DefaultServices} || $Param{DefaultServices} ) {
        $Param{DefaultServices} = 1;
    }
    else {
        $Param{DefaultServices} = 0;
    }

    # get options for default services for unknown customers
    my $DefaultServiceUnknownCustomer = $Kernel::OM->Get('Kernel::Config')->Get('Ticket::Service::Default::UnknownCustomer');
    if (
        $DefaultServiceUnknownCustomer
        && $Param{DefaultServices}
        && !$Param{ServiceID}
        && !$Param{CustomerUserLogin}
        )
    {
        $Param{CustomerUserLogin} = '<DEFAULT>';
    }

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

    # create cache key
    my $CacheKey = 'CustomerUserServiceMemberList::' . $Param{Result} . '::'
        . 'DefaultServices::' . $Param{DefaultServices} . '::';
    if ( $Param{ServiceID} ) {
        $CacheKey .= 'ServiceID::' . $Param{ServiceID};
    }
    elsif ( $Param{CustomerUserLogin} ) {
        $CacheKey .= 'CustomerUserLogin::' . $Param{CustomerUserLogin};
    }

    # check cache
    my $Cache = $Kernel::OM->Get('Kernel::System::Cache')->Get(
        Type => $Self->{CacheType},
        Key  => $CacheKey,
    );
    if ( $Param{Result} eq 'HASH' ) {
        return %{$Cache} if ref $Cache eq 'HASH';
    }
    else {
        return @{$Cache} if ref $Cache eq 'ARRAY';
    }

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

    # db quote
    for ( sort keys %Param ) {
        $Param{$_} = $DBObject->Quote( $Param{$_} );
    }
    for (qw(ServiceID)) {
        $Param{$_} = $DBObject->Quote( $Param{$_}, 'Integer' );
    }

    # sql
    my %Data;
    my @Data;
    my $SQL = 'SELECT scu.service_id, scu.customer_user_login, s.name '
        . ' FROM '
        . ' service_customer_user scu, service s'
        . ' WHERE '
        . " s.valid_id IN ( ${\(join ', ', $Kernel::OM->Get('Kernel::System::Valid')->ValidIDsGet())} ) AND "
        . ' s.id = scu.service_id AND ';

    if ( $Param{ServiceID} ) {
        $SQL .= " scu.service_id = $Param{ServiceID}";
    }
    elsif ( $Param{CustomerUserLogin} ) {
        $SQL .= " scu.customer_user_login = '$Param{CustomerUserLogin}'";
    }

    $DBObject->Prepare( SQL => $SQL );

    while ( my @Row = $DBObject->FetchrowArray() ) {

        my $Value = '';
        if ( $Param{ServiceID} ) {
            $Data{ $Row[1] } = $Row[0];
            $Value = $Row[0];
        }
        else {
            $Data{ $Row[0] } = $Row[2];
        }
    }
    if (
        $Param{CustomerUserLogin}
        && $Param{CustomerUserLogin} ne '<DEFAULT>'
        && $Param{DefaultServices}
        && !keys(%Data)
        )
    {
        %Data = $Self->CustomerUserServiceMemberList(
            CustomerUserLogin => '<DEFAULT>',
            Result            => 'HASH',
            DefaultServices   => 0,
        );
    }

    # return result
    if ( $Param{Result} eq 'HASH' ) {
        $Kernel::OM->Get('Kernel::System::Cache')->Set(
            Type  => $Self->{CacheType},
            TTL   => $Self->{CacheTTL},
            Key   => $CacheKey,
            Value => \%Data,
        );
        return %Data;
    }
    if ( $Param{Result} eq 'Name' ) {
        @Data = values %Data;
    }
    else {
        @Data = keys %Data;
    }
    $Kernel::OM->Get('Kernel::System::Cache')->Set(
        Type  => $Self->{CacheType},
        TTL   => $Self->{CacheTTL},
        Key   => $CacheKey,
        Value => \@Data,
    );
    return @Data;
}

=head2 CustomerUserServiceMemberAdd()

to add a member to a service

if 'Active' is 0, the customer is removed from the service

    $ServiceObject->CustomerUserServiceMemberAdd(
        CustomerUserLogin => 'Test1',
        ServiceID         => 6,
        Active            => 1,
        UserID            => 123,
    );

=cut

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

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

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

    # delete existing relation
    return if !$DBObject->Do(
        SQL  => 'DELETE FROM service_customer_user WHERE customer_user_login = ? AND service_id = ?',
        Bind => [ \$Param{CustomerUserLogin}, \$Param{ServiceID} ],
    );

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

    # insert new relation
    my $Success = $DBObject->Do(
        SQL => 'INSERT INTO service_customer_user '
            . '(customer_user_login, service_id, create_time, create_by) '
            . 'VALUES (?, ?, current_timestamp, ?)',
        Bind => [ \$Param{CustomerUserLogin}, \$Param{ServiceID}, \$Param{UserID} ]
    );

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

    return $Success;
}

=head2 ServicePreferencesSet()

set service preferences

    $ServiceObject->ServicePreferencesSet(
        ServiceID => 123,
        Key       => 'UserComment',
        Value     => 'some comment',
        UserID    => 123,
    );

=cut

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

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

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

=head2 ServicePreferencesGet()

get service preferences

    my %Preferences = $ServiceObject->ServicePreferencesGet(
        ServiceID => 123,
        UserID    => 123,
    );

=cut

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

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

=head2 ServiceParentsGet()

return an ordered list all parent service IDs for the given service from the root parent to the
current service parent

    my $ServiceParentsList = $ServiceObject->ServiceParentsGet(
        ServiceID => 123,
        UserID    => 1,
    );

    returns

    $ServiceParentsList = [ 1, 2, ...];

=cut

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

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

    # read cache
    my $CacheKey = 'ServiceParentsGet::' . $Param{ServiceID};
    my $Cache    = $Kernel::OM->Get('Kernel::System::Cache')->Get(
        Type => $Self->{CacheType},
        Key  => $CacheKey,
    );
    return $Cache if ref $Cache;

    # get the list of services
    my $ServiceList = $Self->ServiceListGet(
        Valid  => 0,
        UserID => 1,
    );

    # get a service lookup table
    my %ServiceLookup;
    SERVICE:
    for my $ServiceData ( @{$ServiceList} ) {
        next SERVICE if !$ServiceData;
        next SERVICE if !IsHashRefWithData($ServiceData);
        next SERVICE if !$ServiceData->{ServiceID};

        $ServiceLookup{ $ServiceData->{ServiceID} } = $ServiceData;
    }

    # exit if ServiceID is invalid
    return if !$ServiceLookup{ $Param{ServiceID} };

    # to store the return structure
    my @ServiceParents;

    # get the ServiceParentID from the requested service
    my $ServiceParentID = $ServiceLookup{ $Param{ServiceID} }->{ParentID};

    # get all partents for the requested service
    while ($ServiceParentID) {

        # add service parent ID to the return structure
        push @ServiceParents, $ServiceParentID;

        # set next ServiceParentID (the parent of the current parent)
        $ServiceParentID = $ServiceLookup{$ServiceParentID}->{ParentID} || 0;

    }

    # reverse the return array to get the list ordered from old to young (in parent context)
    my @Data = reverse @ServiceParents;

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

    return \@Data;
}

=head2 GetAllCustomServices()

get all custom services of one user

    my @Services = $ServiceObject->GetAllCustomServices( UserID => 123 );

=cut

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

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

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

    return @{$Cache} if $Cache;

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

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

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

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

    return @ServiceIDs;
}
# ---
# ITSMCore
# ---

=head2 _ServiceGetCurrentIncidentState()

Returns a hash with the original service data,
enhanced with additional service data about the current incident state,
based on configuration items and other services.

    %ServiceData = $ServiceObject->_ServiceGetCurrentIncidentState(
        ServiceData => \%ServiceData,
        Preferences => \%Preferences,
        UserID      => 1,
    );

=cut

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

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

    # check needed stuff
    for my $Argument (qw(ServiceData Preferences)) {
        if ( ref $Param{$Argument} ne 'HASH' ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "$Argument must be a hash reference!",
            );
            return;
        }
    }

    # make local copies
    my %ServiceData = %{ $Param{ServiceData} };
    my %Preferences = %{ $Param{Preferences} };

    # get service type list
    my $ServiceTypeList = $Kernel::OM->Get('Kernel::System::GeneralCatalog')->ItemList(
        Class => 'ITSM::Service::Type',
    );
# Rother OSS / ServiceCatalog
    if ( $ServiceData{TypeID} ) {
        $ServiceData{Type} = $ServiceTypeList->{ $ServiceData{TypeID} } || '';
    }
# EO ServiceCatalog

    # set default incident state type
    $ServiceData{CurInciStateType} = 'operational';

    # get ITSM module directory
    my $ConfigItemModule = $Kernel::OM->Get('Kernel::Config')->Get('Home') . '/Kernel/System/ITSMConfigItem.pm';

    # check if ITSMConfigurationManagement package is installed
    if ( -e $ConfigItemModule ) {

        # check if a preference setting for CurInciStateTypeFromCIs exists
        if ( $Preferences{CurInciStateTypeFromCIs} ) {

            # set default incident state type from service preferences 'CurInciStateTypeFromCIs'
            $ServiceData{CurInciStateType} = $Preferences{CurInciStateTypeFromCIs};
        }

        # set the preferences setting for CurInciStateTypeFromCIs
        else {

            # get incident link types and directions from config
            my $IncidentLinkTypeDirection = $Kernel::OM->Get('Kernel::Config')->Get('ITSM::Core::IncidentLinkTypeDirection');

            # to store all linked config item ids of this service (for all configured link types)
            my %AllLinkedConfigItemIDs;

            LINKTYPE:
            for my $LinkType ( sort keys %{ $IncidentLinkTypeDirection } ) {

                # get the direction
                my $LinkDirection = $IncidentLinkTypeDirection->{$LinkType};

                # reverse the link direction, as this is the perspective from the service
                # no need to reverse if direction is 'Both'
                if ( $LinkDirection eq 'Source' ) {
                    $LinkDirection = 'Target';
                }
                elsif ( $LinkDirection eq 'Target' ) {
                    $LinkDirection = 'Source';
                }

                # find all linked config items with this linktype and direction
                my %LinkedConfigItemIDs = $Kernel::OM->Get('Kernel::System::LinkObject')->LinkKeyListWithData(
                    Object1   => 'Service',
                    Key1      => $ServiceData{ServiceID},
                    Object2   => 'ITSMConfigItem',
                    State     => 'Valid',
                    Type      => $LinkType,
                    Direction => $LinkDirection,
                    UserID    => 1,
                );

                # remember the linked config items
                %AllLinkedConfigItemIDs = ( %AllLinkedConfigItemIDs, %LinkedConfigItemIDs);
            }

            # investigate the current incident state of each config item
            CONFIGITEMID:
            for my $ConfigItemID ( sort keys %AllLinkedConfigItemIDs ) {

                # extract config item data
                my $ConfigItemData = $AllLinkedConfigItemIDs{$ConfigItemID};

                next CONFIGITEMID if $ConfigItemData->{CurDeplStateType} ne 'productive';
                next CONFIGITEMID if $ConfigItemData->{CurInciStateType} eq 'operational';

                # check if service must be set to 'warning'
                if ( $ConfigItemData->{CurInciStateType} eq 'warning' ) {
                    $ServiceData{CurInciStateType} = 'warning';
                    next CONFIGITEMID;
                }

                # check if service must be set to 'incident'
                if ( $ConfigItemData->{CurInciStateType} eq 'incident' ) {
                    $ServiceData{CurInciStateType} = 'incident';
                    last CONFIGITEMID;
                }
            }

            # update the current incident state type from CIs of the service
            $Self->ServicePreferencesSet(
                ServiceID => $ServiceData{ServiceID},
                Key       => 'CurInciStateTypeFromCIs',
                Value     => $ServiceData{CurInciStateType},
                UserID    => 1,
            );

            # set the preferences locally
            $Preferences{CurInciStateTypeFromCIs} = $ServiceData{CurInciStateType};
        }
    }

    # investigate the state of all child services
    if ( $ServiceData{CurInciStateType} eq 'operational' ) {

        # create the valid string
        my $ValidIDString = join q{, }, $Kernel::OM->Get('Kernel::System::Valid')->ValidIDsGet();

        # prepare name
        my $Name = $ServiceData{Name};
        $Name = $Self->{DBObject}->Quote( $Name, 'Like' );

        # get list of all valid childs
        $Self->{DBObject}->Prepare(
            SQL => "SELECT id, name FROM service "
                . "WHERE name LIKE '" . $Name . "::%' "
                . "AND valid_id IN (" . $ValidIDString . ")",
        );

        # find length of childs prefix
        my $PrefixLength = length "$ServiceData{Name}::";

        # fetch the result
        my @ChildIDs;
        ROW:
        while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {

            # extract child part
            my $ChildPart = substr $Row[1], $PrefixLength;

            next ROW if $ChildPart =~ m{ :: }xms;

            push @ChildIDs, $Row[0];
        }

        SERVICEID:
        for my $ServiceID ( @ChildIDs ) {

            # get data of child service
            my %ChildServiceData = $Self->ServiceGet(
                ServiceID     => $ServiceID,
                UserID        => $Param{UserID},
                IncidentState => 1,
            );

            next SERVICEID if $ChildServiceData{CurInciStateType} eq 'operational';

            $ServiceData{CurInciStateType} = 'warning';
            last SERVICEID;
        }
    }

    # define default incident states
    my %DefaultInciStates = (
        operational => 'Operational',
        warning     => 'Warning',
        incident    => 'Incident',
    );

    # get the incident state list of this type
    my $InciStateList = $Kernel::OM->Get('Kernel::System::GeneralCatalog')->ItemList(
        Class         => 'ITSM::Core::IncidentState',
        Preferences   => {
            Functionality => $ServiceData{CurInciStateType},
        },
    );

    my %ReverseInciStateList = reverse %{ $InciStateList };
    $ServiceData{CurInciStateID}
        = $ReverseInciStateList{ $DefaultInciStates{ $ServiceData{CurInciStateType} } };

    # fallback if the default incident state is deactivated
    if ( !$ServiceData{CurInciStateID} ) {
        my @SortedInciList = sort keys %{ $InciStateList };
        $ServiceData{CurInciStateID} = $SortedInciList[0];
    }

    # get incident state functionality
    my $InciState = $Kernel::OM->Get('Kernel::System::GeneralCatalog')->ItemGet(
        ItemID => $ServiceData{CurInciStateID},
    );

    $ServiceData{CurInciState}     = $InciState->{Name};
    $ServiceData{CurInciStateType} = $InciState->{Functionality}[0] // '';

    %ServiceData = (%ServiceData, %Preferences);

    return %ServiceData;
}

# ---


# Rother OSS / ServiceCatalog
=head2 AttachmentAdd()

add article attachments, returns the attachment id
    my $AttachmentID = $ServiceObject->AttachmentAdd(
        ServiceID   => $123,
        FileName    => 'F<image.png>',
        ContentSize => '123',
        ContentType => 'image/png;',
        Content     => $Content,
        Inline      => 1,   (0|1, default 0)
        UserID      => 1,
    );
Returns:
    $AttachmentID = 123 ;               # or undef if can't add the attachment
=cut

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

    for my $Argument (qw(ServiceID FileName ContentSize ContentType Content UserID)) {
        if ( !$Param{$Argument} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );

            return;
        }
    }

    # set default
    if ( !$Param{Inline} ) {
        $Param{Inline} = 0;
    }

    # get all existing attachments
    my @Index = $Self->AttachmentIndex(
        ServiceID => $Param{ServiceID},
        UserID    => $Param{UserID},
    );

    # get the filename
    my $NewFileName = $Param{FileName};

    # build a lookup hash of all existing file names
    my %UsedFile;
    for my $File (@Index) {
        if ( $File->{FileName} ) {
            $UsedFile{ $File->{FileName} } = 1;
        }
    }

    # try to modify the the file name by adding a number if it exists already
    my $Count = 0;
    while ( $Count < 50 ) {

        # increase counter
        $Count++;

        # if the file name exists
        if ( exists $UsedFile{$NewFileName} ) {

            # filename has a file name extension
            if ( $Param{FileName} =~ m{ \A (.*) \. (.+?) \z }xms ) {
                $NewFileName = "$1-$Count.$2";
            }
            else {
                $NewFileName = "$Param{FileName}-$Count";
            }
        }
    }

    # store the new filename
    $Param{FileName} = $NewFileName;

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

    # encode attachment if it's a postgresql backend
    if ( !$DBObject->GetDatabaseFunction('DirectBlob') ) {

        $Kernel::OM->Get('Kernel::System::Encode')->EncodeOutput( \$Param{Content} );

        $Param{Content} = MIME::Base64::encode_base64( $Param{Content} );
    }

    # write attachment to db
    return if !$DBObject->Do(
        SQL => 'INSERT INTO service_attachment ' .
            ' (service_id, filename, content_size, content_type, content, inlineattachment, ' .
            ' created, created_by, changed, changed_by) VALUES ' .
            ' (?, ?, ?, ?, ?, ?, current_timestamp, ?, current_timestamp, ?)',
        Bind => [
            \$Param{ServiceID}, \$Param{FileName}, \$Param{ContentSize}, \$Param{ContentType},
            \$Param{Content}, \$Param{Inline}, \$Param{UserID}, \$Param{UserID},
        ],
    );

    # get the attachment id
    return if !$DBObject->Prepare(
        SQL => 'SELECT id '
            . 'FROM service_attachment '
            . 'WHERE service_id = ? AND filename = ? '
            . 'AND content_size = ? AND  content_type = ? '
            . 'AND inlineattachment = ? '
            . 'AND created_by = ? AND changed_by = ?',
        Bind => [
            \$Param{ServiceID}, \$Param{FileName}, \$Param{ContentSize}, \$Param{ContentType},
            \$Param{Inline}, \$Param{UserID}, \$Param{UserID},
        ],
        Limit => 1,
    );

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

    return $AttachmentID;
}

=head2 ServiceInlineAttachmentURLUpdate()
Updates the URLs of uploaded inline attachments.
    my $Success = $ServiceObject->ServiceInlineAttachmentURLUpdate(
        ServiceID  => 12,
        FormID     => 456,
        FileID     => 5,
        Attachment => \%Attachment,
        UserID     => 1,
    );
Returns:
    $Success = 1;               # of undef if attachment URL could not be updated
=cut

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

    for my $Argument (qw(ServiceID Attachment FormID FileID UserID)) {
        if ( !$Param{$Argument} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );

            return;
        }
    }

    # check if attachment is a hash reference
    if ( ref $Param{Attachment} ne 'HASH' && !%{ $Param{Attachment} } ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Attachment must be a hash reference!",
        );

        return;
    }

    # only consider inline attachments here (they have a content id)
    return 1 if !$Param{Attachment}->{ContentID};

    my %ServiceData = $Self->ServiceGet(
        ServiceID  => $Param{ServiceID},
        UserID     => $Param{UserID},
    );

    # picture URL in upload cache
    my $Search = "Action=PictureUpload . FormID=\Q$Param{FormID}\E . "
        . "ContentID=\Q$Param{Attachment}->{ContentID}\E";

    # picture URL in Service attachment
    my $Replace = "Action=AgentITSMServiceZoom;Subaction=DownloadAttachment;"
        . "ServiceID=$Param{ServiceID};FileID=$Param{FileID}";

    # rewrite picture URLs
    foreach my $LanguageID ( keys %{$ServiceData{Descriptions}} ) {
        if ( $ServiceData{Descriptions}->{$LanguageID}->{DescriptionLong} ) {
            # replace URL
            $ServiceData{Descriptions}->{$LanguageID}->{DescriptionLong} =~ s{$Search}{$Replace}xms;
        }
    }

    # Cut off sub services from service name
    $ServiceData{Name} = (split /::/, $ServiceData{Name})[-1];

    # update service
    my $Success = $Self->ServiceUpdate(
        %ServiceData,
        UserID => $Param{UserID},
    );

    # check if update was successful
    if ( !$Success ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => "Could not update ServiceID'$Param{ServiceID}'!",
        );

        return;
    }

    return 1;
}

=head2 AttachmentGet()

get attachment of service ID
    my %File = $ServiceObject->AttachmentGet(
        ServiceID => 123,
        FileID    => 1,
        UserID    => 1,
    );
Returns:
    %File = (
        Filesize    => '540286',                # file size in bytes
        ContentType => 'image/jpeg',
        Filename    => 'F<Error.jpg>',
        Content     => '...'                    # file binary content
    );
=cut

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

    for my $Argument (qw(ServiceID FileID UserID)) {
        if ( !defined $Param{$Argument} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );

            return;
        }
    }

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

    return if !$DBObject->Prepare(
        SQL => 'SELECT filename, content_type, content_size, content '
            . 'FROM service_attachment '
            . 'WHERE id = ? AND service_id = ? '
            . 'ORDER BY created',
        Bind   => [ \$Param{FileID}, \$Param{ServiceID} ],
        Encode => [ 1, 1, 1, 0 ],
        Limit  => 1,
    );

    my %File;
    while ( my @Row = $DBObject->FetchrowArray() ) {

        # decode attachment if it's a postgresql backend and not BLOB
        if ( !$DBObject->GetDatabaseFunction('DirectBlob') ) {
            $Row[3] = MIME::Base64::decode_base64( $Row[3] );
        }

        $File{Filename}    = $Row[0];
        $File{ContentType} = $Row[1];
        $File{Filesize}    = $Row[2];
        $File{Content}     = $Row[3];
    }

    return %File;
}

=head2 AttachmentIndex()
return an attachment index of an service id
    my @Index = $ServiceObject->AttachmentIndex(
        ServiceID  => 123,
        ShowInline => 0,   ( 0|1, default 1)
        UserID     => 1,
    );
Returns:
    @Index = (
        {
            Filesize    => '527.6 KBytes',
            ContentType => 'image/jpeg',
            Filename    => 'F<Error.jpg>',
            FilesizeRaw => 540286,
            FileID      => 6,
            Inline      => 0,
        },
        {,
            Filesize => '430.0 KBytes',
            ContentType => 'image/jpeg',
            Filename => 'F<Solution.jpg>',
            FilesizeRaw => 440286,
            FileID => 5,
            Inline => 1,
        },
        {
            Filesize => '296 Bytes',
            ContentType => 'text/plain',
            Filename => 'F<AdditionalComments.txt>',
            FilesizeRaw => 296,
            FileID => 7,
            Inline => 0,
        },
    );
=cut

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

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

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

    return if !$DBObject->Prepare(
        SQL => 'SELECT id, filename, content_type, content_size, inlineattachment '
            . 'FROM service_attachment '
            . 'WHERE service_id = ? '
            . 'ORDER BY filename',
        Bind  => [ \$Param{ServiceID} ],
        Limit => 100,
    );

    my @Index;
    ATTACHMENT:
    while ( my @Row = $DBObject->FetchrowArray() ) {

        my $ID          = $Row[0];
        my $Filename    = $Row[1];
        my $ContentType = $Row[2];
        my $Filesize    = $Row[3];
        my $Inline      = $Row[4];

        # do not show inline attachments
        if ( defined $Param{ShowInline} && !$Param{ShowInline} && $Inline ) {
            next ATTACHMENT;
        }

        # convert to human readable file size
        my $FileSizeRaw = $Filesize;
        if ($Filesize) {
            if ( $Filesize > ( 1024 * 1024 ) ) {
                $Filesize = sprintf "%.1f MBytes", ( $Filesize / ( 1024 * 1024 ) );
            }
            elsif ( $Filesize > 1024 ) {
                $Filesize = sprintf "%.1f KBytes", ( ( $Filesize / 1024 ) );
            }
            else {
                $Filesize = $Filesize . ' Bytes';
            }
        }

        push @Index, {
            FileID      => $ID,
            Filename    => $Filename,
            ContentType => $ContentType,
            Filesize    => $Filesize,
            FilesizeRaw => $FileSizeRaw,
            Inline      => $Inline,
        };
    }

    return @Index;
}

=head2 AttachmentDelete()
delete attachment of article
    my $Success = $ServiceObject->AttachmentDelete(
        ServiceID => 123,
        FileID    => 1,
        UserID    => 1,
    );
Returns:
    $Success = 1 ;              # or undef if attachment could not be deleted
=cut

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

    for my $Argument (qw(ServiceID FileID UserID)) {
        if ( !defined $Param{$Argument} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );

            return;
        }
    }

    return if !$Kernel::OM->Get('Kernel::System::DB')->Do(
        SQL  => 'DELETE FROM service_attachment WHERE id = ? AND service_id = ? ',
        Bind => [ \$Param{FileID}, \$Param{ServiceID} ],
    );

    return 1;
}

=for stopwords acl

=head2 UpdateTypServiceACL()
delete attachment of article
    my $Success = $ServiceObject->UpdateTypServiceACL(
        ServiceID => 123,
        TicketTypeID    => 1, # Optional
        ServiceValid => 0,1,2,
        UserID    => 1,
    );
Returns:
    $Success = 1 ;              # or undef if acl could not be added/changed/deleted
=cut

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

    for my $Argument (qw(ServiceID ServiceValid UserID)) {
        if ( !defined $Param{$Argument} ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );

            return;
        }
    }

    my $Success;
    my $ACLName;

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

    my $ConfigObject  = $Kernel::OM->Get('Kernel::Config');
    my $ACLOptions = $ConfigObject->Get('ServiceCatalog::CreateTypeServiceRelatedAcls::Options');
    my $GenerateInitalACLToDisableAllServices = $Param{GenerateInitalACLToDisableAllServices} || $ACLOptions->{GenerateInitalACLToDisableAllServices};
    my $Possible = $Param{ConfigChange} || $ACLOptions->{ConfigChange};
    my $ACLDeploy = $Param{ACLDeploy} || $ACLOptions->{ACLDeploy};
    my $ACLValidID = $Param{ACLValidID} || $ACLOptions->{ACLValidID};
    my $FrontendAction = $Param{FrontendAction} || $ACLOptions->{FrontendAction};

    my $TypeObject = $Kernel::OM->Get('Kernel::System::Type');
    my $TicketType = $TypeObject->TypeLookup( TypeID => $Param{TicketTypeID} );

    my $ServiceObject = $Kernel::OM->Get('Kernel::System::Service');
    my $ServiceName = $ServiceObject->ServiceLookup( ServiceID => $Param{ServiceID} );

    if ( !$TicketType ) {
    # Remove Service from all ACLs.

        my %TypeList = $TypeObject->TypeList(
            Valid => 1,
        );

        TYPE:
        for my $TicketType ( values %TypeList ) {

            my $ACLRemoveName = 'zzz - Show Service based on Ticket-Type: ' . $TicketType;

            # Check if disable ACL exists
            my $ACL = $ACLObject->ACLGet(
                Name   => $ACLRemoveName,
                UserID => 1,
            );

            if (IsHashRefWithData($ACL) ) {
                my $ConfigChangeHashRefOld = $ACL->{ConfigChange};
                my $OldServices            = $ConfigChangeHashRefOld->{$Possible} && $ConfigChangeHashRefOld->{$Possible}{Ticket}
                    ? $ConfigChangeHashRefOld->{$Possible}{Ticket}{Service} : undef;
                my @ConfigServices         = $OldServices ? $OldServices->@* : ();

                @ConfigServices                                       = grep { $_ !~ /$ServiceName/ } @ConfigServices;
                $ConfigChangeHashRefOld->{$Possible}{Ticket}{Service} = [@ConfigServices];
                $ACL->{ConfigChange}                                  = $ConfigChangeHashRefOld;

                $Success = $ACLObject->ACLUpdate(
                    $ACL->%*,
                    UserID => 1,
                );
            }
        }

        return 1;
    }

    # Generate a initial ACL, which disable all services
    if ( $GenerateInitalACLToDisableAllServices eq '1' ) {

        my $ACLDisableName = 'zza - Disable all Services if no Ticket-Type is selected.';

        # Check if disable ACL exists
        my $ACL = $ACLObject->ACLGet(
                Name   => $ACLDisableName,
                UserID => 1,
            );

        # Create ACL if it not exists
        if ( !IsHashRefWithData($ACL) ) {

            my $DisableConfigMatchHashRef;
            $DisableConfigMatchHashRef->{Properties}->{Frontend}->{Action} = $FrontendAction;
            # $DisableConfigMatchHashRef->{Properties}->{Ticket}->{Type} = [];

            my $DisableConfigChangeHashRef;
            $DisableConfigChangeHashRef->{PossibleNot}{Ticket}{Service} = ['[RegExp].*'];

                my %NewACL = (
                    Name           => $ACLDisableName,
                    Comment        => 'This ACL was generated when a service was added or changed.',
                    Description    => 'This ACL is used to restrict Services per Ticket-Type',
                    StopAfterMatch => 0,
                    ConfigMatch    => $DisableConfigMatchHashRef,
                    ConfigChange   => $DisableConfigChangeHashRef,
                    ValidID        => $ACLValidID,
                );

                $Success = $ACLObject->ACLAdd(
                    %NewACL,
                    UserID => 1,
                );
        }
    }

    $ACLName = 'zzz - Show Service based on Ticket-Type: ' . $TicketType;

    my $ACL = $ACLObject->ACLGet(
        Name   => $ACLName,
        UserID => 1,
    );

    if ( $Param{ServiceValid} != 1 ) {
        if ( $ACL ) {
            $Success = $ACLObject->ACLDelete(
                ID     => $ACL->{ID},
                UserID => 1,
            );
        }
        return;
    }

    else {
        my $Action;
        my $ConfigChangeHashRefOld = $ACL->{ConfigChange};

        my $OldServices = $ConfigChangeHashRefOld->{$Possible} && $ConfigChangeHashRefOld->{$Possible}{Ticket} ? $ConfigChangeHashRefOld->{$Possible}{Ticket}{Service} : undef;
        my @ConfigServices = $OldServices ? $OldServices->@* : ();

        my $ConfigMatchHashRef  = {};
        $ConfigMatchHashRef->{Properties}->{Ticket}->{Type} = ["$TicketType"];
        $ConfigMatchHashRef->{Properties}->{Frontend}->{Action} = $FrontendAction;

        my $ConfigChangeHashRef = {};

        if (! grep { $_ =~ /$ServiceName/ } @ConfigServices ) {
            push (@ConfigServices, $ServiceName);
            $ConfigChangeHashRef->{$Possible}{Ticket}{Service} = [@ConfigServices];

            if ( IsArrayRefWithData(\@ConfigServices) ) {
                $Action = 'Update';
            } else {
                $Action = 'Delete';
            }
        } else {
            $ConfigChangeHashRef = $ConfigChangeHashRefOld;
    }

        my %NewACL = (
            Name           => $ACLName,
            Comment        => 'This ACL was generated when a service was added or changed.',
            Description    => 'This ACL is used to restrict Services per Ticket-Type',
            StopAfterMatch => 0,
            ConfigMatch    => $ConfigMatchHashRef,
            ConfigChange   => $ConfigChangeHashRef,
            ValidID        => $ACLValidID,
        );

        if ( IsHashRefWithData($ACL) ) {
            $Success = $ACLObject->ACLUpdate(
                $ACL->%*,
                %NewACL,
                UserID => 1,
            );
        }

        else {
            $Success = $ACLObject->ACLAdd(
                %NewACL,
                UserID => 1,
            );
        }
    }

    if ( !$Success ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Could not ' . ( $Param{Delete} ? 'delete' : 'update' ) . " ACL $ACLName!",
        );

        return;
    }

    # Don't deploy new ACL, cause ServiceCatalog::CreateTypeServiceRelatedAcls::Options -> Deploy is disabled
    if ( $ACLDeploy ne '1' ) {

        return 1;
    }

    # deploy new ACLs - taken from Kernel/Modules/AdminACL
    my $Location = $Kernel::OM->Get('Kernel::Config')->Get('Home') . '/Kernel/Config/Files/ZZZACL.pm';

    $Success = $ACLObject->ACLDump(
        ResultType => 'FILE',
        Location   => $Location,
        UserID     => 1,
    );

    if ( $Success ) {

        $Success = $ACLObject->ACLsNeedSyncReset();

        # remove preselection cache TODO: rebuild the cache properly (a simple $FieldRestrictionsObject->SetACLPreselectionCache(); uses the old ACLs)
        my $CacheObject = $Kernel::OM->Get('Kernel::System::Cache');
        $CacheObject->Delete(
            Type => 'TicketACL',      # only [a-zA-Z0-9_] chars usable
            Key  => 'Preselection',
        );
    }

    if ( !$Success ) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'Could not deploy ACLs - manual fix needed!',
        );

        return;
    }

    return 1;
}
# EO ServiceCatalog

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

## no critic (Modules::RequireExplicitPackage)

use Kernel::System::Service ();    ## no perlimports

package Kernel::System::Service;   ## no critic (Modules::RequireFilenameMatchesPackage)

use strict;
use warnings;
use v5.24;
use utf8;

# core modules

# CPAN modules

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

our @ObjectDependencies = (
    'Kernel::System::Queue',
    'Kernel::System::Service',
    'Kernel::System::Type',
    'Kernel::System::Valid',
);

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

    my $UserID = $Self->{UserID} || $Param{UserID};

    my %ServiceFilter;
    if ( IsArrayRefWithData( $Param{Services} ) ) {
        %ServiceFilter = map { $_ => 1 } $Param{Services}->@*;
    }

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

    my %ServiceList = $ServiceObject->ServiceList(
        Valid  => 0,
        UserID => $UserID,
    );

    my %ExportData;
    SERVICEID:
    for my $ServiceID ( sort keys %ServiceList ) {

        my %ServiceData = $ServiceObject->ServiceGet(
            ServiceID => $ServiceID,
            UserID    => $UserID,
        );

        if (%ServiceFilter) {
            next SERVICEID unless $ServiceFilter{ $ServiceData{Name} };
        }

        # translate IDs into names or name-like identifiers
        my $QueueObject = $Kernel::OM->Get('Kernel::System::Queue');
        my $TypeObject  = $Kernel::OM->Get('Kernel::System::Type');
        my $ValidObject = $Kernel::OM->Get('Kernel::System::Valid');

        ATTRIBUTE:
        for my $Attribute ( keys %ServiceData ) {

            next ATTRIBUTE unless $Attribute =~ /ID/;

            if ( $Attribute eq 'ParentID' ) {
                my $ParentService = $ServiceObject->ServiceLookup(
                    ServiceID => $ServiceData{ParentID},
                );
                $ServiceData{Parent} = $ParentService;
                delete $ServiceData{ParentID};
            }
            elsif ( $Attribute eq 'ValidID' ) {
                my $Valid = $ValidObject->ValidLookup(
                    ValidID => $ServiceData{ValidID},
                );
                $ServiceData{Valid} = $Valid;
                delete $ServiceData{ValidID};
            }
            elsif ( $Attribute eq 'DestQueueID' ) {
                my $Queue = $QueueObject->QueueLookup(
                    QueueID => $ServiceData{DestQueueID},
                );
                $ServiceData{DestQueue} = $Queue;
                delete $ServiceData{DestQueueID};
            }
            elsif ( $Attribute eq 'TicketTypeIDs' ) {
                if ( IsArrayRefWithData( $ServiceData{TicketTypeIDs} ) ) {
                    my @TicketTypes;
                    for my $TicketTypeID ( $ServiceData{TicketTypeIDs}->@* ) {
                        push @TicketTypes, $TypeObject->TypeLookup(
                            TypeID => $TicketTypeID,
                        );
                    }
                    $ServiceData{TicketTypes} = \@TicketTypes;
                    delete $ServiceData{TicketTypeIDs};
                }
            }
        }

        delete $ServiceData{ChangeBy};
        delete $ServiceData{ChangeTime};
        delete $ServiceData{CreateBy};
        delete $ServiceData{CreateTime};
        delete $ServiceData{ServiceID};

        # unhandled attribute, related to ITSMCore and GeneralCatalog
        delete $ServiceData{TypeID};

        $ExportData{ $ServiceData{Name} } = \%ServiceData;
    }

    return \%ExportData;
}

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

    my $UserID = $Self->{UserID} || $Param{UserID};

    my $QueueObject   = $Kernel::OM->Get('Kernel::System::Queue');
    my $ServiceObject = $Kernel::OM->Get('Kernel::System::Service');
    my $TypeObject    = $Kernel::OM->Get('Kernel::System::Type');
    my $ValidObject   = $Kernel::OM->Get('Kernel::System::Valid');
    my %ServiceList   = $ServiceObject->ServiceList(
        Valid  => 0,
        UserID => $UserID,
    );
    my %ServiceLookup = reverse %ServiceList;

    # sort services by parent attribute
    my @FirstLevelServices;
    my @ChildServices;
    for my $ServiceName ( keys $Param{Services}->%* ) {
        if ( $Param{Services}{$ServiceName}{Parent} ) {
            push @ChildServices, $ServiceName;
        }
        else {
            push @FirstLevelServices, $ServiceName;
        }
    }
    my @ChildServicesSorted = sort {
        if ( ( $Param{Services}{$a}{Parent} // '' ) eq $Param{Services}{$b}{Name} ) {
            return 1;
        }
        elsif ( ( $Param{Services}{$b}{Parent} // '' ) eq $Param{Services}{$a}{Name} ) {
            return -1;
        }
        else {
            return 0;
        }
    } @ChildServices;

    SERVICENAME:
    for my $ServiceName ( @FirstLevelServices, @ChildServicesSorted ) {
        my $ServiceData = $Param{Services}{$ServiceName};

        # skip if parent attribute present but no corresponding service
        if ( $ServiceData->{Parent} ) {
            my $ParentServiceID = $ServiceObject->ServiceLookup(
                Name => $ServiceData->{Parent},
            );

            next SERVICENAME unless $ParentServiceID;

            $ServiceData->{ParentID} = $ParentServiceID;
        }

        # in case of child service, check if all parent services are present
        #   either in the system or in the import data
        my @NameElements = split( /::/, $ServiceData->{Name} );
        if ( scalar @NameElements > 1 ) {
            my $NameStrg = '';
            for my $Index ( 0 .. $#NameElements - 1 ) {
                if ($NameStrg) {
                    $NameStrg .= '::' . $NameElements[$Index];
                }
                else {
                    $NameStrg .= $NameElements[$Index];
                }

                if ( !$ServiceLookup{$NameStrg} && !$Param{Services}{$NameStrg} ) {

                    # parent element not found, skipping
                    next SERVICENAME;
                }
            }
        }

        my $ServiceID = $ServiceLookup{ $ServiceData->{Name} };

        # skip if service with same name exists and overwrite is not set
        next SERVICENAME if ( !$Param{OverwriteExistingEntities} && $ServiceID );

        # translate named data back to IDs
        if ( $ServiceData->{DestQueue} ) {
            $ServiceData->{DestQueueID} = $QueueObject->QueueLookup(
                Queue => $ServiceData->{DestQueue},
            );
        }
        if ( IsArrayRefWithData( $ServiceData->{TicketTypes} ) ) {
            my @TicketTypeIDs;
            for my $TicketType ( $ServiceData->{TicketTypes}->@* ) {
                push @TicketTypeIDs, $TypeObject->TypeLookup(
                    Type => $TicketType,
                );
            }
            $ServiceData->{TicketTypeIDs} = \@TicketTypeIDs;
        }
        $ServiceData->{ValidID} = $ValidObject->ValidLookup(
            Valid => $ServiceData->{Valid},
        );

        if ($ServiceID) {

            my $Success = $ServiceObject->ServiceUpdate(
                $ServiceData->%*,
                Name      => $ServiceData->{NameShort},
                ServiceID => $ServiceID,
                UserID    => $UserID,
            );
            return unless $Success;
        }
        else {
            my $ServiceID = $ServiceObject->ServiceAdd(
                $ServiceData->%*,
                Name   => $ServiceData->{NameShort},
                UserID => $UserID,
            );
            return unless $ServiceID;
        }
    }

    return 1;
}

1;
 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 <?xml version="1.0" encoding="utf-8" ?>
<otobo_config version="2.0" init="Application">
    <Setting Name="Frontend::Module###AdminServiceImportExport" Required="0" Valid="1">
        <Description Translatable="1">Frontend module registration for the admin interface.</Description>
        <Navigation>Frontend::Admin::ModuleRegistration</Navigation>
        <Value>
            <Item ValueType="FrontendRegistration">
                <Hash>
                    <Item Key="GroupRo">
                        <Array>
                        </Array>
                    </Item>
                    <Item Key="Group">
                        <Array>
                            <Item>admin</Item>
                        </Array>
                    </Item>
                    <Item Key="Description">Service Import Export</Item>
                    <Item Key="Title">ServiceImportExport</Item>
                    <Item Key="NavBarName">Admin</Item>
                </Hash>
            </Item>
        </Value>
    </Setting>
    <Setting Name="Loader::Module::AdminServiceImportExport###002-ServiceCatalog" Required="0" Valid="1">
        <Description Translatable="1">Loader module registration for the agent interface.</Description>
        <Navigation>Frontend::Admin::ModuleRegistration::Loader</Navigation>
        <Value>
            <Hash>
                <Item Key="JavaScript">
                    <Array>
                        <Item>Core.Agent.Admin.ServiceImportExport.js</Item>
                    </Array>
                </Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="Frontend::Module###AdminSLAImportExport" Required="0" Valid="1">
        <Description Translatable="1">Frontend module registration for the admin interface.</Description>
        <Navigation>Frontend::Admin::ModuleRegistration</Navigation>
        <Value>
            <Item ValueType="FrontendRegistration">
                <Hash>
                    <Item Key="GroupRo">
                        <Array>
                        </Array>
                    </Item>
                    <Item Key="Group">
                        <Array>
                            <Item>admin</Item>
                        </Array>
                    </Item>
                    <Item Key="Description">SLA Import Export</Item>
                    <Item Key="Title">SLAImportExport</Item>
                    <Item Key="NavBarName">Admin</Item>
                </Hash>
            </Item>
        </Value>
    </Setting>
    <Setting Name="Loader::Module::AdminSLAImportExport###002-ServiceCatalog" Required="0" Valid="1">
        <Description Translatable="1">Loader module registration for the agent interface.</Description>
        <Navigation>Frontend::Admin::ModuleRegistration::Loader</Navigation>
        <Value>
            <Hash>
                <Item Key="JavaScript">
                    <Array>
                        <Item>Core.Agent.Admin.SLAImportExport.js</Item>
                    </Array>
                </Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="CustomerDashboard::Tiles###ServiceCatalog-01" Required="0" Valid="0">
        <Description Translatable="1">Tile registration for the CustomerDashboard. Module is required.</Description>
        <Navigation>Frontend::Customer::View::Dashboard::Tiles</Navigation>
        <Value>
            <Hash>
                <Item Key="Order">7</Item>
                <Item Key="Module">Kernel::Output::HTML::CustomerDashboard::TileServiceCatalog</Item>
                <Item Key="Config">
                    <Hash>
                        <Item Key="HeaderText" Translatable="1">Find the right service for your ticket</Item>
                    </Hash>
                </Item>
            </Hash>
        </Value>
    </Setting>
    <!-- FIXME: This could be renamed; would probably break existing configs on installed systems -->
    <Setting Name="CustomerDashboard::Configuration::ServiceCatalog" Required="0" Valid="1">
        <Description Translatable="1">Additional settings for the service catalog.</Description>
        <Navigation>Frontend::Customer::View::Dashboard::Configuration</Navigation>
        <Value>
            <Hash>
                <Item Key="Incident">ooofo-bang oooColor-Red</Item>
                <Item Key="Incident::Major">ooofo-bang oooColor-Red</Item>
                <Item Key="ServiceRequest"></Item>
                <Item Key="Problem"></Item>
                <Item Key="RfC"></Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="CustomerDashboard::Configuration::ServiceCatalog###DynamicField" Required="0" Valid="1">
        <Description Translatable="1">Dynamic fields shown in the service catalog screen of the customer interface.</Description>
        <Navigation>Frontend::Customer::View::Dashboard::Configuration</Navigation>
        <Value>
            <Hash>
                <DefaultItem ValueType="Select" SelectedID="0">
                    <Item ValueType="Option" Value="0" Translatable="1">0 - Disabled</Item>
                    <Item ValueType="Option" Value="1" Translatable="1">1 - Enabled</Item>
                </DefaultItem>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="DynamicFieldScreens###ServiceCatalog" Required="1" Valid="1">
        <Description Translatable="1">This configuration defines all possible screens to enable or disable dynamic fields.</Description>
        <Navigation>Frontend::Base::DynamicFieldScreens</Navigation>
        <Value>
            <Hash>
                <Item Key="CustomerDashboard::Configuration::ServiceCatalog###DynamicField">CustomerDashboardTile ServiceCatalog</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="DynamicFieldScreens::ObjectTypes###ServiceCatalog" Required="1" Valid="1">
        <Description Translatable="1">Define a list of dynamic field object types which are allowed to be assigned to actions of this package via the dynamic field screens interface.</Description>
        <Navigation>Frontend::Base::DynamicFieldScreens</Navigation>
        <Value>
            <Array>
                <Item>Service</Item>
            </Array>
        </Value>
    </Setting>
    <Setting Name="CustomerDashboard::Configuration::ServiceCatalog###SortByTicketType" Required="0" Valid="0">
        <Description Translatable="1">Show services with the following ticket type last.</Description>
        <Navigation>Frontend::Customer::View::Dashboard::Configuration</Navigation>
        <Value>
            <Item ValueType="String" ValueRegex="">Incident</Item>
        </Value>
    </Setting>
    <Setting Name="CustomerDashboard::Configuration::ServiceCatalog###FAQDescriptionField" Required="0" Valid="1">
        <Description Translatable="1">The FAQ field that should be used as the description of an FAQ article in the sidebar (e.g. Field1, Field2, Field3...).</Description>
        <Navigation>Frontend::Customer::View::Dashboard::Configuration</Navigation>
        <Value>
            <Item ValueType="String" ValueRegex="">Field1</Item>
        </Value>
    </Setting>
    <Setting Name="Loader::Module::CustomerDashboard###003-CustomerDashboard" Required="0" Valid="1">
        <Description Translatable="1">Loader module registration for the customer interface.</Description>
        <Navigation>Frontend::Customer::ModuleRegistration::Loader</Navigation>
        <Value>
            <Hash>
                <Item Key="CSS">
                    <Array>
                        <Item>Core.Dashboard.TileServiceCatalog.css</Item>
                        <Item>Core.Widget.css</Item>
                    </Array>
                </Item>
                <Item Key="JavaScript">
                    <Array>
                        <Item>Core.UI.oooWidget.js</Item>
                        <Item>Core.Customer.TileServiceCatalog.js</Item>
                    </Array>
                </Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="CustomerFrontend::Module###CustomerTileServiceCatalog" Required="0" Valid="1">
        <Description Translatable="1">Frontend module registration for the customer interface.</Description>
        <Navigation>Frontend::Customer::ModuleRegistration</Navigation>
        <Value>
            <Item ValueType="FrontendRegistration">
                <Hash>
                    <Item Key="Group">
                        <Array>
                        </Array>
                    </Item>
                    <Item Key="GroupRo">
                        <Array>
                        </Array>
                    </Item>
                    <Item Key="Title"></Item>
                    <Item Key="Description" Translatable="1">CustomerTileServiceCatalog AJAX Module.</Item>
                    <Item Key="NavBarName">Service Catalog</Item>
                </Hash>
            </Item>
        </Value>
    </Setting>
    <Setting Name="DynamicFields::ObjectType###Service" Required="0" Valid="1">
        <Description Translatable="1">DynamicField object registration.</Description>
        <Navigation>Core::DynamicFields::ObjectTypeRegistration</Navigation>
        <Value>
            <Hash>
                <Item Key="DisplayName" Translatable="1">Service</Item>
                <Item Key="Module">Kernel::System::DynamicField::ObjectType::Service</Item>
                <Item Key="Prio">140</Item>
                <Item Key="UseObjectName">1</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="ServiceCatalog::CreateTypeServiceRelatedAcls" Required="0" Valid="1">
        <Description Translatable="1">This option allows you to automatically generate ACLs for different interfaces when creating services. Services will then only be displayed if the ticket type stored in the service has been selected. The "AddBulkACL" console script can also be used to create ACLs for services that have already been create.</Description>
        <Navigation>Core::Acl</Navigation>
        <Value>
            <Item ValueType="Select" SelectedID="0">
                <Item ValueType="Option" Value="0" Translatable="1">0 - Disabled</Item>
                <Item ValueType="Option" Value="1" Translatable="1">1 - Enabled</Item>
            </Item>
        </Value>
    </Setting>
    <Setting Name="ServiceCatalog::CreateTypeServiceRelatedAcls::Options" Required="0" Valid="1">
        <Description Translatable="1">This option makes it possible to preconfigure the automatically generated ACLs. The aim is to only display the services that have also been assigned to the service in the service catalog. To use this function, please first enable the "ServiceCatalog::CreateTypeServiceRelatedAcls" option. "GenerateInitalACLToDisableAllServices" generates an ACL that initially hides all services. The value "Possible" or "PossibleAdd" can be set for the key "ConfigChange". The "DeployNewACL" key decides whether the changed ACL should also be deployed immediately. "ACLValidID" (1, 2, 3) sets the ACLs to valid, invalid or temporarily invalid.</Description>
        <Navigation>Core::Acl</Navigation>
        <Value>
            <Hash>
                <Item Key="FrontendAction">
                    <Array>
                        <Item>CustomerTicketMessage</Item>
                        <Item>AgentTicketPhone</Item>
                        <Item>AgentTicketEmail</Item>
                        <Item>AgentTicketFreeText</Item>
                    </Array>
                </Item>
                <Item Key="GenerateInitalACLToDisableAllServices">1</Item>
                <Item Key="ConfigChange">Possible</Item>
                <Item Key="ACLDeploy">1</Item>
                <Item Key="ACLValidID">1</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="Ticket::EventModulePost###9700-SetDynamicFieldCriticalityFromService" Required="0" Valid="0">
        <Description Translatable="1">Event module registration. Currently, the criticality of the service can also be set in the service, but this has no effect. Therefore, this event module has been implemented that automatically updates the DynamicField Criticality in a ticket as soon as a service has been assigned. Please activate the SysConfig option SetPriorityFromCriticalityAndImpactMatrix to set the priority in the next step based an Criticality and Impact.</Description>
        <Navigation>Core::Event::Ticket</Navigation>
        <Value>
            <Hash>
                <Item Key="Module">Kernel::System::Ticket::Event::SetDynamicFieldCriticalityFromService</Item>
                <Item Key="Transaction">1</Item>
                <Item Key="Event">TicketServiceUpdate|TicketCreate</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="Ticket::EventModulePost###9800-SetPriorityFromCriticalityAndImpactMatrix" Required="0" Valid="0">
        <Description Translatable="1">Event module registration. Currently, the criticality of the service can also be set in the service, but this has no effect. Therefore, this event module has been implemented that automatically updates the priority regarding Criticality and Impact in a ticket.</Description>
        <Navigation>Core::Event::Ticket</Navigation>
        <Value>
            <Hash>
                <Item Key="Module">Kernel::System::Ticket::Event::SetPriorityFromCriticalityAndImpactMatrix</Item>
                <Item Key="Transaction">1</Item>
                <Item Key="Event">TicketDynamicFieldUpdate_ITSMCriticality|TicketDynamicFieldUpdate_ITSMImpact</Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="Loader::Module::AgentITSMServiceZoom###002-ServiceCatalog" Required="0" Valid="1">
        <Description Translatable="1">Loader module registration for the agent interface.</Description>
        <Navigation>Frontend::Agent::ModuleRegistration::Loader</Navigation>
        <Value>
            <Hash>
                <Item Key="CSS">
                    <Array>
                    </Array>
                </Item>
                <Item Key="JavaScript">
                    <Array>
                        <Item>Core.Agent.ITSMServiceZoom.js</Item>
                    </Array>
                </Item>
            </Hash>
        </Value>
    </Setting>
    <Setting Name="AutoloadPerlPackages###002-ServiceImportExport" Required="0" Valid="1">
        <Description Translatable="1">Autoload configuration for Service import and export functions.</Description>
        <Navigation>Core::Autoload</Navigation>
        <Value>
            <Array>
                <Item ValueType="String">Kernel::Autoload::ServiceImportExport</Item>
            </Array>
        </Value>
    </Setting>
    <Setting Name="AutoloadPerlPackages###002-SLAImportExport" Required="0" Valid="1">
        <Description Translatable="1">Autoload configuration for SLA import and export functions.</Description>
        <Navigation>Core::Autoload</Navigation>
        <Value>
            <Array>
                <Item ValueType="String">Kernel::Autoload::SLAImportExport</Item>
            </Array>
        </Value>
    </Setting>
</otobo_config>
 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

package Kernel::Language::de_ServiceCatalog;

use strict;
use warnings;
use utf8;

sub Data {
    my $Self = shift;

    # Template: AdminSLAImportExport
    $Self->{Translation}->{'Here you can export a configuration file of SLAs to import these on another system. The configuration file is exported in yml format.'} =
        'Hier kann eine SLA-Konfigurationsdatei exportiert werden, die auf einem anderen System importiert werden kann. Die Konfigurationsdatei ist im YML-Format.';
    $Self->{Translation}->{'SLAs List'} = 'SLA-Liste';

    # Template: AdminServiceImportExport
    $Self->{Translation}->{'Here you can export a configuration file of services to import these on another system. The configuration file is exported in yml format.'} =
        'Hier kann eine Service-Konfigurationsdatei exportiert werden, die auf einem anderen System importiert werden kann. Die Konfigurationsdatei ist im YML-Format.';
    $Self->{Translation}->{'Services List'} = 'Service-Liste';

    # Template: TileServiceCatalog
    $Self->{Translation}->{'Show details of this service.'} = 'Zeige die Details von diesem Service.';

    # Template: AdminSLA
    $Self->{Translation}->{'Here you can upload a configuration file to import SLAs to your system. The file needs to be in .yml format as exported by SLA management module.'} =
        'Hier kann eine Konfigurationsdatei hochgeladen werden, um SLAs in das System zu importieren. Diese Datei muss im YML-Format sein, so wie sie durch das SLA-Verwaltungsmodul exportiert wird.';
    $Self->{Translation}->{'SLAs Import'} = 'SLAs importieren';
    $Self->{Translation}->{'SLAs Export'} = 'SLAs exportieren';
    $Self->{Translation}->{'Minimum Time Between Incidents'} = '';

    # Template: AdminService
    $Self->{Translation}->{'Here you can upload a configuration file to import services to your system. The file needs to be in .yml format as exported by the service management module.'} =
        '';
    $Self->{Translation}->{'Services Import'} = 'Services importieren';
    $Self->{Translation}->{'Services Export'} = 'Services exportieren';
    $Self->{Translation}->{'Criticality'} = 'Kritikalität';
    $Self->{Translation}->{'Service depends on the following ticket types'} = 'Der Service wird für folgende Ticket-Typen angezeigt';
    $Self->{Translation}->{'Ticket destination queue'} = 'Ticket Ziel-Queue';
    $Self->{Translation}->{'Customer default service'} = 'Service für alle Kunden anzeigen';
    $Self->{Translation}->{'Keywords'} = 'Schlüsselwörter';
    $Self->{Translation}->{'Service Description'} = 'Service-Beschreibung';
    $Self->{Translation}->{'This language is not present or enabled on the system. This service description could be deleted if it is not needed anymore.'} =
        'Diese Sprache ist nicht verfügbar oder auf dem System aktiviert. Die Service-Beschreibung kann gelöscht werden, sofern sie nicht mehr benötigt wird.';
    $Self->{Translation}->{'Remove Service Description Language'} = 'Sprache der Service-Beschreibung entfernen';
    $Self->{Translation}->{'Add new service description language'} = 'Neue Sprache der Service-Beschreibung hinzufügen';
    $Self->{Translation}->{'Option Reference'} = 'Konfigurationsreferenz';
    $Self->{Translation}->{'You can use the following options'} = 'Die folgenden Optionen können verwendet werden';
    $Self->{Translation}->{'Within the ServiceCatalogue tile in the customer dashboard, it is possible to show ticket types for preconfigured ticket creation inside the service description. Furthermore, it is possible to restrict the services for other screens using the ticket types set here. If you wish to do this, please activate the options "ServiceCatalog::CreateTypeServiceRelatedAcls" and "ServiceCatalog::CreateTypeServiceRelatedAcls::Options" in the OTOBO system configuration. The restriction is made via automatically generated ACLs, which can be viewed under "Admin -> Access Control Lists (ACL)". If necessary, please adjust the option "ServiceCatalog::CreateTypeServiceRelatedAcls::Options" according to your requirements.'} =
        'Innerhalb der Servicekatalog-Kachel im Kunden-Dashboard ist es möglich, Tickettypen in der Service-Beschreibung für eine vorkonfigurierte Ticketerstellung anzuzeigen. Weiterhin ist es möglich, die Services für andere Oberflächen einzuschränken, auf Grundlage der hier verwendeten Tickettypen. Ist dieses verhalten gewünscht, bitte die Einstellungen "ServiceCatalog::CreateTypeServiceRelatedAcls" und "ServiceCatalog::CreateTypeServiceRelatedAcls::Options" in der OTOBO Systemkonfiguration aktivieren. Diese Einschränkung wird über automatisch erstellte ACLs umgesetzt, die unter "Admin -> Access Control Lists (ACL)" angesehen werden können. Sofern nötig, bitte die Einstellung "ServiceCatalog::CreateTypeServiceRelatedAcls::Options" an die Anforderungen anpassen.';
    $Self->{Translation}->{'If we work service-based, we do not want to offer the customer a choice of queues in the customer portal when creating a ticket, but decide on the basis of the service into which queue (or which team of agents) the ticket should be processed first. In order to use this option sensibly, please deactivate the option "Ticket::Frontend::CustomerTicketMessage###Queue" and set a sensible default queue in the option "Ticket::Frontend::CustomerTicketMessage###QueueDefault". As soon as you set a "Ticket destination queue" here in the service, the ticket will immediately be created in this queue. If the field remains empty, the default queue configured above will be used.'} =
        'Sofern Serivce-basiert gearbeitet wird, soll dem Kunden im Kundenportal während der Ticketerstellung zwar eine Auswahl der Queues angezeigt werden, jedoch soll die Entscheidung , in welcher Queue (oder welchem Agenten-Team) das Ticket zunächst bearbeitet werden soll, auf Basis des Service getroffen werden. Um diese Option vernünftig zu verwenden, sollte die Einstellung "Ticket::Frontend::CustomerTicketMessage###Queue" deaktiviert werden und eine sinnvolle Standard-Queue in der Einstellung "Ticket::Frontend::CustomerTicketMessage###QueueDefault" gesetzt werden. Sobald hier im Service eine "Ticket Ziel-Queue" eingestellt wurde, wird das Ticket unmittelbar in dieser Queue erstellt. Sofern das Feld leer bleibt, wird die oben gesetzte Default-Queue verwendet.';
    $Self->{Translation}->{'If you do not assign services to customers or companies individually, but all services are initially offered to your customers for selection, the step of releasing each service as a "default" service under "Admin -> Customer user <-> Service" (or "Customer <-> Service") can be bypassed here. Of course, in the next step it is possible to restrict the services via ACLs.'} =
        'Sofern den Kundenbenutzern oder Kunden (Firmen) keine Services individuell zugeordnet werden, aber alle Services den Kunden zur Auswahl angeboten werden, kann der Schritte alle Services als "Standard"-Service unter "Admin -> Kundenbenutzer <-> Service" (bzw. "Admin -> Kunde <-> Service") hier umgangen werden. Natürlich ist es im nächsten Schritt möglich, die Services via ACLs einzuschränken.';
    $Self->{Translation}->{'Here, there is the possibility to automatically calculate the correct ticket priority in the background based on the dynamic field "ITSMCriticality" and "ITSMImpact". Please activate the option "Ticket::EventModulePost###9700-SetDynamicFieldCriticalityFromService" and the option "Ticket::EventModulePost###9800-SetPriorityFromCriticalityAndImpactMatrix". In the next step, you have the possibility using "Admin -> Criticality ↔ Impact ↔ Priority" to set the priority using a matrix.'} =
        'Hier gibt es die Möglichkeit, die korrekte Ticket-Priorität basierend auf den Dynamischen Feldern "ITSMCriticality" und "ITSMImpact" im Hintergrund zu berechnen. Hierfür bitte die Einstellung"Ticket::EventModulePost###9700-SetDynamicFieldCriticalityFromService" und die Einstellung "Ticket::EventModulePost###9800-SetPriorityFromCriticalityAndImpactMatrix" aktivieren. Im nächsten Schritt gibt es die Möglichkeit die Priorität in einer Matrix unter "Admin -> Kritikalität ↔ Auswirkung ↔ Priorität" zu setzen.';
    $Self->{Translation}->{'Keywords to facilitate the search for services within the service catalog.'} =
        'Schlüsselwörter um die Suche nach Services innerhalb des Servicekatalogs zu erleichtern.';
    $Self->{Translation}->{'Service descriptions (short & long) specified by User Language.'} =
        'Service-Beschreibung (kurz und lang), festgelegt durch die Anwendersprache.';
    $Self->{Translation}->{'Short summary of the service, mainly used in the CustomerDashboard.'} =
        'Kurzbeschreibung des Service, vor allem verwendet im Dialog CustomerDashboard.';
    $Self->{Translation}->{'Description of the service. Screenshots and tables are also allowed. Please ensure the correct width of the image for screenshots. This can be adjusted in the ckeditor after uploading the screenshot. A width of 600px has proven to be useful or you can configure a "max-width" of 95% under Advanced.'} =
        'Beschreibung des Service. Screenshots und Tabellen sind auch erlaubt. Bitte sicherstellen, dass die korrekte Bildbreite für Screenshots verwendet wird.  Diese kann nach dem Hochladen des Screenshots im Editor angepasst werden. Eine Breite von 600px wurde als sinnvoll erachtet. Alternativ kann unter "Erweitert" eine Maximalbreite von 95% konfiguriert werden.';
    $Self->{Translation}->{'Add more service catalog fields'} = 'Weitere Servicekatalog-Felder hinzufügen';
    $Self->{Translation}->{'You have the option of adding further fields here in the service catalog at any time. To do this, please go to "Admin -> DynamicFields" and create the new field of the object type "Service". You can then activate the field for the customer dashboard under "Admin -> DynamicField Screens" by assigning it under "CustomerDashboardTile ServiceCatalog".'} =
        '';

    # Template: AgentITSMSLAZoom
    $Self->{Translation}->{'SLA Information'} = 'SLA-Informationen';
    $Self->{Translation}->{'Last changed'} = 'Zuletzt geändert';
    $Self->{Translation}->{'Last changed by'} = 'Zuletzt geändert von';
    $Self->{Translation}->{'Associated Services'} = 'Zugehörige Services';

    # Template: AgentITSMServiceZoom
    $Self->{Translation}->{'Service Information'} = 'Service-Informationen';
    $Self->{Translation}->{'Current incident state'} = 'Aktueller Vorfallstatus';
    $Self->{Translation}->{'Associated SLAs'} = 'Zugehörige SLAs';

    # JS Template: TileServiceCatalogContainer
    $Self->{Translation}->{'Create a new ticket for this service.'} = 'Neues Ticket für diesen Service hinzufügen.';
    $Self->{Translation}->{'Create %s'} = '%s erstellen';
    $Self->{Translation}->{'Show %s sub-service(s)'} = 'Zeige %s Unter-Service(s)';
    $Self->{Translation}->{'More details'} = 'Weitere Details';
    $Self->{Translation}->{'Sub-Service(s)'} = 'Unter-Service(s)';

    # JS Template: TileServiceCatalogDetailed
    $Self->{Translation}->{'sub-service(s) available'} = 'verfügbare(r) Unterservice(s)';
    $Self->{Translation}->{'Create a new ticket of type %s.'} = 'Ein neues Ticket vom Typ %s erstellen.';
    $Self->{Translation}->{'FAQ article on this topic'} = 'FAQ-Artikel zu diesem Thema';
    $Self->{Translation}->{'Additional information'} = 'Zusätzliche Informationen';
    $Self->{Translation}->{'Service hours'} = 'Service-Zeiten';
    $Self->{Translation}->{'o\'clock'} = 'Uhr';
    $Self->{Translation}->{'No additional data are available.'} = 'Es sind keine weiteren Daten verfügbar.';
    $Self->{Translation}->{'Further information'} = 'Weitere Informationen';

    # JS Template: TileServiceCatalogModal
    $Self->{Translation}->{'Search catalog'} = 'Suchkatalog';

    # Perl Module: Kernel/Modules/CustomerTileServiceCatalog.pm
    $Self->{Translation}->{'Description not available.'} = 'Beschreibung nicht verfügbar.';
    $Self->{Translation}->{'Need FileID!'} = 'Benötige FileID!';

    # Perl Module: Kernel/Modules/AgentITSMServiceZoom.pm
    $Self->{Translation}->{'No ServiceID is given!'} = 'Keine ServiceID vorhanden!';
    $Self->{Translation}->{'ServiceID %s not found in database!'} = 'ServiceID %s nicht in Datenbank gefunden!';
    $Self->{Translation}->{'operational'} = 'operativ';
    $Self->{Translation}->{'warning'} = 'Warnung';
    $Self->{Translation}->{'incident'} = 'Vorfall';

    # JS File: Core.Agent.Admin.Service
    $Self->{Translation}->{'Do you really want to delete this service description language?'} =
        'Soll diese Sprache der Service-Beschreibung wirklich gelöscht werden?';

    # JS File: Core.Customer.TileServiceCatalog
    $Self->{Translation}->{'Results for %s'} = 'Ergebnisse für %s';

    # SysConfig
    $Self->{Translation}->{'Additional settings for the service catalog.'} = 'Zusätzliche Einstellungen für den Servicekatalog.';
    $Self->{Translation}->{'Autoload configuration for SLA import and export functions.'} = '';
    $Self->{Translation}->{'Autoload configuration for Service import and export functions.'} =
        '';
    $Self->{Translation}->{'CustomerTileServiceCatalog AJAX Module.'} = 'CustomerTileServiceCatalog AJAX Modul.';
    $Self->{Translation}->{'Define a list of dynamic field object types which are allowed to be assigned to actions of this package via the dynamic field screens interface.'} =
        '';
    $Self->{Translation}->{'Dynamic fields shown in the service catalog screen of the customer interface.'} =
        'Dynamische Felder, die in der Servicekatalog-Oberfläche des Kundenbereichs angezeigt werden.';
    $Self->{Translation}->{'Event module registration. Currently, the criticality of the service can also be set in the service, but this has no effect. Therefore, this event module has been implemented that automatically updates the DynamicField Criticality in a ticket as soon as a service has been assigned. Please activate the SysConfig option SetPriorityFromCriticalityAndImpactMatrix to set the priority in the next step based an Criticality and Impact.'} =
        'Event-Modulregistrierung. Momentan kann die Kritikalität des Service auch im Service festgelegt werden, hat allerdings keine Wirkung. Daher wurde dieses Event-Modul implementiert, das automatisch das Dynamische Feld Kritikalität in einem Ticket aktualisiert, sobald ein Service zugeordnet wurde. Bitte die Systemkonfigurations-Einstellung "SetPriorityFromCriticalityAndImpactMatrix" aktivieren, um die Priorität auf Basis der Kritikalität und die Auswirkung im nächsten Schritt zu setzen.';
    $Self->{Translation}->{'Event module registration. Currently, the criticality of the service can also be set in the service, but this has no effect. Therefore, this event module has been implemented that automatically updates the priority regarding Criticality and Impact in a ticket.'} =
        'Event-Modulregistrierung. Momentan kann die Kritikalität des Service auch im Service festgelegt werden, hat allerdings keine Wirkung. Daher wurde dieses Event-Modul implementiert, das automatisch die Priorität und die Auswirkung in einem Ticket aktualisiert.';
    $Self->{Translation}->{'Show services with the following ticket type last.'} = 'Services mit dem folgenden Tickettypen zuletzt anzeigen.';
    $Self->{Translation}->{'The FAQ field that should be used as the description of an FAQ article in the sidebar (e.g. Field1, Field2, Field3...).'} =
        'Das FAQ-Feld, welches in der Beschreibung eines FAQ-Artikel in der Seitenleiste angezeigt werden soll (z.B. Field1, Field2, Field3, ...).';
    $Self->{Translation}->{'This option allows you to automatically generate ACLs for different interfaces when creating services. Services will then only be displayed if the ticket type stored in the service has been selected. The "AddBulkACL" console script can also be used to create ACLs for services that have already been create.'} =
        'Diese Option ermöglicht es, dass bei der Service-Erstellung automatisch ACLs für verschiedene Oberflächen generiert werden. Services werden dann nur angezeigt, sobald der im Service gespeicherte Tickettyp ausgewählt wurde. Das Konsolenskript "AddBulkACL" kann auch für die ACL-Erstellung für die Services verwendet werden, die bereits vor dieser Aktivierung erstellt wurden.';
    $Self->{Translation}->{'This option makes it possible to preconfigure the automatically generated ACLs. The aim is to only display the services that have also been assigned to the service in the service catalog. To use this function, please first enable the "ServiceCatalog::CreateTypeServiceRelatedAcls" option. "GenerateInitalACLToDisableAllServices" generates an ACL that initially hides all services. The value "Possible" or "PossibleAdd" can be set for the key "ConfigChange". The "DeployNewACL" key decides whether the changed ACL should also be deployed immediately. "ACLValidID" (1, 2, 3) sets the ACLs to valid, invalid or temporarily invalid.'} =
        'Diese Option ermöglicht es, die automatisch generierten ACLs vorzukonfigurieren. Das Ziel ist es, nur die Services einzublenden, die auch im Servicekatalog zugeordnet wurden. Um diese Funktion zu verwenden, muss zunächst die Einstellung "ServiceCatalog::CreateTypeServiceRelatedAcls" aktiviert werden. "GenerateInitalACLToDisableAllServices" erzeugt eine ACL, die initial alle Services ausblendet. Die Werte "Possible" (exklusiv einblenden) oder "PossibleAdd" (zusätzlich einblenden) können für den Schlüssel "ConfigChange" eingestellt werden. Der Schlüssel "DeployNewACL" entscheidet, ob die geänderte ACL sofort in Betrieb genommen werden soll. Die "ACLValidID" (1, 2, 3) setzt die Gültigkeit der ACL auf "gültig", "ungültig" oder "ungültig temporär".';
    $Self->{Translation}->{'Tile registration for the CustomerDashboard. Module is required.'} =
        '';


    push @{ $Self->{JavaScriptStrings} // [] }, (
    'Additional information',
    'All',
    'Close this dialog',
    'Create %s',
    'Create Ticket',
    'Create a new ticket for this service.',
    'Create a new ticket of type %s.',
    'Details',
    'Do you really want to delete this service description language?',
    'FAQ article on this topic',
    'First Response Time',
    'Further information',
    'More details',
    'No additional data are available.',
    'OK',
    'Results',
    'Results for %s',
    'Search',
    'Search catalog',
    'Service Information',
    'Service hours',
    'Show %s sub-service(s)',
    'Show details of this service.',
    'Show or hide the content',
    'Solution Time',
    'Sub-Service(s)',
    'hour(s)',
    'o\'clock',
    'sub-service(s) available',
    );

}

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

package Kernel::Language::es_ServiceCatalog;

use strict;
use warnings;
use utf8;

sub Data {
    my $Self = shift;

    # Template: AdminSLAImportExport
    $Self->{Translation}->{'Here you can export a configuration file of SLAs to import these on another system. The configuration file is exported in yml format.'} =
        '';
    $Self->{Translation}->{'SLAs List'} = '';

    # Template: AdminServiceImportExport
    $Self->{Translation}->{'Here you can export a configuration file of services to import these on another system. The configuration file is exported in yml format.'} =
        '';
    $Self->{Translation}->{'Services List'} = '';

    # Template: TileServiceCatalog
    $Self->{Translation}->{'Show details of this service.'} = '';

    # Template: AdminSLA
    $Self->{Translation}->{'Here you can upload a configuration file to import SLAs to your system. The file needs to be in .yml format as exported by SLA management module.'} =
        '';
    $Self->{Translation}->{'SLAs Import'} = '';
    $Self->{Translation}->{'SLAs Export'} = '';
    $Self->{Translation}->{'Minimum Time Between Incidents'} = '';

    # Template: AdminService
    $Self->{Translation}->{'Here you can upload a configuration file to import services to your system. The file needs to be in .yml format as exported by the service management module.'} =
        '';
    $Self->{Translation}->{'Services Import'} = '';
    $Self->{Translation}->{'Services Export'} = '';
    $Self->{Translation}->{'Criticality'} = '';
    $Self->{Translation}->{'Service depends on the following ticket types'} = '';
    $Self->{Translation}->{'Ticket destination queue'} = '';
    $Self->{Translation}->{'Customer default service'} = '';
    $Self->{Translation}->{'Keywords'} = '';
    $Self->{Translation}->{'Service Description'} = '';
    $Self->{Translation}->{'This language is not present or enabled on the system. This service description could be deleted if it is not needed anymore.'} =
        '';
    $Self->{Translation}->{'Remove Service Description Language'} = '';
    $Self->{Translation}->{'Add new service description language'} = '';
    $Self->{Translation}->{'Option Reference'} = '';
    $Self->{Translation}->{'You can use the following options'} = '';
    $Self->{Translation}->{'Within the ServiceCatalogue tile in the customer dashboard, it is possible to show ticket types for preconfigured ticket creation inside the service description. Furthermore, it is possible to restrict the services for other screens using the ticket types set here. If you wish to do this, please activate the options "ServiceCatalog::CreateTypeServiceRelatedAcls" and "ServiceCatalog::CreateTypeServiceRelatedAcls::Options" in the OTOBO system configuration. The restriction is made via automatically generated ACLs, which can be viewed under "Admin -> Access Control Lists (ACL)". If necessary, please adjust the option "ServiceCatalog::CreateTypeServiceRelatedAcls::Options" according to your requirements.'} =
        '';
    $Self->{Translation}->{'If we work service-based, we do not want to offer the customer a choice of queues in the customer portal when creating a ticket, but decide on the basis of the service into which queue (or which team of agents) the ticket should be processed first. In order to use this option sensibly, please deactivate the option "Ticket::Frontend::CustomerTicketMessage###Queue" and set a sensible default queue in the option "Ticket::Frontend::CustomerTicketMessage###QueueDefault". As soon as you set a "Ticket destination queue" here in the service, the ticket will immediately be created in this queue. If the field remains empty, the default queue configured above will be used.'} =
        '';
    $Self->{Translation}->{'If you do not assign services to customers or companies individually, but all services are initially offered to your customers for selection, the step of releasing each service as a "default" service under "Admin -> Customer user <-> Service" (or "Customer <-> Service") can be bypassed here. Of course, in the next step it is possible to restrict the services via ACLs.'} =
        '';
    $Self->{Translation}->{'Here, there is the possibility to automatically calculate the correct ticket priority in the background based on the dynamic field "ITSMCriticality" and "ITSMImpact". Please activate the option "Ticket::EventModulePost###9700-SetDynamicFieldCriticalityFromService" and the option "Ticket::EventModulePost###9800-SetPriorityFromCriticalityAndImpactMatrix". In the next step, you have the possibility using "Admin -> Criticality ↔ Impact ↔ Priority" to set the priority using a matrix.'} =
        '';
    $Self->{Translation}->{'Keywords to facilitate the search for services within the service catalog.'} =
        '';
    $Self->{Translation}->{'Service descriptions (short & long) specified by User Language.'} =
        '';
    $Self->{Translation}->{'Short summary of the service, mainly used in the CustomerDashboard.'} =
        '';
    $Self->{Translation}->{'Description of the service. Screenshots and tables are also allowed. Please ensure the correct width of the image for screenshots. This can be adjusted in the ckeditor after uploading the screenshot. A width of 600px has proven to be useful or you can configure a "max-width" of 95% under Advanced.'} =
        '';
    $Self->{Translation}->{'Add more service catalog fields'} = '';
    $Self->{Translation}->{'You have the option of adding further fields here in the service catalog at any time. To do this, please go to "Admin -> DynamicFields" and create the new field of the object type "Service". You can then activate the field for the customer dashboard under "Admin -> DynamicField Screens" by assigning it under "CustomerDashboardTile ServiceCatalog".'} =
        '';

    # Template: AgentITSMSLAZoom
    $Self->{Translation}->{'SLA Information'} = '';
    $Self->{Translation}->{'Last changed'} = '';
    $Self->{Translation}->{'Last changed by'} = '';
    $Self->{Translation}->{'Associated Services'} = '';

    # Template: AgentITSMServiceZoom
    $Self->{Translation}->{'Service Information'} = '';
    $Self->{Translation}->{'Current incident state'} = '';
    $Self->{Translation}->{'Associated SLAs'} = '';

    # JS Template: TileServiceCatalogContainer
    $Self->{Translation}->{'Create a new ticket for this service.'} = '';
    $Self->{Translation}->{'Create %s'} = '';
    $Self->{Translation}->{'Show %s sub-service(s)'} = '';
    $Self->{Translation}->{'More details'} = '';
    $Self->{Translation}->{'Sub-Service(s)'} = '';

    # JS Template: TileServiceCatalogDetailed
    $Self->{Translation}->{'sub-service(s) available'} = '';
    $Self->{Translation}->{'Create a new ticket of type %s.'} = '';
    $Self->{Translation}->{'FAQ article on this topic'} = '';
    $Self->{Translation}->{'Additional information'} = '';
    $Self->{Translation}->{'Service hours'} = '';
    $Self->{Translation}->{'o\'clock'} = '';
    $Self->{Translation}->{'No additional data are available.'} = '';
    $Self->{Translation}->{'Further information'} = '';

    # JS Template: TileServiceCatalogModal
    $Self->{Translation}->{'Search catalog'} = '';

    # Perl Module: Kernel/Modules/CustomerTileServiceCatalog.pm
    $Self->{Translation}->{'Description not available.'} = '';
    $Self->{Translation}->{'Need FileID!'} = '';

    # Perl Module: Kernel/Modules/AgentITSMServiceZoom.pm
    $Self->{Translation}->{'No ServiceID is given!'} = '';
    $Self->{Translation}->{'ServiceID %s not found in database!'} = '';
    $Self->{Translation}->{'operational'} = '';
    $Self->{Translation}->{'warning'} = '';
    $Self->{Translation}->{'incident'} = '';

    # JS File: Core.Agent.Admin.Service
    $Self->{Translation}->{'Do you really want to delete this service description language?'} =
        '';

    # JS File: Core.Customer.TileServiceCatalog
    $Self->{Translation}->{'Results for %s'} = '';

    # SysConfig
    $Self->{Translation}->{'Additional settings for the service catalog.'} = '';
    $Self->{Translation}->{'Autoload configuration for SLA import and export functions.'} = '';
    $Self->{Translation}->{'Autoload configuration for Service import and export functions.'} =
        '';
    $Self->{Translation}->{'CustomerTileServiceCatalog AJAX Module.'} = '';
    $Self->{Translation}->{'Define a list of dynamic field object types which are allowed to be assigned to actions of this package via the dynamic field screens interface.'} =
        '';
    $Self->{Translation}->{'Dynamic fields shown in the service catalog screen of the customer interface.'} =
        '';
    $Self->{Translation}->{'Event module registration. Currently, the criticality of the service can also be set in the service, but this has no effect. Therefore, this event module has been implemented that automatically updates the DynamicField Criticality in a ticket as soon as a service has been assigned. Please activate the SysConfig option SetPriorityFromCriticalityAndImpactMatrix to set the priority in the next step based an Criticality and Impact.'} =
        '';
    $Self->{Translation}->{'Event module registration. Currently, the criticality of the service can also be set in the service, but this has no effect. Therefore, this event module has been implemented that automatically updates the priority regarding Criticality and Impact in a ticket.'} =
        '';
    $Self->{Translation}->{'Show services with the following ticket type last.'} = '';
    $Self->{Translation}->{'The FAQ field that should be used as the description of an FAQ article in the sidebar (e.g. Field1, Field2, Field3...).'} =
        '';
    $Self->{Translation}->{'This option allows you to automatically generate ACLs for different interfaces when creating services. Services will then only be displayed if the ticket type stored in the service has been selected. The "AddBulkACL" console script can also be used to create ACLs for services that have already been create.'} =
        '';
    $Self->{Translation}->{'This option makes it possible to preconfigure the automatically generated ACLs. The aim is to only display the services that have also been assigned to the service in the service catalog. To use this function, please first enable the "ServiceCatalog::CreateTypeServiceRelatedAcls" option. "GenerateInitalACLToDisableAllServices" generates an ACL that initially hides all services. The value "Possible" or "PossibleAdd" can be set for the key "ConfigChange". The "DeployNewACL" key decides whether the changed ACL should also be deployed immediately. "ACLValidID" (1, 2, 3) sets the ACLs to valid, invalid or temporarily invalid.'} =
        '';
    $Self->{Translation}->{'Tile registration for the CustomerDashboard. Module is required.'} =
        '';


    push @{ $Self->{JavaScriptStrings} // [] }, (
    'Additional information',
    'All',
    'Close this dialog',
    'Create %s',
    'Create Ticket',
    'Create a new ticket for this service.',
    'Create a new ticket of type %s.',
    'Details',
    'Do you really want to delete this service description language?',
    'FAQ article on this topic',
    'First Response Time',
    'Further information',
    'More details',
    'No additional data are available.',
    'OK',
    'Results',
    'Results for %s',
    'Search',
    'Search catalog',
    'Service Information',
    'Service hours',
    'Show %s sub-service(s)',
    'Show details of this service.',
    'Show or hide the content',
    'Solution Time',
    'Sub-Service(s)',
    'hour(s)',
    'o\'clock',
    'sub-service(s) available',
    );

}

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

package Kernel::Language::es_CO_ServiceCatalog;

use strict;
use warnings;
use utf8;

sub Data {
    my $Self = shift;

    # Template: AdminSLAImportExport
    $Self->{Translation}->{'Here you can export a configuration file of SLAs to import these on another system. The configuration file is exported in yml format.'} =
        '';
    $Self->{Translation}->{'SLAs List'} = '';

    # Template: AdminServiceImportExport
    $Self->{Translation}->{'Here you can export a configuration file of services to import these on another system. The configuration file is exported in yml format.'} =
        '';
    $Self->{Translation}->{'Services List'} = '';

    # Template: TileServiceCatalog
    $Self->{Translation}->{'Show details of this service.'} = '';

    # Template: AdminSLA
    $Self->{Translation}->{'Here you can upload a configuration file to import SLAs to your system. The file needs to be in .yml format as exported by SLA management module.'} =
        '';
    $Self->{Translation}->{'SLAs Import'} = '';
    $Self->{Translation}->{'SLAs Export'} = '';
    $Self->{Translation}->{'Minimum Time Between Incidents'} = '';

    # Template: AdminService
    $Self->{Translation}->{'Here you can upload a configuration file to import services to your system. The file needs to be in .yml format as exported by the service management module.'} =
        '';
    $Self->{Translation}->{'Services Import'} = '';
    $Self->{Translation}->{'Services Export'} = '';
    $Self->{Translation}->{'Criticality'} = '';
    $Self->{Translation}->{'Service depends on the following ticket types'} = '';
    $Self->{Translation}->{'Ticket destination queue'} = '';
    $Self->{Translation}->{'Customer default service'} = '';
    $Self->{Translation}->{'Keywords'} = '';
    $Self->{Translation}->{'Service Description'} = '';
    $Self->{Translation}->{'This language is not present or enabled on the system. This service description could be deleted if it is not needed anymore.'} =
        '';
    $Self->{Translation}->{'Remove Service Description Language'} = '';
    $Self->{Translation}->{'Add new service description language'} = '';
    $Self->{Translation}->{'Option Reference'} = '';
    $Self->{Translation}->{'You can use the following options'} = '';
    $Self->{Translation}->{'Within the ServiceCatalogue tile in the customer dashboard, it is possible to show ticket types for preconfigured ticket creation inside the service description. Furthermore, it is possible to restrict the services for other screens using the ticket types set here. If you wish to do this, please activate the options "ServiceCatalog::CreateTypeServiceRelatedAcls" and "ServiceCatalog::CreateTypeServiceRelatedAcls::Options" in the OTOBO system configuration. The restriction is made via automatically generated ACLs, which can be viewed under "Admin -> Access Control Lists (ACL)". If necessary, please adjust the option "ServiceCatalog::CreateTypeServiceRelatedAcls::Options" according to your requirements.'} =
        '';
    $Self->{Translation}->{'If we work service-based, we do not want to offer the customer a choice of queues in the customer portal when creating a ticket, but decide on the basis of the service into which queue (or which team of agents) the ticket should be processed first. In order to use this option sensibly, please deactivate the option "Ticket::Frontend::CustomerTicketMessage###Queue" and set a sensible default queue in the option "Ticket::Frontend::CustomerTicketMessage###QueueDefault". As soon as you set a "Ticket destination queue" here in the service, the ticket will immediately be created in this queue. If the field remains empty, the default queue configured above will be used.'} =
        '';
    $Self->{Translation}->{'If you do not assign services to customers or companies individually, but all services are initially offered to your customers for selection, the step of releasing each service as a "default" service under "Admin -> Customer user <-> Service" (or "Customer <-> Service") can be bypassed here. Of course, in the next step it is possible to restrict the services via ACLs.'} =
        '';
    $Self->{Translation}->{'Here, there is the possibility to automatically calculate the correct ticket priority in the background based on the dynamic field "ITSMCriticality" and "ITSMImpact". Please activate the option "Ticket::EventModulePost###9700-SetDynamicFieldCriticalityFromService" and the option "Ticket::EventModulePost###9800-SetPriorityFromCriticalityAndImpactMatrix". In the next step, you have the possibility using "Admin -> Criticality ↔ Impact ↔ Priority" to set the priority using a matrix.'} =
        '';
    $Self->{Translation}->{'Keywords to facilitate the search for services within the service catalog.'} =
        '';
    $Self->{Translation}->{'Service descriptions (short & long) specified by User Language.'} =
        '';
    $Self->{Translation}->{'Short summary of the service, mainly used in the CustomerDashboard.'} =
        '';
    $Self->{Translation}->{'Description of the service. Screenshots and tables are also allowed. Please ensure the correct width of the image for screenshots. This can be adjusted in the ckeditor after uploading the screenshot. A width of 600px has proven to be useful or you can configure a "max-width" of 95% under Advanced.'} =
        '';
    $Self->{Translation}->{'Add more service catalog fields'} = '';
    $Self->{Translation}->{'You have the option of adding further fields here in the service catalog at any time. To do this, please go to "Admin -> DynamicFields" and create the new field of the object type "Service". You can then activate the field for the customer dashboard under "Admin -> DynamicField Screens" by assigning it under "CustomerDashboardTile ServiceCatalog".'} =
        '';

    # Template: AgentITSMSLAZoom
    $Self->{Translation}->{'SLA Information'} = '';
    $Self->{Translation}->{'Last changed'} = '';
    $Self->{Translation}->{'Last changed by'} = '';
    $Self->{Translation}->{'Associated Services'} = '';

    # Template: AgentITSMServiceZoom
    $Self->{Translation}->{'Service Information'} = '';
    $Self->{Translation}->{'Current incident state'} = '';
    $Self->{Translation}->{'Associated SLAs'} = '';

    # JS Template: TileServiceCatalogContainer
    $Self->{Translation}->{'Create a new ticket for this service.'} = '';
    $Self->{Translation}->{'Create %s'} = '';
    $Self->{Translation}->{'Show %s sub-service(s)'} = '';
    $Self->{Translation}->{'More details'} = '';
    $Self->{Translation}->{'Sub-Service(s)'} = '';

    # JS Template: TileServiceCatalogDetailed
    $Self->{Translation}->{'sub-service(s) available'} = '';
    $Self->{Translation}->{'Create a new ticket of type %s.'} = '';
    $Self->{Translation}->{'FAQ article on this topic'} = '';
    $Self->{Translation}->{'Additional information'} = '';
    $Self->{Translation}->{'Service hours'} = '';
    $Self->{Translation}->{'o\'clock'} = '';
    $Self->{Translation}->{'No additional data are available.'} = '';
    $Self->{Translation}->{'Further information'} = '';

    # JS Template: TileServiceCatalogModal
    $Self->{Translation}->{'Search catalog'} = '';

    # Perl Module: Kernel/Modules/CustomerTileServiceCatalog.pm
    $Self->{Translation}->{'Description not available.'} = '';
    $Self->{Translation}->{'Need FileID!'} = '';

    # Perl Module: Kernel/Modules/AgentITSMServiceZoom.pm
    $Self->{Translation}->{'No ServiceID is given!'} = '';
    $Self->{Translation}->{'ServiceID %s not found in database!'} = '';
    $Self->{Translation}->{'operational'} = '';
    $Self->{Translation}->{'warning'} = '';
    $Self->{Translation}->{'incident'} = '';

    # JS File: Core.Agent.Admin.Service
    $Self->{Translation}->{'Do you really want to delete this service description language?'} =
        '';

    # JS File: Core.Customer.TileServiceCatalog
    $Self->{Translation}->{'Results for %s'} = '';

    # SysConfig
    $Self->{Translation}->{'Additional settings for the service catalog.'} = '';
    $Self->{Translation}->{'Autoload configuration for SLA import and export functions.'} = '';
    $Self->{Translation}->{'Autoload configuration for Service import and export functions.'} =
        '';
    $Self->{Translation}->{'CustomerTileServiceCatalog AJAX Module.'} = '';
    $Self->{Translation}->{'Define a list of dynamic field object types which are allowed to be assigned to actions of this package via the dynamic field screens interface.'} =
        '';
    $Self->{Translation}->{'Dynamic fields shown in the service catalog screen of the customer interface.'} =
        '';
    $Self->{Translation}->{'Event module registration. Currently, the criticality of the service can also be set in the service, but this has no effect. Therefore, this event module has been implemented that automatically updates the DynamicField Criticality in a ticket as soon as a service has been assigned. Please activate the SysConfig option SetPriorityFromCriticalityAndImpactMatrix to set the priority in the next step based an Criticality and Impact.'} =
        '';
    $Self->{Translation}->{'Event module registration. Currently, the criticality of the service can also be set in the service, but this has no effect. Therefore, this event module has been implemented that automatically updates the priority regarding Criticality and Impact in a ticket.'} =
        '';
    $Self->{Translation}->{'Show services with the following ticket type last.'} = '';
    $Self->{Translation}->{'The FAQ field that should be used as the description of an FAQ article in the sidebar (e.g. Field1, Field2, Field3...).'} =
        '';
    $Self->{Translation}->{'This option allows you to automatically generate ACLs for different interfaces when creating services. Services will then only be displayed if the ticket type stored in the service has been selected. The "AddBulkACL" console script can also be used to create ACLs for services that have already been create.'} =
        '';
    $Self->{Translation}->{'This option makes it possible to preconfigure the automatically generated ACLs. The aim is to only display the services that have also been assigned to the service in the service catalog. To use this function, please first enable the "ServiceCatalog::CreateTypeServiceRelatedAcls" option. "GenerateInitalACLToDisableAllServices" generates an ACL that initially hides all services. The value "Possible" or "PossibleAdd" can be set for the key "ConfigChange". The "DeployNewACL" key decides whether the changed ACL should also be deployed immediately. "ACLValidID" (1, 2, 3) sets the ACLs to valid, invalid or temporarily invalid.'} =
        '';
    $Self->{Translation}->{'Tile registration for the CustomerDashboard. Module is required.'} =
        '';


    push @{ $Self->{JavaScriptStrings} // [] }, (
    'Additional information',
    'All',
    'Close this dialog',
    'Create %s',
    'Create Ticket',
    'Create a new ticket for this service.',
    'Create a new ticket of type %s.',
    'Details',
    'Do you really want to delete this service description language?',
    'FAQ article on this topic',
    'First Response Time',
    'Further information',
    'More details',
    'No additional data are available.',
    'OK',
    'Results',
    'Results for %s',
    'Search',
    'Search catalog',
    'Service Information',
    'Service hours',
    'Show %s sub-service(s)',
    'Show details of this service.',
    'Show or hide the content',
    'Solution Time',
    'Sub-Service(s)',
    'hour(s)',
    'o\'clock',
    'sub-service(s) available',
    );

}

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

package Kernel::Language::hu_ServiceCatalog;

use strict;
use warnings;
use utf8;

sub Data {
    my $Self = shift;

    # Template: AdminSLAImportExport
    $Self->{Translation}->{'Here you can export a configuration file of SLAs to import these on another system. The configuration file is exported in yml format.'} =
        'Itt exportálhatja az SLA-k beállítófájlját, hogy azokat egy másik rendszerbe importálhassa. A beállítófájl YAML formátumban kerül exportálásra.';
    $Self->{Translation}->{'SLAs List'} = 'SLA-k listája';

    # Template: AdminServiceImportExport
    $Self->{Translation}->{'Here you can export a configuration file of services to import these on another system. The configuration file is exported in yml format.'} =
        'Itt exportálhatja a szolgáltatások beállítófájlját, hogy azokat egy másik rendszerbe importálhassa. A beállítófájl YAML formátumban kerül exportálásra.';
    $Self->{Translation}->{'Services List'} = 'Szolgáltatások listája';

    # Template: TileServiceCatalog
    $Self->{Translation}->{'Show details of this service.'} = 'A szolgáltatás részleteinek megjelenítése.';

    # Template: AdminSLA
    $Self->{Translation}->{'Here you can upload a configuration file to import SLAs to your system. The file needs to be in .yml format as exported by SLA management module.'} =
        'Itt tölthet fel egy beállítófájlt az SLA-k importálásához a rendszerre. A fájlnak .yml formátumban kell lennie, ahogy az SLA-kezelő modul exportálta.';
    $Self->{Translation}->{'SLAs Import'} = 'SLA-k importálása';
    $Self->{Translation}->{'SLAs Export'} = 'SLA-k exportálása';
    $Self->{Translation}->{'Minimum Time Between Incidents'} = 'Az incidensek közti legkisebb idő';

    # Template: AdminService
    $Self->{Translation}->{'Here you can upload a configuration file to import services to your system. The file needs to be in .yml format as exported by the service management module.'} =
        'Itt tölthet fel egy beállítófájlt a szolgáltatások importálásához a rendszerre. A fájlnak .yml formátumban kell lennie, ahogy a szolgáltatáskezelő modul exportálta.';
    $Self->{Translation}->{'Services Import'} = 'Szolgáltatások importálása';
    $Self->{Translation}->{'Services Export'} = 'Szolgáltatások exportálása';
    $Self->{Translation}->{'Criticality'} = 'Kritikusság';
    $Self->{Translation}->{'Service depends on the following ticket types'} = 'A szolgáltatás a következő jegytípusoktól függ';
    $Self->{Translation}->{'Ticket destination queue'} = 'Jegy célvárólistája';
    $Self->{Translation}->{'Customer default service'} = 'Ügyfél alapértelmezett szolgáltatása';
    $Self->{Translation}->{'Keywords'} = 'Kulcsszavak';
    $Self->{Translation}->{'Service Description'} = 'Szolgáltatás leírása';
    $Self->{Translation}->{'This language is not present or enabled on the system. This service description could be deleted if it is not needed anymore.'} =
        'Ez a nyelv nincs jelen vagy nincs engedélyezve a rendszeren. Ez a szolgáltatásleírás törölhető, ha többé nincs rá szükség.';
    $Self->{Translation}->{'Remove Service Description Language'} = 'Szolgáltatásleírás-nyelv eltávolítása';
    $Self->{Translation}->{'Add new service description language'} = 'Új szolgáltatásleírás-nyelv hozzáadása';
    $Self->{Translation}->{'Option Reference'} = 'Beállítások hivatkozása';
    $Self->{Translation}->{'You can use the following options'} = 'A következő beállításokat használhatja';
    $Self->{Translation}->{'Within the ServiceCatalogue tile in the customer dashboard, it is possible to show ticket types for preconfigured ticket creation inside the service description. Furthermore, it is possible to restrict the services for other screens using the ticket types set here. If you wish to do this, please activate the options "ServiceCatalog::CreateTypeServiceRelatedAcls" and "ServiceCatalog::CreateTypeServiceRelatedAcls::Options" in the OTOBO system configuration. The restriction is made via automatically generated ACLs, which can be viewed under "Admin -> Access Control Lists (ACL)". If necessary, please adjust the option "ServiceCatalog::CreateTypeServiceRelatedAcls::Options" according to your requirements.'} =
        'Az ügyfél vezérlőpultján lévő „ServiceCatalogue” csempén belül lehetőség van megjeleníteni a jegytípusokat az előre beállított jegylétrehozásához a szolgáltatás leírásán belül. Ezenfelül lehetőség van a szolgáltatások korlátozására más képernyőknél az itt beállított jegytípusok használatával. Ha ezt szeretné megtenni, akkor aktiválja a „ServiceCatalog::CreateTypeServiceRelatedAcls” és a „ServiceCatalog::CreateTypeServiceRelatedAcls::Options” beállításokat az OTOBO rendszerbeállításaiban. A korlátozás automatikusan előállított ACL-eken keresztül történik, amelyek az „Adminisztráció → Hozzáférés-vezérlési listák (ACL)” alatt tekinthetők meg. Ha szükséges, akkor állítsa be a „ServiceCatalog::CreateTypeServiceRelatedAcls::Options” beállítást az igényeinek megfelelően.';
    $Self->{Translation}->{'If we work service-based, we do not want to offer the customer a choice of queues in the customer portal when creating a ticket, but decide on the basis of the service into which queue (or which team of agents) the ticket should be processed first. In order to use this option sensibly, please deactivate the option "Ticket::Frontend::CustomerTicketMessage###Queue" and set a sensible default queue in the option "Ticket::Frontend::CustomerTicketMessage###QueueDefault". As soon as you set a "Ticket destination queue" here in the service, the ticket will immediately be created in this queue. If the field remains empty, the default queue configured above will be used.'} =
        'Ha szolgáltatásalapú rendszerben dolgozunk, akkor nem szeretnénk felajánlani az ügyfélnek a várólisták közötti választást az ügyfélportálon a jegy létrehozásakor, hanem a szolgáltatás alapján szeretnénk eldönteni, hogy melyik várólistába (vagy melyik ügyintézői csapatnak) kell elsőként feldolgozni a jegyet. Ahhoz, hogy ezt a lehetőséget észszerűen lehessen használni, kapcsolja ki a „Ticket::Frontend::CustomerTicketMessage###Queue” beállítást, és állítson be észszerű alapértelmezett várólistát a „Ticket::Frontend::CustomerTicketMessage###QueueDefault” beállításban. Amint itt a szolgáltatásban beállít egy „Jegy célvárólistája” értéket, a jegy azonnal ebben a várólistában lesz létrehozva. Ha a mező üres marad, akkor a fent beállított alapértelmezett várólista lesz használva.';
    $Self->{Translation}->{'If you do not assign services to customers or companies individually, but all services are initially offered to your customers for selection, the step of releasing each service as a "default" service under "Admin -> Customer user <-> Service" (or "Customer <-> Service") can be bypassed here. Of course, in the next step it is possible to restrict the services via ACLs.'} =
        'Ha nem rendel hozzá egyenként szolgáltatásokat az ügyfelekhez vagy a vállalatokhoz, hanem az összes szolgáltatást eleve felajánlja az ügyfeleinek választásra, akkor az „Adminisztráció → Ügyfél-felhasználó ↔ Szolgáltatás” (vagy „Ügyfél ↔ Szolgáltatás”) alatt az egyes szoláltatások „alapértelmezett” szolgáltatásként történő kiadásának lépése itt megkerülhető. Természetesen a következő lépésben lehetőség van a szolgáltatások ACL-eken keresztül történő korlátozására.';
    $Self->{Translation}->{'Here, there is the possibility to automatically calculate the correct ticket priority in the background based on the dynamic field "ITSMCriticality" and "ITSMImpact". Please activate the option "Ticket::EventModulePost###9700-SetDynamicFieldCriticalityFromService" and the option "Ticket::EventModulePost###9800-SetPriorityFromCriticalityAndImpactMatrix". In the next step, you have the possibility using "Admin -> Criticality ↔ Impact ↔ Priority" to set the priority using a matrix.'} =
        'Itt lehetőség van arra, hogy automatikusan kiszámítsa a megfelelő jegyprioritást a háttérben az „ITSMCriticality” és „ITSMImpact” dinamikus mezők alapján. Aktiválja a „Ticket::EventModulePost###9700-SetDynamicFieldCriticalityFromService” és a „Ticket::EventModulePost###9800-SetPriorityFromCriticalityAndImpactMatrix” beállításokat. A következő lépésben lehetősége van az „Adminisztráció → Kritikusság ↔ Hatás ↔ Prioritás” használatával egy mátrix segítségével beállítani a prioritást.';
    $Self->{Translation}->{'Keywords to facilitate the search for services within the service catalog.'} =
        'Kulcsszavak a szolgáltatások keresésének megkönnyítéséhez a szolgáltatáskatalóguson belül.';
    $Self->{Translation}->{'Service descriptions (short & long) specified by User Language.'} =
        'A felhasználó nyelve által megadott szolgáltatásleírások (rövid és hosszú).';
    $Self->{Translation}->{'Short summary of the service, mainly used in the CustomerDashboard.'} =
        'A szolgáltatás rövid összefoglalása, amely elsősorban az ügyfél vezérlőpultján van használva.';
    $Self->{Translation}->{'Description of the service. Screenshots and tables are also allowed. Please ensure the correct width of the image for screenshots. This can be adjusted in the ckeditor after uploading the screenshot. A width of 600px has proven to be useful or you can configure a "max-width" of 95% under Advanced.'} =
        'A szolgáltatás leírása. Képernyőképek és táblázatok is megengedettek. Győződjön meg arról, hogy a képek szélessége megfelelő legyen a képernyőképeknél. Ez a CKEditor szerkesztőben állítható be a képernyőkép feltöltése után. A 600 képpontos szélesség jól bevált, vagy beállíthatja a „max-width” értéket 95%-ra a „Speciális” menüpont alatt.';
    $Self->{Translation}->{'Add more service catalog fields'} = 'További szolgáltatáskatalógus mezők hozzáadása';
    $Self->{Translation}->{'You have the option of adding further fields here in the service catalog at any time. To do this, please go to "Admin -> DynamicFields" and create the new field of the object type "Service". You can then activate the field for the customer dashboard under "Admin -> DynamicField Screens" by assigning it under "CustomerDashboardTile ServiceCatalog".'} =
        'Lehetősége van további mezőket hozzáadnia bármikor itt, a szolgáltatáskatalógusban. Ehhez menjen az „Adminisztráció → Dinamikus mezők” modulhoz, és hozza létre a „Szolgáltatás” objektumtípusú új mezőt. Ezután aktiválhatja a mezőt az ügyfél vezérlőpultjához az „Adminisztráció → Dinamikus mezők képernyői” alatt azáltal, hogy hozzárendeli a mezőt a „CustomerDashboardTile ServiceCatalog” alatt.';

    # Template: AgentITSMSLAZoom
    $Self->{Translation}->{'SLA Information'} = 'SLA információk';
    $Self->{Translation}->{'Last changed'} = 'Utoljára módosítva';
    $Self->{Translation}->{'Last changed by'} = 'Utoljára módosította';
    $Self->{Translation}->{'Associated Services'} = 'Hozzárendelt szolgáltatások';

    # Template: AgentITSMServiceZoom
    $Self->{Translation}->{'Service Information'} = 'Szolgáltatásinformációk';
    $Self->{Translation}->{'Current incident state'} = 'Jelenlegi incidensállapot';
    $Self->{Translation}->{'Associated SLAs'} = 'Hozzárendelt SLA-k';

    # JS Template: TileServiceCatalogContainer
    $Self->{Translation}->{'Create a new ticket for this service.'} = 'Új jegy létrehozása ehhez a szolgáltatáshoz.';
    $Self->{Translation}->{'Create %s'} = '%s létrehozása';
    $Self->{Translation}->{'Show %s sub-service(s)'} = '%s alszolgáltatásainak megjelenítése';
    $Self->{Translation}->{'More details'} = 'További részletek';
    $Self->{Translation}->{'Sub-Service(s)'} = 'Alszolgáltatások';

    # JS Template: TileServiceCatalogDetailed
    $Self->{Translation}->{'sub-service(s) available'} = 'alszolgáltatás érhető el';
    $Self->{Translation}->{'Create a new ticket of type %s.'} = 'Új %s típusú jegy létrehozása.';
    $Self->{Translation}->{'FAQ article on this topic'} = 'GyIK bejegyzés ebben a témában';
    $Self->{Translation}->{'Additional information'} = 'További információk';
    $Self->{Translation}->{'Service hours'} = 'Szolgáltatási idő';
    $Self->{Translation}->{'o\'clock'} = 'óra';
    $Self->{Translation}->{'No additional data are available.'} = 'Nem érhetők el további adatok.';
    $Self->{Translation}->{'Further information'} = 'További információk';

    # JS Template: TileServiceCatalogModal
    $Self->{Translation}->{'Search catalog'} = 'Katalógus keresése';

    # Perl Module: Kernel/Modules/CustomerTileServiceCatalog.pm
    $Self->{Translation}->{'Description not available.'} = 'Leírás nem érhető el.';
    $Self->{Translation}->{'Need FileID!'} = 'Fájlazonosító szükséges!';

    # Perl Module: Kernel/Modules/AgentITSMServiceZoom.pm
    $Self->{Translation}->{'No ServiceID is given!'} = 'Nincs szolgáltatásazonosító megadva!';
    $Self->{Translation}->{'ServiceID %s not found in database!'} = 'A(z) %s szolgáltatásazonosító nem található az adatbázisban!';
    $Self->{Translation}->{'operational'} = 'üzemképes';
    $Self->{Translation}->{'warning'} = 'figyelmeztetés';
    $Self->{Translation}->{'incident'} = 'incidens';

    # JS File: Core.Agent.Admin.Service
    $Self->{Translation}->{'Do you really want to delete this service description language?'} =
        'Valóban törölni szeretné ezt a szolgáltatásleírás-nyelvet?';

    # JS File: Core.Customer.TileServiceCatalog
    $Self->{Translation}->{'Results for %s'} = 'Találatok erre: %s';

    # SysConfig
    $Self->{Translation}->{'Additional settings for the service catalog.'} = 'További beállítások a szolgáltatáskatalógushoz.';
    $Self->{Translation}->{'Autoload configuration for SLA import and export functions.'} = 'Automatikus betöltési beállítás az SLA importálása és exportálása funkciókhoz.';
    $Self->{Translation}->{'Autoload configuration for Service import and export functions.'} =
        'Automatikus betöltési beállítás a szolgáltatás importálása és exportálása funkciókhoz.';
    $Self->{Translation}->{'CustomerTileServiceCatalog AJAX Module.'} = 'Ügyfélcsempe-szolgáltatáskatalógus AJAX-modul.';
    $Self->{Translation}->{'Define a list of dynamic field object types which are allowed to be assigned to actions of this package via the dynamic field screens interface.'} =
        'Azon dinamikus mező objektumtípusok listájának meghatározása, amelyek hozzárendelhetők a csomag műveleteihez a dinamikus mező képernyőinek felületén keresztül.';
    $Self->{Translation}->{'Dynamic fields shown in the service catalog screen of the customer interface.'} =
        'Az ügyfélfelület szolgáltatáskatalógus képernyőjén megjelenített dinamikus mezők.';
    $Self->{Translation}->{'Event module registration. Currently, the criticality of the service can also be set in the service, but this has no effect. Therefore, this event module has been implemented that automatically updates the DynamicField Criticality in a ticket as soon as a service has been assigned. Please activate the SysConfig option SetPriorityFromCriticalityAndImpactMatrix to set the priority in the next step based an Criticality and Impact.'} =
        'Eseménymodul regisztráció. Jelenleg a szolgáltatás kritikussága beállítható a szolgáltatásban is, de ennek nincs hatása. Ezért került megvalósításra ez az eseménymodul, amely automatikusan frissíti a kritikusság dinamikus mezőt a jegyben, amint egy szolgáltatás hozzárendelésre kerül. Aktiválja a „SetPriorityFromCriticalityAndImpactMatrix” rendszerbeállítási lehetőséget, hogy beállítsa a prioritást a következő lépésben egy kritikusság és hatás alapján.';
    $Self->{Translation}->{'Event module registration. Currently, the criticality of the service can also be set in the service, but this has no effect. Therefore, this event module has been implemented that automatically updates the priority regarding Criticality and Impact in a ticket.'} =
        'Eseménymodul regisztráció. Jelenleg a szolgáltatás kritikussága beállítható a szolgáltatásban is, de ennek nincs hatása. Ezért került megvalósításra ez az eseménymodul, amely automatikusan frissíti a prioritást a kritikusságra és hatásra vonatkozóan a jegyben.';
    $Self->{Translation}->{'Show services with the following ticket type last.'} = 'A következő jegytípusokkal rendelkező szolgáltatások megjelenítése utoljára.';
    $Self->{Translation}->{'The FAQ field that should be used as the description of an FAQ article in the sidebar (e.g. Field1, Field2, Field3...).'} =
        'Az a GyIK mező, amelyet egy GyIK bejegyzés leírásaként kell használni az oldalsávban (például Mező1, Mező2, Mező3 stb.).';
    $Self->{Translation}->{'This option allows you to automatically generate ACLs for different interfaces when creating services. Services will then only be displayed if the ticket type stored in the service has been selected. The "AddBulkACL" console script can also be used to create ACLs for services that have already been create.'} =
        'Ez a beállítás lehetővé teszi ACL-ek automatikus előállítását a különböző felületekhez a szolgáltatások létrehozásakor. A szolgáltatások ezután csak akkor jelennek meg, ha a szolgáltatásban tárolt jegytípust kiválasztották. Az „AddBulkACL” konzolparancs is használható a már létrehozott szolgáltatásokhoz tartozó ACL-ek létrehozására.';
    $Self->{Translation}->{'This option makes it possible to preconfigure the automatically generated ACLs. The aim is to only display the services that have also been assigned to the service in the service catalog. To use this function, please first enable the "ServiceCatalog::CreateTypeServiceRelatedAcls" option. "GenerateInitalACLToDisableAllServices" generates an ACL that initially hides all services. The value "Possible" or "PossibleAdd" can be set for the key "ConfigChange". The "DeployNewACL" key decides whether the changed ACL should also be deployed immediately. "ACLValidID" (1, 2, 3) sets the ACLs to valid, invalid or temporarily invalid.'} =
        'Ez a beállítás lehetővé teszi az automatikusan előállított ACL-ek előzetes beállítását. A cél az, hogy csak olyan szolgáltatások jelenjenek meg, amelyek hozzá is lettek rendelve a szolgáltatáshoz a szolgáltatáskatalógusban. A funkció használatához először engedélyezze a „ServiceCatalog::CreateTypeServiceRelatedAcls” beállítást. A „GenerateInitalACLToDisableAllServices” olyan ACL-t állít elő, amely kezdetben elrejti az összes szolgáltatást. A „Possible” vagy „PossibleAdd” érték állítható be a „ConfigChange” kulcshoz. A „DeployNewACL” kulcs dönti el, hogy a megváltoztatott ACL-t is azonnal üzembe kell-e állítani. Az „ACLValidID” (1, 2, 3) állítja be az ACL-eket érvényesre, érvénytelenre vagy átmenetileg érvénytelenre.';
    $Self->{Translation}->{'Tile registration for the CustomerDashboard. Module is required.'} =
        'Csemperegisztráció az ügyfél vezérlőpultjához. A modul kötelező.';


    push @{ $Self->{JavaScriptStrings} // [] }, (
    'Additional information',
    'All',
    'Close this dialog',
    'Create %s',
    'Create Ticket',
    'Create a new ticket for this service.',
    'Create a new ticket of type %s.',
    'Details',
    'Do you really want to delete this service description language?',
    'FAQ article on this topic',
    'First Response Time',
    'Further information',
    'More details',
    'No additional data are available.',
    'OK',
    'Results',
    'Results for %s',
    'Search',
    'Search catalog',
    'Service Information',
    'Service hours',
    'Show %s sub-service(s)',
    'Show details of this service.',
    'Show or hide the content',
    'Solution Time',
    'Sub-Service(s)',
    'hour(s)',
    'o\'clock',
    'sub-service(s) available',
    );

}

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

package Kernel::Modules::AdminServiceImportExport;

use strict;
use warnings;

# core modules
use List::AllUtils qw(first);

# CPAN modules

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

our @ObjectDependencies = (
    'Kernel::Output::HTML::Layout',
    'Kernel::System::Cache',
    'Kernel::System::Service',
    'Kernel::System::Valid',
    'Kernel::System::Web::Request',
    'Kernel::System::YAML',
);

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

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

    return $Self;
}

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

    # get objects
    my $LayoutObject  = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
    my $ServiceObject = $Kernel::OM->Get('Kernel::System::Service');
    my $ParamObject   = $Kernel::OM->Get('Kernel::System::Web::Request');
    my $YAMLObject    = $Kernel::OM->Get('Kernel::System::YAML');
    my $CacheObject   = $Kernel::OM->Get('Kernel::System::Cache');

    $Self->{Subaction} = $ParamObject->GetParam( Param => 'Subaction' ) || '';

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

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

        my %UploadStuff = $ParamObject->GetUploadAll(
            Param => 'FileUpload',
        );

        my $OverwriteExistingEntities = $ParamObject->GetParam( Param => 'OverwriteExistingEntities' );

        my $PerlStructure = $YAMLObject->Load(
            Data => $UploadStuff{Content},
        );

        $CacheObject->Set(
            Type  => 'AdminServiceImportExport',
            Key   => 'AdminServiceImportExport::' . $Self->{UserID},
            Value => $PerlStructure,
            TTL   => 60 * 60,
        );

        return $Self->_Mask(
            Data                      => $PerlStructure,
            Type                      => $Self->{Subaction},
            OverwriteExistingEntities => $OverwriteExistingEntities || 0,
        );
    }

    # ------------------------------------------------------------ #
    # ImportAction
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'ImportAction' ) {

        my $ImportData = $CacheObject->Get(
            Type => 'AdminServiceImportExport',
            Key  => 'AdminServiceImportExport::' . $Self->{UserID},
        );

        if ( !IsHashRefWithData($ImportData) ) {

            # redirect to AdminService
            my $HTML = $LayoutObject->Redirect(
                OP => "Action=AdminService"
            );

            return $HTML;
        }

        # check required parameters
        my @ServicesSelected          = $ParamObject->GetArray( Param => 'Services' );
        my $OverwriteExistingEntities = $ParamObject->GetParam( Param => 'OverwriteExistingEntities' ) || 0;

        $CacheObject->Delete(
            Type => 'AdminServiceImportExport',
            Key  => 'AdminServiceImportExport::' . $Self->{UserID},
        );

        # ------------------------------------------------------------ #
        # Import Services
        # ------------------------------------------------------------ #
        if ( IsHashRefWithData( $ImportData->{Services} ) ) {

            my %ServicesImport;
            SERVICENAME:
            for my $ServiceName ( keys $ImportData->{Services}->%* ) {

                my $Selected = grep { $ServiceName eq $_ } @ServicesSelected;
                next SERVICENAME if !$Selected;

                next SERVICENAME if !IsHashRefWithData( $ImportData->{Services}{$ServiceName} );

                $ServicesImport{$ServiceName} = $ImportData->{Services}{$ServiceName};
            }

            $ServiceObject->ImportServices(
                Services                  => \%ServicesImport,
                OverwriteExistingEntities => $OverwriteExistingEntities,
                UserID                    => $Self->{UserID},
            );
        }

        # redirect to AdminService
        my $HTML = $LayoutObject->Redirect(
            OP => "Action=AdminService"
        );

        return $HTML;
    }

    # ------------------------------------------------------------ #
    # Export
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'Export' ) {

        return $Self->_Mask(
            %Param,
            Type => $Self->{Subaction},
        );

    }

    # ------------------------------------------------------------ #
    # ExportAction
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'ExportAction' ) {

        # check required parameters
        my @Services = $ParamObject->GetArray( Param => 'Services' );

        my %Data;
        my $HTML;

        if (@Services) {

            $Data{Services} = $ServiceObject->ExportServices(
                Services => \@Services,
                UserID   => $Self->{UserID},
            );
        }

        if ( !%Data ) {

            # redirect to AdminServiceImportExport
            $HTML .= $LayoutObject->Redirect(
                OP => "Action=AdminServiceImportExport;Subaction=Export",
            );
            return $HTML;
        }

        # convert the service data hash to string
        my $ServiceDataYAML = $YAMLObject->Dump( Data => \%Data );

        # Get the current time formatted like '2016-01-31 14:05:45'.
        # Hoping that nobody has registered object params for Kernel::System::DateTime
        my $TimeStamp = $Kernel::OM->Create('Kernel::System::DateTime')->ToString();

        # send the result to the browser
        $HTML = $LayoutObject->Attachment(
            ContentType => 'text/html; charset=' . $LayoutObject->{Charset},
            Content     => $ServiceDataYAML,
            Type        => 'attachment',
            Filename    => "Export_Services_$TimeStamp.yml",
            NoCache     => 1,
        );

        return $HTML;

    }

    # ------------------------------------------------------------ #
    # ------------------------------------------------------------ #
    else {

        # redirect to AdminService
        my $HTML = $LayoutObject->Redirect(
            OP => "Action=AdminService"
        );

        return $HTML;
    }

    return;
}

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

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

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

    # call hint block
    $LayoutObject->Block(
        Name => $Param{Type} . 'Hint',
        Data => {
            %Param,
        },
    );

    if ( !$Param{Data} ) {

        $Param{Data}{Services} = {};

        # TODO change to ServiceListGet()
        # export
        my %Services = $ServiceObject->ServiceList(
            Valid  => 0,
            UserID => $Self->{UserID},
        );

        # get service data
        for my $ServiceID ( keys %Services ) {
            my %ServiceData = $ServiceObject->ServiceGet(
                ServiceID => $ServiceID,
                UserID    => $Self->{UserID},
            );

            $Param{Data}{Services}{ $ServiceData{Name} } = \%ServiceData;
        }
    }

    my $Output = $LayoutObject->Header();
    $Output .= $LayoutObject->NavigationBar();

    # print the list of services
    $Self->_ServiceShow(
        %Param,
    );

    # output header
    $Output .= $LayoutObject->Output(
        TemplateFile => 'AdminServiceImportExport',
        Data         => {
            %Param,
        },
    );

    $Output .= $LayoutObject->Footer();
    return $Output;
}

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

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

    # check if at least 1 dynamic field is registered in the system
    if ( IsHashRefWithData( $Param{Data}{Services} ) ) {

        my @ServicesAlreadyUsed;

        SERVICENAME:
        for my $ServiceName ( sort keys $Param{Data}{Services}->%* ) {

            my $ServiceData = $Param{Data}{Services}{$ServiceName};

            push @ServicesAlreadyUsed, $ServiceData->{Name};

            next SERVICENAME if !IsHashRefWithData($ServiceData);

            # convert ValidID to Validity string
            my $Valid = $ServiceData->{Valid} || $ValidObject->ValidLookup(
                ValidID => $ServiceData->{ValidID},
            );

            my %ServiceData = (
                %{$ServiceData},
                Valid => $Valid,
            );

            for my $Blocks ( 'ServicesRow', 'ServiceCheckbox', $Param{Type} ) {

                # print each service row
                $LayoutObject->Block(
                    Name => $Blocks,
                    Data => {
                        %ServiceData,
                    },
                );
            }
        }
    }

    # otherwise show a no data found message
    else {
        $LayoutObject->Block(
            Name => 'NoDataFound',
            Data => \%Param,
        );
    }

    return;
}

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

package Kernel::Modules::AdminSLAImportExport;

use strict;
use warnings;

# core modules
use List::AllUtils qw(first);

# CPAN modules

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

our @ObjectDependencies = (
    'Kernel::Output::HTML::Layout',
    'Kernel::System::Cache',
    'Kernel::System::SLA',
    'Kernel::System::Valid',
    'Kernel::System::Web::Request',
    'Kernel::System::YAML',
);

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

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

    return $Self;
}

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

    # get objects
    my $LayoutObject = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
    my $SLAObject    = $Kernel::OM->Get('Kernel::System::SLA');
    my $ParamObject  = $Kernel::OM->Get('Kernel::System::Web::Request');
    my $YAMLObject   = $Kernel::OM->Get('Kernel::System::YAML');
    my $CacheObject  = $Kernel::OM->Get('Kernel::System::Cache');

    $Self->{Subaction} = $ParamObject->GetParam( Param => 'Subaction' ) || '';

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

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

        my %UploadStuff = $ParamObject->GetUploadAll(
            Param => 'FileUpload',
        );

        my $OverwriteExistingEntities = $ParamObject->GetParam( Param => 'OverwriteExistingEntities' );

        my $PerlStructure = $YAMLObject->Load(
            Data => $UploadStuff{Content},
        );

        $CacheObject->Set(
            Type  => 'AdminSLAImportExport',
            Key   => 'AdminSLAImportExport::' . $Self->{UserID},
            Value => $PerlStructure,
            TTL   => 60 * 60,
        );

        return $Self->_Mask(
            Data                      => $PerlStructure,
            Type                      => $Self->{Subaction},
            OverwriteExistingEntities => $OverwriteExistingEntities || 0,
        );
    }

    # ------------------------------------------------------------ #
    # ImportAction
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'ImportAction' ) {

        my $ImportData = $CacheObject->Get(
            Type => 'AdminSLAImportExport',
            Key  => 'AdminSLAImportExport::' . $Self->{UserID},
        );

        if ( !IsHashRefWithData($ImportData) ) {

            # redirect to AdminSLA
            my $HTML = $LayoutObject->Redirect(
                OP => "Action=AdminSLA"
            );

            return $HTML;
        }

        # check required parameters
        my @SLAsSelected              = $ParamObject->GetArray( Param => 'SLAs' );
        my $OverwriteExistingEntities = $ParamObject->GetParam( Param => 'OverwriteExistingEntities' ) || 0;

        $CacheObject->Delete(
            Type => 'AdminSLAImportExport',
            Key  => 'AdminSLAImportExport::' . $Self->{UserID},
        );

        # ------------------------------------------------------------ #
        # Import SLAs
        # ------------------------------------------------------------ #
        if ( IsHashRefWithData( $ImportData->{SLAs} ) ) {

            my %SLAImport;
            SLANAME:
            for my $SLAName ( keys $ImportData->{SLAs}->%* ) {

                my $Selected = grep { $SLAName eq $_ } @SLAsSelected;
                next SLANAME if !$Selected;

                next SLANAME if !IsHashRefWithData( $ImportData->{SLAs}{$SLAName} );

                $SLAImport{$SLAName} = $ImportData->{SLAs}{$SLAName};
            }

            $SLAObject->ImportSLAs(
                SLAs                      => \%SLAImport,
                OverwriteExistingEntities => $OverwriteExistingEntities,
                UserID                    => $Self->{UserID},
            );
        }

        # redirect to AdminSLA
        my $HTML = $LayoutObject->Redirect(
            OP => "Action=AdminSLA"
        );

        return $HTML;
    }

    # ------------------------------------------------------------ #
    # Export
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'Export' ) {

        return $Self->_Mask(
            %Param,
            Type => $Self->{Subaction},
        );

    }

    # ------------------------------------------------------------ #
    # ExportAction
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'ExportAction' ) {

        # check required parameters
        my @SLAs = $ParamObject->GetArray( Param => 'SLAs' );

        my %Data;
        my $HTML;

        if (@SLAs) {

            $Data{SLAs} = $SLAObject->ExportSLAs(
                SLAs   => \@SLAs,
                UserID => $Self->{UserID},
            );
        }

        if ( !%Data ) {

            # redirect to AdminSLAImportExport
            $HTML .= $LayoutObject->Redirect(
                OP => "Action=AdminSLAImportExport;Subaction=Export",
            );
            return $HTML;
        }

        # convert the SLA data hash to string
        my $SLADataYAML = $YAMLObject->Dump( Data => \%Data );

        # Get the current time formatted like '2016-01-31 14:05:45'.
        # Hoping that nobody has registered object params for Kernel::System::DateTime
        my $TimeStamp = $Kernel::OM->Create('Kernel::System::DateTime')->ToString();

        # send the result to the browser
        $HTML = $LayoutObject->Attachment(
            ContentType => 'text/html; charset=' . $LayoutObject->{Charset},
            Content     => $SLADataYAML,
            Type        => 'attachment',
            Filename    => "Export_SLAs_$TimeStamp.yml",
            NoCache     => 1,
        );

        return $HTML;

    }

    # ------------------------------------------------------------ #
    # ------------------------------------------------------------ #
    else {

        # redirect to AdminSLA
        my $HTML = $LayoutObject->Redirect(
            OP => "Action=AdminSLA"
        );

        return $HTML;
    }

    return;
}

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

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

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

    # call hint block
    $LayoutObject->Block(
        Name => $Param{Type} . 'Hint',
        Data => {
            %Param,
        },
    );

    if ( !$Param{Data} ) {

        $Param{Data}{SLAs} = {};

        # TODO change to SLAListGet()
        # export
        my %SLAs = $SLAObject->SLAList(
            Valid  => 0,
            UserID => $Self->{UserID},
        );

        # get SLA data
        for my $SLAID ( keys %SLAs ) {
            my %SLAData = $SLAObject->SLAGet(
                SLAID  => $SLAID,
                UserID => $Self->{UserID},
            );

            $Param{Data}{SLAs}{ $SLAData{Name} } = \%SLAData;
        }
    }

    my $Output = $LayoutObject->Header();
    $Output .= $LayoutObject->NavigationBar();

    # print the list of SLAs
    $Self->_SLAShow(
        %Param,
    );

    # output header
    $Output .= $LayoutObject->Output(
        TemplateFile => 'AdminSLAImportExport',
        Data         => {
            %Param,
        },
    );

    $Output .= $LayoutObject->Footer();
    return $Output;
}

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

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

    # check if at least 1 dynamic field is registered in the system
    if ( IsHashRefWithData( $Param{Data}{SLAs} ) ) {

        my @SLAsAlreadyUsed;

        SLANAME:
        for my $SLAName ( sort keys $Param{Data}{SLAs}->%* ) {

            my $SLAData = $Param{Data}{SLAs}{$SLAName};

            push @SLAsAlreadyUsed, $SLAData->{Name};

            next SLANAME if !IsHashRefWithData($SLAData);

            # convert ValidID to Validity string
            my $Valid = $SLAData->{Valid} || $ValidObject->ValidLookup(
                ValidID => $SLAData->{ValidID},
            );

            my %SLAData = (
                %{$SLAData},
                Valid => $Valid,
            );

            for my $Blocks ( 'SLAsRow', 'SLACheckbox', $Param{Type} ) {

                # print each SLA row
                $LayoutObject->Block(
                    Name => $Blocks,
                    Data => {
                        %SLAData,
                    },
                );
            }
        }
    }

    # otherwise show a no data found message
    else {
        $LayoutObject->Block(
            Name => 'NoDataFound',
            Data => \%Param,
        );
    }

    return;
}

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

package Kernel::Modules::CustomerTileServiceCatalog;

use strict;
use warnings;

use Kernel::Language              qw(Translatable);
use Kernel::System::VariableCheck qw(IsHashRefWithData);

our $ObjectManagerDisabled = 1;

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

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

    return $Self;
}

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

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

    # get params
    my $ServiceID = $ParamObject->GetParam( Param => "ServiceID" );

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

        if ( !$ServiceID ) {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Needed ServiceID!",
            );
            return;
        }

        my %Service = $ServiceObject->ServiceGet(
            ServiceID => $ServiceID,
            UserID    => $Self->{UserID},
        );

        # check if the user has permission on this service.
        my %ServiceList = $ServiceObject->CustomerUserServiceMemberList(
            CustomerUserLogin => $Self->{UserID},
            Result            => 'HASH',
        );

        if ( !$ServiceList{ $Service{ServiceID} } ) {
            return $LayoutObject->CustomerNoPermission( WithHeader => 'yes' );
        }

        # Add _blank target to Links in Long Description
        $Service{DescriptionLong} = $LayoutObject->HTMLLinkQuote(
            String => $Service{Descriptions}{ $LayoutObject->{UserLanguage} }{DescriptionLong}
                || $Service{Descriptions}{ $Kernel::OM->Get('Kernel::Config')->Get('DefaultLanguage') }{DescriptionLong}
                || $Service{Descriptions}{'en'}{DescriptionLong} || $LayoutObject->{LanguageObject}->Translate('Description not available.'),
        );

        $Service{DescriptionLong}
            =~ s{ index[.]pl [?] Action=AgentITSMServiceZoom }{customer.pl?Action=CustomerTileServiceCatalog}gxms;

        # build base URL for inline images
        my $SessionID = '';
        if ( $Self->{SessionID} && !$Self->{SessionIDCookie} ) {
            $SessionID = ';' . $Self->{SessionName} . '=' . $Self->{SessionID};
            $Service{DescriptionLong} =~ s{
                (Action=CustomerTileServiceCatalog;Subaction=DownloadAttachment;ServiceID=\d+;FileID=\d+)
            }{$1$SessionID}gmsx;
        }

        # add needed HTML headers
        $Service{DescriptionLong} = $Kernel::OM->Get('Kernel::System::HTMLUtils')->DocumentComplete(
            String            => $Service{DescriptionLong},
            Charset           => 'utf-8',
            CustomerInterface => 1,
            CustomerUIStyles  => 1,
        );

        # return complete HTML as an attachment
        return $LayoutObject->Attachment(
            Type        => 'inline',
            ContentType => 'text/html',
            Content     => $Service{DescriptionLong},
        );
    }
    elsif ( $Self->{Subaction} eq 'DynamicFieldView' ) {

        # add support for dynamic fields
        my @DynamicFieldList;
        my $DynamicFieldFilter = {
            %{ $ConfigObject->Get("CustomerDashboard::Configuration::ServiceCatalog")->{DynamicField} || {} },
        };

        # get the dynamic fields for service object
        my $DynamicFieldLookup = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
            Valid       => 1,
            ObjectType  => ['Service'],
            FieldFilter => $DynamicFieldFilter || {},
        );
        my $DynamicFieldBackendObject = $Kernel::OM->Get('Kernel::System::DynamicField::Backend');

        DYNAMICFIELD:
        for my $DynamicField ( @{$DynamicFieldLookup} ) {
            next DYNAMICFIELD if !IsHashRefWithData($DynamicField);

            my $ValueGet = $DynamicFieldBackendObject->ValueGet(
                DynamicFieldConfig => $DynamicField,
                ObjectID           => $ServiceID,
                UserID             => $Self->{UserID},
            );

            next DYNAMICFIELD if !$ValueGet;

            # use translation here to be able to reduce the character length in the template
            my $Label = $LayoutObject->{LanguageObject}->Translate( $DynamicField->{Label} );

            my $ValueStrg = $DynamicFieldBackendObject->DisplayValueRender(
                DynamicFieldConfig => $DynamicField,
                Value              => $ValueGet,
                LayoutObject       => $LayoutObject,
                ValueMaxChars      => 130,
            );

            push @DynamicFieldList, {
                $DynamicField->{Name} => $ValueStrg->{Title},
                Name                  => $DynamicField->{Name},
                Title                 => $ValueStrg->{Title},
                Value                 => $ValueStrg->{Value},
                Label                 => $Label,
                Link                  => $ValueStrg->{Link},
                LinkPreview           => $ValueStrg->{LinkPreview},
                TitleFieldConfig      => ( $DynamicField->{FieldType} eq 'Title' ) ? $DynamicField->{Config} : undef,

                # Include unique parameter with dynamic field name in case of collision with others.
                #   Please see bug#13362 for more information.
                "DynamicField_$DynamicField->{Name}" => $ValueStrg->{Title},
            };
        }

        # output dynamic fields
        FIELD:
        for my $Field (@DynamicFieldList) {

            # handle titles separately
            if ( $Field->{TitleFieldConfig} ) {
                my $Style = "padding-left:4px;font-size:$Field->{TitleFieldConfig}{FontSize}px;color:$Field->{TitleFieldConfig}{FontColor};";

                if ( $Field->{TitleFieldConfig}{CBFontStyleUnderLineValue} ) {
                    $Style .= "text-decoration:underline;";
                }
                if ( $Field->{TitleFieldConfig}{CBFontStyleItalicValue} ) {
                    $Style .= "font-style:italic;";
                }
                if ( $Field->{TitleFieldConfig}{CBFontStyleBoldValue} ) {
                    $Style .= "font-weight:bold;";
                }

                $LayoutObject->Block(
                    Name => 'TicketDynamicField',
                    Data => {
                        Text       => $Field->{Label},
                        Style      => $Style,
                        TitleField => 1,
                    },
                );

                next FIELD;
            }

            $LayoutObject->Block(
                Name => 'ServiceDynamicField',
                Data => {
                    Label => $Field->{Label},
                },
            );

            if ( $Field->{Link} ) {
                $LayoutObject->Block(
                    Name => 'ServiceDynamicFieldLink',
                    Data => {
                        $Field->{Name} => $Field->{Title},
                        Value          => $Field->{Value},
                        Title          => $Field->{Title},
                        Link           => $Field->{Link},
                        LinkPreview    => $Field->{LinkPreview},

                        # Include unique parameter with dynamic field name in case of collision with others.
                        #   Please see bug#13362 for more information.
                        "DynamicField_$Field->{Name}" => $Field->{Title},
                    },
                );
            }
            else {
                $LayoutObject->Block(
                    Name => 'ServiceDynamicFieldPlain',
                    Data => {
                        Value => $Field->{Value},
                        Title => $Field->{Title},
                    },
                );
            }
        }

        my $Output = $LayoutObject->Output(
            TemplateFile => 'Dashboard/TileServiceCatalogDynamicFields',
            Data         => {%Param},
        );

        # return complete HTML as an attachment
        return $LayoutObject->Attachment(
            Type        => 'inline',
            ContentType => 'text/html',
            Content     => $Output,
        );
    }

    # ---------------------------------------------------------- #
    # DownloadAttachment Subaction
    # ---------------------------------------------------------- #
    elsif ( $Self->{Subaction} eq 'DownloadAttachment' ) {
        my $FileID = $ParamObject->GetParam( Param => 'FileID' );

        if ( !defined $FileID ) {
            return $LayoutObject->CustomerFatalError(
                Message => Translatable('Need FileID!'),
            );
        }

        # Get attachments.
        my %File = $Kernel::OM->Get('Kernel::System::Service')->AttachmentGet(
            ServiceID => $ServiceID,
            FileID    => $FileID,
            UserID    => $Self->{UserID},
        );

        if (%File) {
            return $LayoutObject->Attachment(%File);
        }
        else {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Message  => "No such attachment ($FileID)! May be an attack!!!",
                Priority => 'error',
            );
            return $LayoutObject->CustomerFatalError();
        }
    }

    return $LayoutObject->Redirect(
        OP =>
            "Action=CustomerDashboard",
    );
}

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

package Kernel::Output::HTML::CustomerDashboard::TileServiceCatalog;

use strict;
use warnings;

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

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::Language',
    'Kernel::Output::HTML::Layout',
    'Kernel::System::CustomerUser',
    'Kernel::System::DateTime',
    'Kernel::System::DynamicField',
    'Kernel::System::DynamicField::Backend',
    'Kernel::System::FAQ',
    'Kernel::System::HTMLUtils',
    'Kernel::System::LinkObject',
    'Kernel::System::Package',
    'Kernel::System::Service',
    'Kernel::System::SLA',
    'Kernel::System::Ticket',
    'Kernel::System::Type',
    'Kernel::System::Valid',
    'Kernel::System::DynamicField',
    'Kernel::System::DynamicField::Backend',
    'Kernel::System::LinkObject',
    'Kernel::System::Package'
);

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

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

    return $Self;
}

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

    my $ConfigObject   = $Kernel::OM->Get('Kernel::Config');
    my $LanguageObject = $Kernel::OM->Get('Kernel::Language');
    my $LayoutObject   = $Kernel::OM->Get('Kernel::Output::HTML::Layout');
    my $SLAObject      = $Kernel::OM->Get('Kernel::System::SLA');
    my $PackageObject  = $Kernel::OM->Get('Kernel::System::Package');

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

    # Get customer user.
    $Param{CustomerUser} = $Kernel::OM->Get('Kernel::System::CustomerUser')->CustomerUserDataGet(
        User => $Param{UserID},
    );

    # Only get information of SLAs or calendars once and save them in hashes.
    my %SLAIDs = $SLAObject->SLAList(
        Valid  => 1,
        UserID => 1,
    );

    # Get all SLA and associated calendar information.
    my %ServiceList;
    my %SLAList;
    my %CalendarList;
    my @WeekDays = ( 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun' );    # FIXME/Improve: Work with CalendarWeekDayStart
    for my $SLAID ( keys %SLAIDs ) {
        my %SLAData = $SLAObject->SLAGet(
            SLAID  => $SLAID,
            UserID => 1,
        );
        $SLAList{$SLAID} = \%SLAData;

        # Get all services which use this SLA.
        for my $ServiceID ( @{ $SLAData{ServiceIDs} } ) {
            push @{ $ServiceList{$ServiceID}{SLAIDs} }, $SLAID;
        }

        # Calendar does not exist yet.
        if ( $SLAData{Calendar} && !$CalendarList{ $SLAData{Calendar} } ) {

            # Get the calendar and the time zone.
            my $Calendar = $ConfigObject->Get( 'TimeWorkingHours::Calendar' . $SLAData{Calendar} );
            $Calendar->{TimeZone} = $ConfigObject->Get( 'TimeZone::Calendar' . $SLAData{Calendar} ) || $DefaultTimeZone;

            # Get working days and hours for the week. E.g.: Mo-Fr 12–19, Sat 13–19.
            my %Run;
            for my $Index ( 0 .. ( scalar @WeekDays - 1 ) ) {
                my $Day = $Calendar->{ $WeekDays[$Index] };

                # The day has working hours.
                if ( IsArrayRefWithData($Day) ) {
                    my $FirstHour = $Day->[0];
                    my $LastHour  = $Day->[-1];

                    # We need one hour more, cause the calendar means inclusive the last hour
                    $LastHour++;

                    # First day of the run.
                    if ( !$Run{StartDay} ) {
                        $Run{StartDay}  = $WeekDays[$Index];
                        $Run{FirstHour} = $FirstHour;
                        $Run{LastHour}  = $LastHour;
                    }

                    # The current date has different working hours than the last day of the run.
                    elsif ( $FirstHour != $Run{FirstHour} || $LastHour != $Run{LastHour} ) {

                        # Set the last day to yesterday and reset the run.
                        $Run{LastDay} = $WeekDays[ ( $Index - 1 ) ];
                        push @{ $Calendar->{WorkingHours} }, {%Run};
                        undef %Run;

                        $Run{StartDay}  = $WeekDays[$Index];
                        $Run{FirstHour} = $FirstHour;
                        $Run{LastHour}  = $LastHour;
                    }
                }
                else {
                    # No data for the day. Check if the run needs to be stopped.
                    if ( $Run{StartDay} ) {
                        $Run{LastDay} = $WeekDays[ ( $Index - 1 ) ];
                        push @{ $Calendar->{WorkingHours} }, {%Run};
                        undef %Run;
                    }
                }

                # It's the last day of the week.
                if ( $Index == 6 ) {

                    # If the run is still going on, close it.
                    if ( $Run{StartDay} ) {
                        $Run{LastDay} = $WeekDays[$Index];
                        push @{ $Calendar->{WorkingHours} }, {%Run};
                    }
                }
            }

            $CalendarList{ $SLAData{Calendar} } = $Calendar;
        }
    }

    # Iterate through all avaliable services and filter out the sevices and parameters we need.
    my $ServiceListRefArray = $Kernel::OM->Get('Kernel::System::Service')->ServiceListGet(
        Valid  => 1,
        UserID => 1,
    );

    my %ServiceListRef;

    my %TypeList = $Kernel::OM->Get('Kernel::System::Type')->TypeList(
        Valid => 1,
    );

    # Get all service IDs of the customer.
    my %ServiceIDs = $Kernel::OM->Get('Kernel::System::Ticket')->TicketServiceList(
        Action         => 'CustomerDashboard',
        CustomerUserID => $Param{UserID},
        QueueID        => 1,
    );

    my $Settings = $ConfigObject->Get('CustomerDashboard::Configuration::ServiceCatalog') || {};
    SERVICEREF:
    for my $ServiceRef ( @{$ServiceListRefArray} ) {
        $ServiceListRef{ $ServiceRef->{ServiceID} } = $ServiceRef;

        # Check if the customer has permission on this service.
        next SERVICEREF if !$ServiceIDs{ $ServiceRef->{ServiceID} };
        my %Service = ();

        # Get all needed parameters
        for my $Needed (qw(ServiceID NameShort Descriptions TicketTypeIDs ParentID Keywords)) {
            if ( $ServiceRef->{$Needed} ) {
                if ( $Needed eq 'TicketTypeIDs' ) {

                    # Get names of all assigned types.
                    for my $TypeID ( @{ $ServiceRef->{$Needed} } ) {
                        my $TypeName = $LanguageObject->Translate( $TypeList{$TypeID} );

                        # Check if the assigned type ID is still valid.
                        if ($TypeName) {
                            $Service{TicketType}{$TypeName} = {
                                ID      => $TypeID,
                                Classes => $Settings->{ $TypeList{$TypeID} },
                            };
                        }
                    }
                } elsif ( $Needed eq 'Descriptions' ) {
                    $Service{DescriptionShort} = $ServiceRef->{$Needed}->{$LayoutObject->{UserLanguage}}->{DescriptionShort} || 
                        $ServiceRef->{$Needed}->{$Kernel::OM->Get('Kernel::Config')->Get('DefaultLanguage')}->{DescriptionShort} || 
                            $ServiceRef->{$Needed}->{'en'}->{DescriptionShort} || $LayoutObject->{LanguageObject}->Translate( 'Description not available.' );

                    $Service{DescriptionLong} = $ServiceRef->{$Needed}->{$LayoutObject->{UserLanguage}}->{DescriptionLong} || 
                        $ServiceRef->{$Needed}->{$Kernel::OM->Get('Kernel::Config')->Get('DefaultLanguage')}->{DescriptionLong} || 
                            $ServiceRef->{$Needed}->{'en'}->{DescriptionLong} || $LayoutObject->{LanguageObject}->Translate( 'Description not available.' );
                }
                else {
                    $Service{$Needed} = $ServiceRef->{$Needed};
                }
            }
        }

        # Get all calendar and SLA information for this service.
        my $SLAIDs = $ServiceList{ $Service{ServiceID} }{SLAIDs};

        my %DontSet;
        SLAID:
        for my $SLAID ( @{$SLAIDs} ) {
            my $SLA      = $SLAList{$SLAID};
            my $Calendar = $CalendarList{ $SLA->{Calendar} };

            # This service is linked to at least two SLAs with different first response times.
            if ( $Service{FirstResponseTime} && $Service{FirstResponseTime} ne $SLA->{FirstResponseTime} ) {
                undef $Service{FirstResponseTime};
                $DontSet{FirstResponseTime} = 1;
            }
            elsif ( !$DontSet{FirstResponseTime} ) {
                $Service{FirstResponseTime} = $SLA->{FirstResponseTime};
            }

            # This service is linked to at least two SLAs with different solution times.
            if ( $Service{SolutionTime} && $Service{SolutionTime} ne $SLA->{SolutionTime} ) {
                undef $Service{SolutionTime};
                $DontSet{SolutionTime} = 1;
            }
            elsif ( !$DontSet{SolutionTime} ) {
                $Service{SolutionTime} = $SLA->{SolutionTime};
            }

            # SLA does not have a calendar.
            next SLAID if !$Calendar;

            # This service is linked to at least two SLA calendars with different time zones.
            if ( $Service{TimeZone} && $Calendar->{TimeZone} && $Service{TimeZone} ne $Calendar->{TimeZone} ) {
                undef $Service{TimeZone};
                undef $Service{WorkingHours};
                $DontSet{TimeZone}     = 1;
                $DontSet{WorkingHours} = 1;
            }
            elsif ( !$DontSet{TimeZone} ) {
                $Service{TimeZone} = $Calendar->{TimeZone};
            }

            # This service is linked to at least two different calendars.
            if ( $Service{WorkingHours} ) {

                # Check if working hours are the same.
                INDEX:
                for my $Index ( 0 .. ( scalar @{ $Service{WorkingHours} } - 1 ) ) {
                    if (
                        !$Service{WorkingHours}[$Index] || !$Calendar->{WorkingHours}[$Index]    # Check if runs exist.
                        || $#{ $Service{WorkingHours} } != $#{ $Calendar->{WorkingHours} }       # One run is longer or shorter.
                                                                                                 # Check if they have the same values.
                        || $Service{WorkingHours}[$Index]{StartDay} ne $Calendar->{WorkingHours}[$Index]{StartDay}
                        || $Service{WorkingHours}[$Index]{LastDay} ne $Calendar->{WorkingHours}[$Index]{LastDay}
                        || $Service{WorkingHours}[$Index]{FirstHour} ne $Calendar->{WorkingHours}[$Index]{FirstHour}
                        || $Service{WorkingHours}[$Index]{LastHour} ne $Calendar->{WorkingHours}[$Index]{LastHour}
                        )
                    {
                        undef $Service{WorkingHours};
                        $DontSet{WorkingHours} = 1;
                        last INDEX;
                    }
                }
            }
            elsif ( !$DontSet{WorkingHours} ) {
                $Service{WorkingHours} = $Calendar->{WorkingHours};
            }
        }

        # Check if FAQ modul is installed, if yes we check service related faq messages
        my $FAQInstalled = $PackageObject->PackageIsInstalled(
            Name => 'FAQ',
        );

        # FAQ package is installed
        if ($FAQInstalled) {

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

            # Get FAQ interface state list
            my $InterfaceStates = $FAQObject->StateTypeList(
                Types  => $ConfigObject->Get('FAQ::Customer::StateTypes'),
                UserID => $Param{UserID},
            );

            # Get all linked FAQ articles.
            my %LinkKeyList = $Kernel::OM->Get('Kernel::System::LinkObject')->LinkKeyList(
                Object1 => 'Service',
                Key1    => $Service{ServiceID},
                Object2 => 'FAQ',
                State   => 'Valid',
                UserID  => 1,
            );

            # For each LinkKeyList, get the FAQ article.
            for my $LinkKey ( keys %LinkKeyList ) {
                my %FAQData = $FAQObject->FAQGet(
                    ItemID     => $LinkKey,
                    ItemFields => 1,
                    UserID     => $Param{UserID},
                );

                # Check if the user has permission to see this FAQ.
                my @ValidIDs      = $Kernel::OM->Get('Kernel::System::Valid')->ValidIDsGet();
                my %ValidIDLookup = map { $_ => 1 } @ValidIDs;

                # Check user permission
                my $Permission = $FAQObject->CheckCategoryCustomerPermission(
                    CustomerUser => $Param{CustomerUser},
                    CategoryID   => $FAQData{CategoryID},
                    UserID       => $Param{UserID},
                );

                # Permission check
                if (
                    $Permission
                    && $FAQData{Approved}
                    && $ValidIDLookup{ $FAQData{ValidID} }
                    && $InterfaceStates->{ $FAQData{StateTypeID} }
                    )
                {
                    # Filter out information we don't need.
                    my %FilteredFAQData = ();

                    # Get the config for the FAQ fields we want to display.
                    my $DescriptionFieldToDisplay = $Settings->{FAQDescriptionField} || 'Field1';
                    KEY:
                    for my $Key ( ( 'ItemID', 'Title', $DescriptionFieldToDisplay, 'CategoryName' ) ) {
                        next KEY if !$FAQData{$Key};

                        if ( $Key eq $DescriptionFieldToDisplay ) {

                            # Remove HTML tags.
                            $FilteredFAQData{Description} = $Kernel::OM->Get('Kernel::System::HTMLUtils')->ToAscii(
                                String => $FAQData{$Key},
                            );

                            # If the field is longer than 70 characters, add an ellipsis.
                            if ( length( $FilteredFAQData{Description} ) > 45 ) {
                                $FilteredFAQData{Description} = substr( $FilteredFAQData{Description}, 0, 45 ) . '...';
                            }
                        }
                        else {
                            $FilteredFAQData{$Key} = $FAQData{$Key};
                        }
                    }
                    push @{ $Service{FAQs} }, \%FilteredFAQData;
                }
            }
        }

        # Save the service in a list.
        $ServiceList{ $Service{ServiceID} } = \%Service;
    }

    # Add support for dynamic fields.
    my $DynamicFieldFilter = {
        %{ $ConfigObject->Get("CustomerDashboard::Configuration::ServiceCatalog")->{DynamicField} || {} },
    };

    # Get dynamic fields for service object.
    my $DynamicFieldLookup = $Kernel::OM->Get('Kernel::System::DynamicField')->DynamicFieldListGet(
        Valid       => 1,
        ObjectType  => ['Service'],
        FieldFilter => $DynamicFieldFilter || {},
    );
    my $DynamicFieldBackendObject = $Kernel::OM->Get('Kernel::System::DynamicField::Backend');

    # Get the dynamic field values for every service.
    for my $ServiceID ( keys %ServiceList ) {
        my @DynamicFieldList;

        # # Get the dynamic field values for this service.
        DYNAMICFIELD:
        for my $DynamicFieldConfig ( @{$DynamicFieldLookup} ) {
            next DYNAMICFIELD if !IsHashRefWithData($DynamicFieldConfig);

            # Get the label;
            my $Label = $DynamicFieldConfig->{Label};

            # Get field value.
            my $Value = $DynamicFieldBackendObject->ValueGet(
                DynamicFieldConfig => $DynamicFieldConfig,
                ObjectID           => $ServiceID,
            );

            my $ValueStrg = $DynamicFieldBackendObject->DisplayValueRender(
                DynamicFieldConfig => $DynamicFieldConfig,
                Value              => $Value,
                LayoutObject       => $LayoutObject,
                ValueMaxChars      => 130,
            );

            # Set field value.
            if ( $Label && $ValueStrg->{Value} ) {
                push @DynamicFieldList, {
                    $ValueStrg->%*,
                    Label => $Label,
                };
            }
        }

        # Add the dynamic field values to the service.
        if ( IsArrayRefWithData( \@DynamicFieldList ) ) {
            $ServiceList{$ServiceID}->{DynamicField} = \@DynamicFieldList;
        }
    }

    # Get the basic information for every parent Service, even if the the customer user does not have permission to see it.
    SERVICEID:
    for my $ServiceID ( keys %ServiceList ) {
        my $ParentID = $ServiceList{$ServiceID}{ParentID};
        next SERVICEID if !$ParentID;

        if ( $ServiceList{$ParentID} && $ServiceList{$ParentID}{ServiceID} ) {
            next SERVICEID;
        }

        # Get sure that we can select every subservice of this service.
        SERVICEDATA:
        while (1) {
            my %Service = ();

            for my $Needed (qw(ServiceID NameShort DescriptionShort DescriptionLong ParentID)) {
                if ( $ServiceListRef{$ParentID}{$Needed} ) {
                    $Service{$Needed} = $ServiceListRef{$ParentID}{$Needed};
                }
            }

            $Service{NotSelectable}             = 1;
            $ServiceList{ $Service{ServiceID} } = \%Service;
            $ParentID                           = $Service{ParentID};

            # Parent reached.
            if ( !$Service{ParentID} || ( $ServiceList{$ParentID} && $ServiceList{$ParentID}{ServiceID} ) ) {
                last SERVICEDATA;
            }
        }
    }


    # TODO: Names have to be translated somewhere for the breadcrumb, we need to prevent translation of those translated values
    for my $ServiceID ( keys %ServiceList ) {
        $ServiceList{$ServiceID}{NameShort} = $LayoutObject->Output(
            Template => '[%  Translate(Data.Name) | html %]',
            Data     => {
                Name => $ServiceList{$ServiceID}{NameShort},
            },
        );
    }

    # Show all first level services, sorted by the name.
    my %ParentIDs;
    SERVICEID:
    for my $ServiceID ( keys %ServiceList ) {
        next SERVICEID if $ServiceList{$ServiceID}{ParentID};

        # One of these can be undef if the parent service is disabled.
        next SERVICEID if !$ServiceList{$ServiceID};
        next SERVICEID if !$ServiceList{$ServiceID}{NameShort};

        $ParentIDs{$ServiceID} = $ServiceList{$ServiceID}{NameShort};
    }

    my %ReversedParentIDs = reverse %ParentIDs;
    my $NumberOfServices  = 0;
    SERVICENAME:
    for my $ServiceName ( sort values %ParentIDs ) {
        my $ServiceID = $ReversedParentIDs{$ServiceName};
        next SERVICENAME if !$ServiceID;
        $NumberOfServices++;

        if ( $NumberOfServices <= 3 ) {

            # Create the parent list.
            $LayoutObject->Block(
                Name => 'ParentService',
                Data => $ServiceList{$ServiceID},
            );
        }
    }

    if ( $NumberOfServices >= 4 ) {
        $LayoutObject->Block(
            Name => 'ParentServiceMore',
            Data => {
                NumberOfServices => $NumberOfServices - 3,
            },
        );
    }

    # Create navigation field for services.
    $ServiceIDs{'All'} = $LayoutObject->{LanguageObject}->Translate('All');
    my $ServiceStrg = $LayoutObject->BuildSelection(
        Data         => \%ServiceIDs,
        Name         => 'ServiceID',
        Class        => 'Modernize ',
        PossibleNone => 1,
        TreeView     => 1,
        Sort         => 'TreeView',
        Translation  => 0,
        Max          => 200,
    );

    $LayoutObject->AddJSData(
        Key   => 'ServiceList',
        Value => $LayoutObject->JSONEncode(
            Data => \%ServiceList,
        ),
    );

    $LayoutObject->AddJSData(
        Key   => 'ServiceStrg',
        Value => $LayoutObject->JSONEncode(
            Data => $ServiceStrg,
        ),
    );

    if ( $Settings->{SortByTicketType} ) {
        $LayoutObject->AddJSData(
            Key   => 'SortByTicketType',
            Value => $LanguageObject->Translate( $Settings->{SortByTicketType} ),
        );
    }

    my $Content = $LayoutObject->Output(
        TemplateFile => 'Dashboard/TileServiceCatalog',
        Data         => {
            TileID => $Param{TileID},
            %{ $Param{Config} },
        },
    );

    return $Content;
}

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

<div class="MainBox ARIARoleMain LayoutFixedSidebar SidebarFirst">

    [%
        SET Type  = Translate(Data.Type);
        SET Label = Translate("Services");
    %]

    [% BreadcrumbPath = [
            {
                Name => Translate("%s - %s",Label, Type),
            },
        ]
    %]

    [% INCLUDE "Breadcrumb.tt" Path = BreadcrumbPath %]
    <div class="Clear"></div>

    <div class="SidebarColumn">
        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("Actions") | html %]</h2>
            </div>
            <div class="Content">
                <ul class="ActionList">
[% RenderBlockStart("ActionOverview") %]
                    <li>
                        <a href="[% Env("Baselink") %]Action=AdminService" class="CallForAction Fullsize Center">
                        <span><i class="fa fa-plus-square"></i>[% Translate("Services") | html %]</span></a>
                    </li>
[% RenderBlockEnd("ActionOverview") %]
                </ul>
            </div>
        </div>

        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("Hint") | html %] - [% Translate(Data.Type) | html %]</h2>
            </div>
            <div class="Content">
                <div class="FieldExplanation">
                    <p>
                        <b>
                            [% Translate("Select the items you want to ") | html %] [% Translate(Data.Type) | html %].
                        </b>

                        <p>
                            </br>
[% RenderBlockStart("ImportHint") %]
                        [% Translate("Select the desired elements and confirm the import with 'import'.") | html %]
[% RenderBlockEnd("ImportHint") %]
[% RenderBlockStart("ExportHint") %]
                        [% Translate("Here you can export a configuration file of services to import these on another system. The configuration file is exported in yml format.") | html %]
[% RenderBlockEnd("ExportHint") %]
                         </p>
                    </p>
                </div>
            </div>
        </div>
    </div>

    <div class="ContentColumn">
        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("Services List") | html %]</h2>
            </div>
            <div class="Clear"></div>
            <div class="Content LayoutGrid ColumnsWithSpacing">

                <form id='Form' action="[% Env("CGIHandle") %]" method="post" class="Validate PreventMultipleSubmits">
                    <input type="hidden" name="Action" value="[% Env("Action") %]"/>
                    <input type="hidden" name="Subaction" value="[% Env("Subaction") %]Action"/>
                    <input type="hidden" name="Type" value="[% Data.Type | html %]"/>
                    <input type="hidden" name="OverwriteExistingEntities"  value="[% Data.OverwriteExistingEntities | html %]">
                    <table class="DataTable" id="ServicesTable" summary="List of all registered Services">
                        <thead>
                            <tr>
                                <th class='Center'>
                                    <input type="checkbox" name="SelectAllServices" title="[% Translate('Toggle all available elements') | html %]" checked value="" />
                                    [% Translate("Fields") | html %]
                                </th>
                                <th>[% Translate("Name") | html %]</th>
                                <th>[% Translate("Comment") | html %]</th>
                                <th>[% Translate("Validity") | html %]</th>
                            </tr>
                        </thead>
                        <tbody>
[% RenderBlockStart("ServicesRow") %]
                            <tr id="ServiceID_[% Data.ServiceID | html %]">
                                <td class='Center'>
[% RenderBlockStart("ServiceCheckbox") %]
                                    <input type="checkbox" id="Services" name="Services" value="[% Data.Name | html %]" checked />
[% RenderBlockEnd("ServiceCheckbox") %]
                                </td>
                                <td>
[% RenderBlockStart("Import") %]
                                    [% Data.Name %]
[% RenderBlockEnd("Import") %]
[% RenderBlockStart("Export") %]
                                    <a href="[% Env("Baselink") %]Action=AdminService;Subaction=Change;ServiceID=[% Data.ServiceID | uri %]" title="[% Data.Name | html %]" class="MasterActionLink">[% Data.Name %]</a>
[% RenderBlockEnd("Export") %]
                                </td>
                                <td>
                                    <div>[% Translate(Data.Comment) | html %]</div>
                                </td>
                                <td>
                                    <div>[% Translate(Data.Valid) | html %]</div>
                                </td>
                            </tr>
[% RenderBlockEnd("ServicesRow") %]
                        </tbody>
                    </table>
                    <div class="Field SpacingTop" style="text-align: center;">
                        <button class="Primary CallForAction" type="submit" id="Export" value="[% Translate(Data.Type) | html %]">
                            <span>[% Translate(Data.Type) | html %]</span>
                        </button>
                        [% Translate("or") | html %]
                        <a href="[% Env("Baselink") %]Action=AdminService" >[% Translate("Cancel") | html %]</a>
                    </div>
                    <div class="Clear"></div>
                </form>
            </div>
        </div>
        <div class="Clear"></div>
    </div>
</div>
 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2012-2020 Znuny GmbH, http://znuny.com/
# Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

<div class="MainBox ARIARoleMain LayoutFixedSidebar SidebarFirst">

    [%
        SET Type  = Translate(Data.Type);
        SET Label = Translate("SLAs");
    %]

    [% BreadcrumbPath = [
            {
                Name => Translate("%s - %s",Label, Type),
            },
        ]
    %]

    [% INCLUDE "Breadcrumb.tt" Path = BreadcrumbPath %]
    <div class="Clear"></div>

    <div class="SidebarColumn">
        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("Actions") | html %]</h2>
            </div>
            <div class="Content">
                <ul class="ActionList">
[% RenderBlockStart("ActionOverview") %]
                    <li>
                        <a href="[% Env("Baselink") %]Action=AdminSLA" class="CallForAction Fullsize Center">
                        <span><i class="fa fa-plus-square"></i>[% Translate("SLAs") | html %]</span></a>
                    </li>
[% RenderBlockEnd("ActionOverview") %]
                </ul>
            </div>
        </div>

        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("Hint") | html %] - [% Translate(Data.Type) | html %]</h2>
            </div>
            <div class="Content">
                <div class="FieldExplanation">
                    <p>
                        <b>
                            [% Translate("Select the items you want to ") | html %] [% Translate(Data.Type) | html %].
                        </b>

                        <p>
                            </br>
[% RenderBlockStart("ImportHint") %]
                        [% Translate("Select the desired elements and confirm the import with 'import'.") | html %]
[% RenderBlockEnd("ImportHint") %]
[% RenderBlockStart("ExportHint") %]
                        [% Translate("Here you can export a configuration file of SLAs to import these on another system. The configuration file is exported in yml format.") | html %]
[% RenderBlockEnd("ExportHint") %]
                         </p>
                    </p>
                </div>
            </div>
        </div>
    </div>

    <div class="ContentColumn">
        <div class="WidgetSimple">
            <div class="Header">
                <h2>[% Translate("SLAs List") | html %]</h2>
            </div>
            <div class="Clear"></div>
            <div class="Content LayoutGrid ColumnsWithSpacing">

                <form id='Form' action="[% Env("CGIHandle") %]" method="post" class="Validate PreventMultipleSubmits">
                    <input type="hidden" name="Action" value="[% Env("Action") %]"/>
                    <input type="hidden" name="Subaction" value="[% Env("Subaction") %]Action"/>
                    <input type="hidden" name="Type" value="[% Data.Type | html %]"/>
                    <input type="hidden" name="OverwriteExistingEntities"  value="[% Data.OverwriteExistingEntities | html %]">
                    <table class="DataTable" id="SLAsTable" summary="List of all registered SLAs">
                        <thead>
                            <tr>
                                <th class='Center'>
                                    <input type="checkbox" name="SelectAllSLAs" title="[% Translate('Toggle all available elements') | html %]" checked value="" />
                                    [% Translate("Fields") | html %]
                                </th>
                                <th>[% Translate("Name") | html %]</th>
                                <th>[% Translate("Comment") | html %]</th>
                                <th>[% Translate("Validity") | html %]</th>
                            </tr>
                        </thead>
                        <tbody>
[% RenderBlockStart("SLAsRow") %]
                            <tr id="SLAID_[% Data.SLAID | html %]">
                                <td class='Center'>
[% RenderBlockStart("SLACheckbox") %]
                                    <input type="checkbox" id="SLAs" name="SLAs" value="[% Data.Name | html %]" checked />
[% RenderBlockEnd("SLACheckbox") %]
                                </td>
                                <td>
[% RenderBlockStart("Import") %]
                                    [% Data.Name %]
[% RenderBlockEnd("Import") %]
[% RenderBlockStart("Export") %]
                                    <a href="[% Env("Baselink") %]Action=AdminSLA;Subaction=Change;SLAID=[% Data.SLAID | uri %]" title="[% Data.Name | html %]" class="MasterActionLink">[% Data.Name %]</a>
[% RenderBlockEnd("Export") %]
                                </td>
                                <td>
                                    <div>[% Translate(Data.Comment) | html %]</div>
                                </td>
                                <td>
                                    <div>[% Translate(Data.Valid) | html %]</div>
                                </td>
                            </tr>
[% RenderBlockEnd("SLAsRow") %]
                        </tbody>
                    </table>
                    <div class="Field SpacingTop" style="text-align: center;">
                        <button class="Primary CallForAction" type="submit" id="Export" value="[% Translate(Data.Type) | html %]">
                            <span>[% Translate(Data.Type) | html %]</span>
                        </button>
                        [% Translate("or") | html %]
                        <a href="[% Env("Baselink") %]Action=AdminSLA" >[% Translate("Cancel") | html %]</a>
                    </div>
                    <div class="Clear"></div>
                </form>
            </div>
        </div>
        <div class="Clear"></div>
    </div>
</div>
 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 # --
# OTOBO is a web-based ticketing system for service organisations.
# --
# Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
# --

{% if NumberOfSubservices %}
   <!-- <span class="oooSubservices ooo12g" data-service-id="{{ ID }}">{{ NumberOfSubservices }} {{ 'sub-service(s) available' | Translate }}</span> -->
{% endif %}
<div data-service-id="{{ ID }}" class="oooDetailedServiceContainer">
    <div class="oooDetailedLeft">
        <div class="oooDetailedServiceName">
            <h2>{{ Name }}</h2>
            <!-- <p>{{ DescriptionShort }}</p> -->
        </div>
        <div class="oooDetailedDescriptionLong">
            <iframe sandbox="allow-same-origin allow-popups ms-allow-popups allow-popups-to-escape-sandbox" title="about:blank" frameborder="0" class="VisibleFrame" src="{{ IframeLink }}"></iframe>
        </div>
    </div>
    <div class="oooDetailedRight">
        <div class="oooDetailedTicketTypeList">
            {% if TypeList %}
                {% for TypeName, Type in TypeList %}
                    {% if loop.index0 < 3 %}    
                        <a title="{{ 'Create a new ticket of type %s.' | Translate(TypeName) }}" href="{{ Baselink }}Action=CustomerTicketMessage;ServiceID={{ ID }};TypeID={{ Type.ID }}"><i class="ooofo ooofo-faq {{ Type.Classes }}"></i> 
                            <span>{{ 'Create %s' | Translate(TypeName) }}</span>
                        </a>
                    {% endif %}
                {% endfor %}
            {# {% else %}
                <i class="ooofo ooofo-faq"></i><a href="{{ Baselink }}Action=CustomerTicketMessage;ServiceID={{ ID }}"> {{ 'Create Ticket' | Translate }}</a><br> #}
            {% endif %}
        </div>

        <div class="oooDetailedAccordionList">

        {% if FAQArticleList %}
            <div class="oooDetailedAccordion WidgetSimple {% if AdditionalInformation %}Collapsed{% else %}Expanded{% endif %} Animate">
                <div class="Header">
                    <div class="WidgetAction Toggle">
                        <a href="#" title="{{ 'Show or hide the content' | Translate }}">
                            <h3>{{ 'FAQ article on this topic' | Translate }}</h3>
                            <div class="oooNumberOfEntries"><span>{{ FAQArticleList.length }}</span></div>
                            <i class="ooofo ooofo-arrow_u"></i>
                            <i class="ooofo ooofo-arrow_d"></i>
                        </a>
                    </div>
                </div>
                <div class="oooDetailedFAQ Content" {% if AdditionalInformation %}style="display: none;"{% else %}{% endif %}>
                    {% for FAQArticle in FAQArticleList %}
                            <a href="{{ Baselink }}Action=CustomerFAQZoom;ItemID={{ FAQArticle.ItemID }}" title="{{ FAQArticle.Title }}">
                                <div class="oooDetailedFAQItem">
                                    <p class="oooDetailedAccordionCaption">{{ FAQArticle.Title }}</p>
                                    <div class="oooFAQDescription">{{ FAQArticle.Description }}</div>
                                    <span class="oooFAQDetailsHint oooHidden">{{ 'Details' | Translate }}</span>
                                </div>
                            </a>
                    {% endfor %}
                </div>
            </div>
        {% endif %}

        {% if AdditionalInformation %}
            <div class="oooDetailedAccordion WidgetSimple {% if FAQArticleList %}Collapsed{% else %}Expanded{% endif %} Animate">
                <div class="Header">
                    <div class="WidgetAction Toggle">
                        <a href="#" title="{{ 'Show or hide the content' | Translate }}">
                            <h3>{{ 'Additional information' | Translate }}</h3>
                            <i class="ooofo ooofo-arrow_u"></i>
                            <i class="ooofo ooofo-arrow_d"></i>
                        </a>
                    </div>
                </div>
                <div class="oooDetailedAdditionalInformation Content" {% if FAQArticleList %}style="display: none;"{% else %}{% endif %}>
                    <div>
                        {% if WorkingHours or FirstResponseTime or SolutionTime %}
                            <p class="oooDetailedAccordionCaption oooDetailedSubtitle">{{ 'Service hours' | Translate }}</p>
                            {% if WorkingHours %}
                                <p class="oooSLALabel"> 
                                    <span class="ooo12">
                                        {% for Run in WorkingHours %}
                                            {{ Run.StartDay | Translate(Run.StartDay) }}{% if Run.LastDay != Run.StartDay %}&#8211;{{ Run.LastDay | Translate(Run.LastDay) }}{% endif %} {{ Run.FirstHour }}&#8211;{{ Run.LastHour }} {{ "o'clock" | Translate }}
                                            <br>
                                        {% endfor %}
                                    </span>
                                </span>
                            {% endif %}
                            {% if FirstResponseTime %}
                                <p class="ooo12">{{ 'First Response Time' | Translate }}: {{ FirstResponseTime }} {{ 'hour(s)' | Translate }}</p>
                            {% endif %}
                            {% if SolutionTime %}
                                <p class="ooo12">{{ 'Solution Time' | Translate }}: {{ SolutionTime }} {{ 'hour(s)' | Translate }}</p>
                            {% endif %}
                        {% endif %}
                    </div>
                    <div>
                        {% if DynamicFieldList %}
                            <p class="oooDetailedAccordionCaption oooDetailedSubtitle">{{ 'Service Information' | Translate }}</p>
                            {% for DFData in DynamicFieldList %}
                                {% if DFData.Link %}
                                <p class="ooo12"><span>{{ DFData.Label | Translate }}:</span> <a href="{{ DFData.Link }}" class="DynamicFieldLink" {% if DFData.LinkPreview %} data-trigger="floater" data-floater-url="{{ DFData.LinkPreview }}"{% endif %} target="_blank">{{ DFData.Value }}</a>
                                {% else %}
                                <p class="ooo12"><span>{{ DFData.Label | Translate }}:</span> {{ DFData.Value }}</p>
                                {% endif %}
                            {% endfor %}
                        {% endif %}
                    </div>
                    {# <iframe sandbox="allow-same-origin allow-popups ms-allow-popups allow-popups-to-escape-sandbox" title="about:blank" frameborder="0" class="VisibleFrame" src="{{ IframeLinkDynamicField }}"></iframe> #}
                </div>
            </div>
        {% else %}
            <div class="oooDetailedAccordion WidgetSimple {% if FAQArticleList %}Collapsed{% else %}Expanded{% endif %} Animate">
                <div class="Header">
                    <div class="WidgetAction Toggle">
                        <a href="#" title="{{ 'Show or hide the content' | Translate }}">
                            <h3>{{ 'Additional information' | Translate }}</h3>
                            <i class="ooofo ooofo-arrow_u"></i>
                            <i class="ooofo ooofo-arrow_d"></i>
                        </a>
                    </div>
                </div>
                <div class="oooDetailedAdditionalInformation Content" {% if FAQArticleList %}style="display: none;"{% else %}{% endif %}>        
                    <div>
                        <p class="oooDetailedAccordionCaption oooDetailedSubtitle">{{ 'No additional data are available.' | Translate }}</p>
                    </div>            
                </div>
            </div>
        {% endif %}

        {% if SubservicesHTML | length > 0 %}
            <div class="oooDetailedAccordion WidgetSimple Collapsed Animate">
                <div class="Header">
                    <div class="WidgetAction Toggle">
                        <a href="#" title="{{ 'Show or hide the content' | Translate }}">
                            <h3>{{ 'Sub-Service(s)' | Translate }}</h3>
                            <div class="oooNumberOfEntries"><span>{{ NumberOfSubservices }}</span></div>
                            <i class="ooofo ooofo-arrow_u"></i>
                            <i class="ooofo ooofo-arrow_d"></i>
                        </a>
                    </div>
                </div>
                <div class="oooDetailedSubservices Content" style="display: none;">
                    {% for Subservice in SubservicesHTML %}
                        {{ Subservice | safe }}
                    {% endfor %}
                </div>
            </div>
        {% endif %}

        </div>
    </div>

    <a id="oooDetailedToggleSidebar" href="#" title="{{ 'Further information' | Translate }}" accesskey="n">
        <button>
            <i class="ooofo ooofo-more_v"></i>
        </button>
    </a>

</div>
 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 // --
// OTOBO is a web-based ticketing system for service organisations.
// --
// Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
// Copyright (C) 2019-2024 Rother OSS GmbH, https://otobo.de/
// --
// 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/>.
// --

"use strict";

var Core = Core || {};
Core.Customer = Core.Customer || {};

Core.Customer.TileServiceCatalog = (function (TargetNS) {
    const $l = e => $($(e).get(-1)); // last matched elem
    const clone_offset_dialog = () => {
        const last_dialog = $l('.Dialog.Modal');
        last_dialog.parent().append(last_dialog.clone(true));
        const new_dialog = $l('.Dialog.Modal');
        const offset = new_dialog.offset();
        offset.top += 30;
        offset.left += 30;
        new_dialog.offset(offset);
        $(new_dialog).find('.oooServiceFieldSearch > input').val('');
    };

    TargetNS.Init = function() {
        // Listen to document to recognize DOM changes.
        $(document).on('click', '.oooServiceIDAvailable', function() {
            var ServiceID = $(this).attr('data-service-id');
            $('.Dialog.Modal .Close').click();
            // Show the dialog if not already open.
            if (!$('.Dialog.Modal').length) {
                var ModalContainer = Core.Template.Render('Customer/TileServiceCatalogModal', {
                    ServiceStrg: JSON.parse(Core.Config.Get('ServiceStrg')),
                });

                Core.UI.Dialog.ShowDialog({
                    HTML: ModalContainer,
                    Modal: true,
                    CloseOnClickOutside: true,
                    CloseOnEscape: true,
                    PositionTop: '15px',
                    PositionLeft: 'Center',
                    AllowAutoGrow: false,
                    Stacked: true
                });

                $('.Dialog.Modal').addClass('oooServiceCatalogModal');
                // The search field is not needed anymore
                // $('.Dialog.Modal .oooServiceField').appendTo('.Dialog.Modal > .Header').find('select').attr('id', 'ModalServiceID');
                $('.oooServiceField').addClass('oooHidden');
                $('.Dialog.Modal .oooServiceFieldSearch').appendTo('.Dialog.Modal > .Header').find('select').attr('id', 'ModalSearch');
                $('.oooServiceBreadcrumbWrap').appendTo('.Dialog.Modal > .Header');
                // Core.UI.InputFields.Init();
                $('#ModalServiceID').val(ServiceID).trigger('redraw.InputField');
            }

            TargetNS.DisplayServiceList(ServiceID);
        });

        // Show subservices.
        $(document).on('click', '.Dialog .oooServiceContainer', function(Event) {
            if (
                $(Event.target).hasClass('ooofo-info') || $(Event.target).hasClass('ooofo-add') || $(Event.target).hasClass('oooServiceInformation')
                || $(Event.target).hasClass('oooServiceActions') || $(Event.target).hasClass('oooServiceActionDetails') ||  $(Event.target).hasClass('oooServiceBottom') || $(Event.target).hasClass('ooofo-arrow_r')
                ) {
                return;
            }
            clone_offset_dialog();
            var ServiceID = $(this).attr('data-service-id');
            $('#ModalServiceID').val(ServiceID).trigger('redraw.InputField');
            TargetNS.DisplayServiceList(ServiceID);
        });

        // Show the detailed view.
        $(document).on('click', '.oooServiceBottom, .oooServiceActionDetails', function() {
            var ServiceID = $(this).parent().attr('data-service-id');
            if (!ServiceID) return;
            clone_offset_dialog();
            TargetNS.DisplayDetailedService(ServiceID);
            return;
        });

        // Show or hide service actions.
        $(document).on('click', '.oooDesciptionHeader > .ooofo', function() {
            if ($(this).next().hasClass('oooServiceActions')) {
                if ($(this).next().hasClass('oooHidden')) {
                    $(this).next().removeClass('oooHidden');
                } else {
                    $(this).next().addClass('oooHidden');
                }
            }

        });

        $(document).on('click', '.Dialog span.oooSubservices', function(Event) {
            var ServiceID = $(this).attr('data-service-id');
            TargetNS.DisplayServiceList(ServiceID);
        });

        // Select a service when navbar field is changed.
        $(document).on('change', '#ModalServiceID', function() {
            var ServiceID = $(this).val();
            TargetNS.DisplayServiceList(ServiceID);
        });

        // Enable the search function.
        $(document).on('keyup', '.Dialog > .Header > .oooServiceFieldSearch > input', function() {
            var SearchString = $(this).val().toLowerCase();
            $l('.Dialog .oooServiceWrapper').find('.oooServiceContainer').each(function() {
                var ServiceName = $(this).find('.oooServiceName').text();
                var Description = $(this).find('.oooDescriptionShort').text();
                var Keywords    = $(this).find('.oooKeywords').text();
                if (
                    (ServiceName.toLowerCase().indexOf(SearchString.toLowerCase()) > -1) ||
                    (Description.toLowerCase().indexOf(SearchString.toLowerCase()) > -1) ||
                    (Keywords.toLowerCase().indexOf(SearchString.toLowerCase()) > -1)
                ) {
                    $(this).removeClass('oooHidden');
                } else {
                    $(this).addClass('oooHidden');
                }
            });

            // If no SearchString is given, hide all subservices with the class oooInitialHidden.
            if (SearchString == '') {
                $('.Dialog .oooInitialHidden').addClass('oooHidden');
            }

            // TODO Rebuild the breadcrumb. Show original breadcrumb if no search string is given.
        });

        // Show the quick action view for a service.
        $(document).on('click', '.oooDesciptionHeader > i', function(e) {
            return false;
        });

        // Toggle the sidebar information for mobile views.
        $(document).on('click', '#oooDetailedToggleSidebar', function() {
            if (!$('.oooDetailedRight').is(':visible')) {
                $('.oooDetailedRight').show();
                $('.oooDetailedLeft').hide();
                $('.oooServiceBreadcrumbWrap').hide();
            } else {
                $('.oooDetailedLeft').show();
                $('.oooDetailedRight').hide();
                $('.oooServiceBreadcrumbWrap').show();
            }
        });

    }

    TargetNS.DisplayServiceList = function(ServiceID) {
        var Subservices = TargetNS.GetSubservices(ServiceID);

        // If there is only one subservice, jump straight into that list.
        if (Subservices.length == 1) {
            var Subservice = JSON.parse(Core.Config.Get('ServiceList'))[Subservices];

            // Only jump deeper if the subservice does not have the option to create a ticket for itself.
            if (!Subservice.TicketType) {
                return TargetNS.DisplayServiceList(Subservices[0]);
            }
        // If there is no subservice, show a detailed view of that service.
        } else if (Subservices.length == 0) {
            return TargetNS.DisplayDetailedService(ServiceID);
        }

        $l('.oooServiceWrapper').html('');
        $l('.oooServiceResult').removeClass('oooHidden');
        // $('.oooServiceBreadcrumb').addClass('oooHidden');
        $l('.oooServiceFieldSearch > input').focus(); // Autofocus the search field.
        // $('.oooServiceField').removeClass('oooHidden');
        $l('.oooServiceFieldSearch').removeClass('oooHidden');
        $l('.Dialog').removeClass('oooDetailedView');

        // Get all subservices for the search function.
        var AllSubservices = TargetNS.GetAllSubservices(ServiceID);
        for (var SubserviceID of AllSubservices) {
            // If the SubserviceID is not within the Subservices array, add the class 'oooHidden'.
            var Class = '';
            if (Subservices.indexOf(SubserviceID) == -1) {
                Class = 'oooHidden oooInitialHidden';
            }
            var DisplayServiceHTML = TargetNS.DisplayService(SubserviceID, Class);
            $(DisplayServiceHTML).appendTo($l('.oooServiceWrapper'));
        }

        TargetNS.CreateBreadcrumb(ServiceID);
    }

    TargetNS.DisplayService = function(ServiceID, Class = '') {
        var Service = JSON.parse(Core.Config.Get('ServiceList'))[ServiceID];
        var Baselink = Core.Config.Get('Baselink');
        var Container = Core.Template.Render('Customer/TileServiceCatalogContainer', {
            ID: ServiceID,
            Name:  Service.NameShort,
            DescriptionShort: Service.DescriptionShort,
            NumberOfSubservices: TargetNS.GetSubservices(ServiceID).length,
            TicketType: Service.TicketType,
            Baselink: Baselink,
            NotSelectable: Service.NotSelectable,
            Class: Class,
            Keywords: Service.Keywords
        });

        return Container;
    }

    TargetNS.DisplayDetailedService = function(ServiceID) {
        $l('.oooServiceWrapper').html('');
        var Service = JSON.parse(Core.Config.Get('ServiceList'))[ServiceID];
        var Baselink = Core.Config.Get('Baselink');
        var IframeLink = Baselink + 'Action=CustomerTileServiceCatalog;Subaction=HTMLView;ServiceID=' + ServiceID + ';' + Core.Config.Get('SessionName') + '=' + Core.Config.Get('SessionID')
        // TODO: Refactor/remove this.
        var IframeLinkDynamicField = Baselink + 'Action=CustomerTileServiceCatalog;Subaction=DynamicFieldView;ServiceID=' + ServiceID + ';' + Core.Config.Get('SessionName') + '=' + Core.Config.Get('SessionID')

        // Convert minutes to hours and round to the first decimal place.
        var SolutionTime, FirstResponseTime;
        if (Service.SolutionTime && !isNaN(Service.SolutionTime)) {
            SolutionTime = Service.SolutionTime / 60;
            SolutionTime = Math.round(SolutionTime * 10) / 10;
        }

        if (Service.FirstResponseTime && !isNaN(Service.FirstResponseTime)) {
            FirstResponseTime = Service.FirstResponseTime / 60;
            FirstResponseTime = Math.round(FirstResponseTime * 10) / 10;
        }

        // Get all subservices.
        var Subservices = TargetNS.GetSubservices(ServiceID);

        // For each Subservice, get the HTML.
        var SubservicesHTML = [];
        for (var SubserviceID of Subservices) {
            SubservicesHTML.push(TargetNS.DisplayService(SubserviceID));
        }

        var AdditionalInformation;
        if (Service.WorkingHours || SolutionTime || FirstResponseTime || Service.DynamicField) {
            AdditionalInformation = 1;
        }

        var Detailed = Core.Template.Render('Customer/TileServiceCatalogDetailed', {
            ID: ServiceID,
            Name:  Service.NameShort,
            DescriptionShort: Service.DescriptionShort,
            IframeLink: IframeLink,
            IframeLinkDynamicField: IframeLinkDynamicField,  // TODO: Delete this.
            DynamicFieldList: Service.DynamicField,
            WorkingHours: Service.WorkingHours,
            SolutionTime: SolutionTime,
            FirstResponseTime: FirstResponseTime,
            AdditionalInformation: AdditionalInformation,
            TypeList: Service.TicketType,
            Baselink: Baselink,
            FAQArticleList: Service.FAQs,
            NumberOfSubservices: TargetNS.GetSubservices(ServiceID).length,
            SubservicesHTML: SubservicesHTML,
        });

        $(Detailed).appendTo($l('.oooServiceWrapper'));

        // Resize iFrame.
        var IFrame = $l('.oooServiceWrapper').find('[data-service-id="' + ServiceID + '"]').find('iframe');
        ResizeIframe(IFrame);
        Core.UI.Init();

        TargetNS.CreateBreadcrumb(ServiceID);

        $l('.Dialog').addClass('oooDetailedView');
        $l('.oooServiceResult').addClass('oooHidden');
    }

    TargetNS.CreateBreadcrumb = function(ServiceID) {
        var Service = JSON.parse(Core.Config.Get('ServiceList'));
        var SelectedService = Service[ServiceID];

        if (SelectedService) {
            $l('.oooServiceResult').text(Core.Language.Translate('Results for %s', SelectedService.NameShort));
        } else {
            $l('.oooServiceResult').text(Core.Language.Translate('Results'));
        }

        var LiString = '';

        // Add the current service to the list.
        if (ServiceID != 'All') {
            LiString += '<li data-service-id="' + SelectedService.ServiceID + '" class="oooServiceIDAvailable oooServiceIDSelected">' + SelectedService.NameShort + '</li>';
        }

        // Add 'All' to the list.
        LiString += '<li data-service-id="All" class="oooServiceIDAvailable ' + ( ServiceID == 'All'  ? 'oooServiceIDSelected' : '') + '">' + Core.Language.Translate('All') + '</li>';

        // Get all main level services.
        for (var ServiceIDLoop in Service) {
            if (Service[ServiceIDLoop].ParentID) continue;  // Skip if the service has a parent.
            if (ServiceIDLoop == ServiceID) continue;  // Don't show the current service twice.
            if (!Service[ServiceIDLoop].NameShort) continue;  // TODO/FIXME: Workaround Stefan R. This should not be necessary, fix in .pm.

            LiString += '<li data-service-id="' + ServiceIDLoop + '" class="oooServiceIDAvailable">' + Service[ServiceIDLoop].NameShort + '</li>';
        }

        $l('.oooBreadcrumbServiceList').html(LiString);

        // Scroll services list.
        const goLeft = crumb => crumb.scrollLeft(crumb.scrollLeft() - crumb.width());
        const goRight = crumb => crumb.scrollLeft(crumb.scrollLeft() + crumb.width());
        $('.oooScrollLeft').click(
            e => goLeft($(e.target).parent().find('.oooServiceBreadcrumbField'))
        );
        $('.oooScrollRight').click(
            e => goRight($(e.target).parent().find('.oooServiceBreadcrumbField'))
        );
        $('.oooServiceBreadcrumbField').on('wheel', e => {
            switch(true) {
                case e.originalEvent.deltaY < 0:
                    goLeft($(e.delegateTarget));
                    break;
                case e.originalEvent.deltaY > 0:
                    goRight($(e.delegateTarget));
                    break;
            }
            e.preventDefault();
        })
    }

    /**
     * @private
     * @name GetSubservices
     * @memberof Core.Customer.TileServiceCatalog
     * @function
     * @param {String} ServiceID - ID of the service
     * @description
     *     Get the subservices of a service.
     */
    TargetNS.GetSubservices = function(ServiceID) {
        var Service = JSON.parse(Core.Config.Get('ServiceList'));

        // Iterate through all services and get all subservices of ServiceID.
        var UnorderedSubservices = {};
        for (var ChildID in Service) {
            if (ServiceID == Service[ChildID].ParentID) {
                UnorderedSubservices[Service[ChildID].NameShort] = ChildID;
            } else if (ServiceID == 'All') {
                // If the all filter is set, get all services.
                UnorderedSubservices[Service[ChildID].NameShort] = ChildID;
            }
        }

        // Order all Subservices by name.
        var Subservices = Object.keys(UnorderedSubservices).sort().reduce(
            function (Obj, Key) {
                Obj[Key] = UnorderedSubservices[Key];
                return Obj;
            }, {}
        );

        // Push services of a specific ticket type to the end of the list.
        var TicketTypeFilter = Core.Config.Get('SortByTicketType');
        if (TicketTypeFilter) {
            var SortByTicketType = {};
            $.each( Subservices, function( ServiceName, ServiceID ) {
                // Filter for services with a single ticket type and only match if it's the ticket type we are looking for.
                if (
                    Service[ServiceID].TicketType &&
                    Object.keys(Service[ServiceID].TicketType).length == 1 &&
                    Service[ServiceID].TicketType[TicketTypeFilter]
                    )
                {
                    // Remove the subservice from the main list.
                    delete Subservices[ServiceName];
                    SortByTicketType[ServiceName] = ServiceID;
                }
            });

            // Add all removed subservices back to the main list.
            $.extend(Subservices, SortByTicketType);
        }

        return Object.values(Subservices);
    }

    /**
     * @private
     * @name GetAllSubservices
     * @memberof Core.Customer.TileServiceCatalog
     * @function
     * @param {String} ServiceID - ID of the service
     * @description
     *     Get all subservices recursively of a service.
     */
    TargetNS.GetAllSubservices = function(ServiceID) {
        var Service = JSON.parse(Core.Config.Get('ServiceList'));

        // Get all subservices of ServiceID.
        var Subservices = TargetNS.GetSubservices(ServiceID);
        var AllSubservices = Subservices;

        // While there are still subservices, get all subservices of the current subservices.
        while (Subservices.length > 0) {
            var NewSubservices = [];
            $.each(Subservices, function(Index, SubserviceID) {
                var SubSubservices = TargetNS.GetSubservices(SubserviceID);
                NewSubservices = NewSubservices.concat(SubSubservices);
            });
            Subservices = NewSubservices;
            AllSubservices = AllSubservices.concat(Subservices);
        }

        // Remove all duplicates (important for the 'All' filter).
        AllSubservices = AllSubservices.filter(function (Item, Index, Array) {
            return Array.indexOf(Item) === Index;
        });

        return AllSubservices;
    }

    /**
     * @private
     * @name CalculateHeight
     * @memberof Core.Customer.TileServiceCatalog
     * @function
     * @param {DOMObject} Iframe - DOM representation of an iframe
     * @description
     *      Resizes Iframe to its max inner height.
     */
    function ResizeIframe(Iframe) {
        Iframe = isJQueryObject(Iframe) ? Iframe.get(0) : Iframe;

        $(Iframe).on('load', function() {
            var $IframeContent = $(Iframe.contentDocument || Iframe.contentWindow.document),
                NewHeight = $IframeContent.height();
            if (!NewHeight || isNaN(NewHeight)) {
                NewHeight = 100;
            }
            else {
                if (NewHeight > 600) {
                    NewHeight = 600;
                }
            }

            NewHeight = parseInt(NewHeight, 10);
            $(Iframe).height(NewHeight + 'px');
        });

    }

    Core.Init.RegisterNamespace(TargetNS, 'APP_MODULE');

    return TargetNS;
}(Core.Customer.TileServiceCatalog || {}));
 /* OTOBO is a web-based ticketing system for service organisations.

Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
Copyright (C) 2019-2024 Rother OSS GmbH, https://otobo.de/

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/>.
*/

.oooTile_ServiceCatalog > h2 {
    margin-top: 16px;
    margin-bottom: 16px;
}

.oooParentServiceList {
    display: flex;
    gap: 16px;
}

.oooParentServiceList > li {
    word-wrap: anywhere;
    box-sizing: border-box;
    display: flex;
    align-items: flex-start;
    padding: 56px 32px 32px;
    gap: 8px;
    width: 200px;
    height: 128px;
    background: #ffffff;
    border-radius: 16px;
}

.oooParentServiceList > .oooServiceMore {
    background: rgba(127, 128, 157, 0.05);
    color: var(--colTextLight);
    outline: none;
    display: flex;
    flex-direction: column;
    justify-content: center;
    align-items: center;
    padding: 0px;
    gap: 8px;
}

.oooServiceMore:hover {
    outline: none !important;
    gap: 8px;
    color: var(--colMainLight) !important;
    background: #ffffff;
}

.oooParentServiceList > li:hover {
    cursor: pointer;
    /* border: 2px solid var(--colMainLight); */
    outline: 2px solid var(--colMainLight);
    color: var(--colMainLight);
}

.oooParentServiceList > li.oooServiceMore:hover {
    border: 2px solid var(--colMainLight);
} 

.oooServiceMore:hover > .oooServiceMoreSearch > span,
.oooServiceMore:hover > .oooServiceMoreInfo {
    display: none;
}

.oooServiceMore:hover > .oooServiceMoreSearch {
    justify-content: center;
    font-size: 25px;
    color: var(--colMainLight);
}

.oooServiceMoreSearch {
    display: flex;
    flex-direction: row;
    align-items: center;
    gap: 8px;
    width: 75px;
    height: 18px;
}

ul.oooChildServiceList > li:not(:first-child) {
    margin-left: 12px;
    padding: 4px 4px;
}

ul.oooBreadcrumbServiceList > li:first-child {
    margin-left: 8px;
}

.oooServiceBreadcrumbWrap {
    padding-top: 20px;
    display: flex;
    flex-wrap: nowrap;
    width: 100%;
}

.oooServiceBreadcrumb {
    display: block;
    max-width: calc( 90% - 100px );
}

.oooServiceBreadcrumbField {
    height: 50px;
    overflow-x: hidden;
    overflow-y: hidden;
}

.oooScrollLeft, .oooScrollRight {
    display: inline-block;
    padding-top: 3px;
    font-family: 'otobo' !important;
    speak: none;
    font-style: normal;
    font-weight: normal;
    font-variant: normal;
    text-transform: none;
    line-height: 1;
    -webkit-font-smoothing: antialiased;
    cursor: pointer;
}

.oooScrollLeft {
    content: "\e903";
    padding-left: 32px;
    padding-right: 16px;
    padding-top: 13px;
}

.oooScrollRight {
    content: "\e904";
    padding-left: 24px;
    padding-right: 32px;
    padding-top: 13px;
}

.oooBreadcrumbServiceList {
    display: flex;
    flex-direction: row;
    align-items: center;
    padding: 0px;
    gap: 8px;
    flex: none;
    order: 0;
    flex-grow: 0;
}

.oooBreadcrumbServiceList > li {
    box-sizing: border-box;
    display: flex;
    flex-direction: row;
    align-items: center;
    padding: 8px 24px;
    gap: 13px;
    width: auto;
    height: 40px;
    background: rgba(127, 128, 157, 0.08);
    border-radius: 76px;
    flex: none;
    order: 1;
    align-self: stretch;
    flex-grow: 0;
    cursor: pointer;
    font-size: 11px;
    line-height: 13px;
    color: var(--colTextLight);
}

.oooBreadcrumbServiceList > li.oooServiceIDSelected {
    border: 1px solid var(--colMainLight);
    color: var(--colMainLight);
    background: #ffffff;
}

.oooServiceResult {
    color: var(--colTextLight);
    font-size: 12px;
    margin-bottom: 10px;
    margin-left: 10px;
}

.oooServiceBreadcrumbField .ooofo.ooofo-arrow_r::before {
    font-weight: bold;
}

.Dialog.oooServiceCatalogModal {
    min-height: 704px;
    height: 704px;
}

.Dialog.oooServiceCatalogModal:not(:last-child) > .Header,
.Dialog.oooServiceCatalogModal:not(:last-child) > .Content {
    display: none;
}

.Dialog.oooServiceCatalogModal:not(:last-child) {
    background: #ffffff;
}

.Dialog.oooServiceCatalogModal:nth-last-child(2) > .Header,
.Dialog.oooServiceCatalogModal:nth-last-child(2) > .Content {
    display: none;
}

.Dialog.oooDetailedView, .oooDetailedView > div {
    background: #ffffff;
}

.Dialog.oooDetailedView > .Header {
    padding-top: 24px;
    width: 720px;
}

.oooDetailedView .oooServiceFieldSearch {
    display: none;
}

.oooDetailedView .oooServiceBreadcrumb {
    width: 100%;
    /* width: calc(100% - 180px); */
}

.Dialog.oooDetailedView > .Content {
    padding: 0px 25px;
}

.oooServiceWrapper > .oooSubservices  {
    color: #001bff;
    color: var(--colMainLight);
    margin: 0 0 8px 8px;
    cursor: pointer;
    display: inline-block;
}

.oooServiceContainer {
    gap: 16px 16px;
    margin: 8px;
    float: left;
    display: flex;
    flex-direction: column;
    justify-content: center;
    align-items: flex-start;
    padding: 0px;
    isolation: isolate;
    width: 319px;
    height: 280px;
    background: #ffffff;
    border-radius: 16px;
}

.oooServiceContainer:hover, .oooDetailedTicketTypeList > a:hover {
    outline: 2px solid var(--colMainLight);
    box-sizing: border-box;
    -moz-box-sizing: border-box;
    -webkit-box-sizing: border-box;
    background: transparent;
    cursor: pointer;
    color: var(--colMainLight);
}

.oooServiceContainer:hover .oooServiceName {
    color: var(--colMainLight);
}

/* Special styling within subservice list in detailed view */
.oooDetailedSubservices > .oooServiceContainer .oooServiceName, 
.oooDetailedSubservices > .oooServiceContainer .oooSubservices,
.oooDetailedSubservices > .oooServiceContainer .oooServiceInformation {
    font-size: 12px;
}

.oooDetailedSubservices > .oooServiceContainer,
.oooDetailedSubservices > .oooServiceContainer > .oooDesciptionHeader,
.oooDetailedSubservices > .oooServiceContainer > .oooServiceBottom {
    width: 300px;
}

.oooDetailedSubservices > .oooServiceContainer {
    height: 160px;
    gap: 0;
}

.oooDetailedSubservices > .oooServiceContainer > .oooDesciptionHeader {
    height: 0;
}

.oooDetailedSubservices > .oooServiceContainer > .oooDescriptionBody > .oooDescriptionShort {
    display: none;
}

.oooServiceContainer > .oooDescriptionBody > .oooKeywords {
    display: none;
}

.oooDetailedSubservices > .oooServiceContainer .oooServiceInformation {
    width: 233px;
    flex-grow: 0;
}

.oooDetailedSubservices > .oooServiceContainer .oooServiceActionEntry {
    max-width: 255px;
}

.oooDetailedSubservices > .oooServiceContainer .oooServiceActions {
    max-height: 118px;
}

.oooDesciptionHeader {
    box-sizing: border-box;
    display: flex;
    flex-direction: row;
    align-items: flex-start;
    position: relative;
    padding: 24px;
    isolation: isolate;
    width: 319px;
    height: 72px;
    border: 0px solid rgba(127, 128, 157, 0.16);
    flex: none;
    order: 0;
    align-self: stretch;
    flex-grow: 0;
    z-index: 2;
}

.oooDesciptionHeader i {
    padding: 5px;
}

.oooServiceName {
    font-size: 16px;
    flex-grow: 1;
}

.oooServiceActions {
    user-select: none;
    position: absolute;
    right: 15%;
    top: 20%;
    padding: 16px 0px;
    display: flex;
    flex-direction: column;
    align-items: flex-start;
    background: #FFFFFF;
    box-shadow: 0px 6px 12px rgb(0 0 0 / 16%);
    border-radius: 10px;
    cursor: initial;
    max-height: 234px;
    overflow-y: auto;
}

.oooServiceActionEntry {
    box-sizing: border-box;
    display: flex;
    flex-direction: row;
    align-items: center;
    padding: 14px 24px 11px;
    gap: 16px;
    width: auto;
    max-width: 270px;
    height: 41px;
    flex: none;
    order: 1;
    align-self: stretch;
    flex-grow: 0;
}

.oooServiceActionEntry:hover {
    background: var(--colBGLight);
    color: var(--colMainLight);
    cursor: pointer;
} 

/* Apply border-bottom to the last element with the class .oooServiceActionCreate in the list */
.oooServiceActionSubservices {
    border-top: 0.6px solid #E5E5EB;
}

.oooDescriptionBody { 
    overflow: hidden; */
    display: flex;
    flex-direction: column;
    justify-content: center;
    align-items: flex-start;
    padding: 16px 24px;
    gap: 4px;
    flex: none;
    order: 1;
    align-self: stretch;
    flex-grow: 1;
    z-index: 1;
    font-size: 12px;
    color: var(--colTextLight);
}

.oooServiceBottom {
    box-sizing: border-box;
    display: flex;
    flex-direction: row;
    align-items: flex-end;
    padding: 16px 24px;
    height: 48px;
    border-top: 1px solid rgba(127, 128, 157, 0.16);
    flex: none;
    order: 2;
    align-self: stretch;
    flex-grow: 0;
    z-index: 0;
    color: var(--colTextLight);
}

.oooServiceInformation { 
    display: flex;
    flex-direction: row;
    align-items: center;
    padding: 0px;
    gap: 8px;
    width: 257px;
    height: 16px;
    flex: none;
    order: 0;
    flex-grow: 1;
}

.oooServiceBottom:hover {
    background: var(--colMainLight);
    border-radius: 0 0 10px 10px;
    color: #ffffff;
}

.oooCreate { 
    grid-area: 3 / 2 / 5 / 3;
}

.oooCreate {
    color: #001bff;
    color: var(--colMainLight);
    background: #ffffff;
    font-size: 24px;
    box-shadow: 0 1px 4px 0 rgba(4, 0, 71, 0.16);
    box-shadow: 0 1px 4px 0 var(--colShadowDark);
    border-radius: 5px;
}

.oooCreate > i, .oooServiceInformation > i {
    display: block;
    width: 24px;
    height: 24px;
    padding: 8px;
}

.oooSubservices { 
    text-decoration-line: underline;
    color: var(--colTextLight);
    font-size: 16px;
    line-height: 150%;
}

.oooSubservices:hover {
    color: var(--colMainLight);
}

.oooDetailedLeft {
    position: absolute;
    width: 750px;
    height: 599px;
    left: 44px;
    top: 100px;
    overflow-y: hidden;
    overflow-x: hidden;
}

.oooDetailedRight {
    box-sizing: border-box;
    display: flex;
    flex-direction: column;
    justify-content: flex-end;
    align-items: flex-end;
    padding: 0px;
    gap: 16px;
    position: absolute;
    width: 396px;
    height: 704px;
    right: 0px;
    bottom: 0px;
}

.oooDetailedServiceName {
    left: 7px;
    position: relative;
    margin: 10px 0;
}

.oooDetailedServiceName > p {
    line-height: 1.3;
}

.oooDetailedServiceName > h2 {
    font-size: 24px;
}

.oooDetailedDescriptionLong > * {
    width: 100%;
    max-height: 450px;
    min-height: 300px;
}

.oooDetailedSubtitle {
    padding-bottom: 8px;
}

.oooSLALabel + * {
    padding-top: 8px;
}

.oooDetailedAdditionalInformation > div:last-child {
    margin-top: 15px;
}

.oooDetailedTicketTypeList {
    width: 364px;
    height: 100px;
    flex: none;
    order: 0;
    align-self: stretch;
    flex-grow: 1;
    z-index: 1;
}

.oooDetailedTicketTypeList > a {
    box-sizing: border-box;
    display: inline-flex;
    flex-direction: column;
    margin: 3px;
    align-items: center;
    padding: 16px 32px;
    gap: 8px;
    width: 110.67px;
    height: 100px;
    top: 0px;
    border: 1px solid rgba(127, 128, 157, 0.16);
    border-radius: 10px;
}

.oooDetailedTicketTypeList > a:hover > i {
    color: var(--colMainLight);
}

.oooDetailedTicketTypeList > a > span {
    font-size: 12px;
    line-height: 15px;
    text-align: center;
}

.oooDetailedTicketTypeList > a > i {
    color: var(--colMainLight);
}

.oooDetailedAccordionList {
    display: flex;
    flex-direction: column;
    align-items: flex-start;
    padding: 16px;
    width: 323px;
    height: 524px;
    margin-bottom: 30px;
    overflow-y: auto;
    background: var(--colBGLight);
    border-radius: 10px;
    flex: none;
    order: 1;
    align-self: stretch;
    flex-grow: 0;
    z-index: 0;
}

.oooDetailedAccordion {
    display: flex;
    flex-direction: column;
    align-items: flex-start;
    padding: 24px 16px;
    border-bottom: 1px solid #7F809D08;
    flex: none;
    order: 1;
    align-self: stretch;
    flex-grow: 0;
    margin: -1px 0px;
}

.oooDetailedAccordion .oooDetailedFAQ, .oooDetailedAccordion .oooDetailedSubservices {
    margin-left: -20px;
}

.oooDetailedAccordion > .Header > .WidgetAction > a {
    position: relative;
    display: flex;
    flex-direction: row;
    align-items: center;
} 

.oooDetailedAccordion i.ooofo-arrow_d, .oooDetailedAccordion i.ooofo-arrow_u {
    position: absolute;
    right: 90px;
    top: 22px;
    left: 280px;
    margin-top: -19px;
    transform: rotate(180deg); /* fix this, should't be needed */
}

.oooDetailedAccordion i.ooofo-arrow_d {
    color: var(--colMainLight);
}

.oooDetailedAccordion h3 {
    line-height: 20px;
}

.oooDetailedAccordion.Collapsed i.ooofo-arrow_d {
    display: none;
}

.oooDetailedAccordion.Expanded i.ooofo-arrow_u {
    display: none;
}

.oooDetailedAccordion.Expanded h3, .oooDetailedAccordion .WidgetAction > a:hover {
    color: var(--colMainLight);
}

.oooDetailedAccordion .WidgetAction > a:hover > .oooNumberOfEntries {
    background: var(--colMainLight);
}

.oooDetailedAccordionCaption {
    font-weight: 700;
    font-size: 12px;
    display: flex;
}

.oooDetailedAccordion > .Content {
    padding: 25px 0px 0px;
}

.oooDetailedAccordion .oooNumberOfEntries {
    display: flex;
    flex-direction: column;
    justify-content: center;
    align-items: center;
    padding: 0px;
    gap: 8px;
    width: 16px;
    height: 16px;
    background: var(--colTextDark);
    border-radius: 40px;
    margin-left: 5px;
    margin-top: 2px;
}

.oooDetailedAccordion.Expanded .oooNumberOfEntries {
    background: var(--colMainLight);
}

.oooDetailedAccordion .oooNumberOfEntries > span {
    font-weight: 700;
    font-size: 9px;
    line-height: 11px;
    color: #ffffff;
}

.oooDetailedFAQ > a:hover {
    cursor: pointer;
}

.oooDetailedFAQItem {
    width: 288px;
    line-height: 150%;
    padding: 13px 0px 20px 20px;
    position: relative;
}

.oooDetailedFAQItem:hover {
    background: rgba(127, 128, 157, 0.04);
    border: 0px solid rgba(127, 128, 157, 0.16);
    border-radius: 10px;
}

.oooDetailedFAQ > a:hover > .oooDetailedFAQItem > .oooFAQDetailsHint {
    display: block !important;
    position: absolute;
    right: 27px;
    top: calc(50% - 27px/2 + 0.5px);
    color: var(--colMainLight);
    font-size: 10px;
}

.oooDetailedFAQ > a:hover > .oooDetailedFAQItem > .oooFAQDescription {
    background-image: linear-gradient(to right, var(--colTextDark) 0%, transparent);
    -webkit-background-clip: text;
    -webkit-text-fill-color: transparent;
}

.oooFAQDescription {
    font-size: 12px;
}

/* TODO: Could/Should be transfered to other CSS classes */
/* Modal */
#Overlay {
    top: 0px;
}

.oooHidden {
    display: none !important;
}

.oooColor-Red {
    color: red;
}

.oooColor-Green {
    color: green;
}

.oooColor-Blue {
    color: blue;
}

.oooColor-Yellow {
    color: yellow;
}

.ooofo-bang::before {
    content: '!';
    font-weight: bold;
} 

.Dialog {
    max-height: calc(100vh - 50px);
    overflow-y: auto;
    background-color: var(--colBGLight);
    background-color: var(--colBGLight);
    width: 95%;
    max-width: 1212px;
}

.Dialog.oooServiceCatalogModal > .Content {
    padding: 20px 48px 16px 100px;
}

.Dialog > .Header {
    background: #ffffff;
    padding: 16px 0px 0px 100px;
}

.Dialog > .Header .Close {
    left: 56px;
    top: 46px;
}

.Dialog > .Header .ooofo {
    top: 5px;
    font-size: 16px;
}

.Dialog:not(.oooDetailedView) > .Header .ooofo {
    top: 40px;
}

.Dialog > .Header #ServiceID_Search {
    width: 220px !important;
    background: transparent;
    border-radius: 30px 2px 2px 30px;
    border: 1px solid var(--colTextLight);
    box-shadow: 0px 29px 49px 8px rgb(0 0 0 / 4%);
}

.Dialog > .Header #ServiceID_Search:hover, .Dialog > .Header .InputField_Selection:hover {
    cursor: default;
}

.Dialog > .Header .oooServiceFieldSearch > input {
    border-radius: 30px;
    background: #ffffff;
    height: 60px;
    padding-left: 40px;
}

.Dialog > .Header #ServiceID_Search:before {
    font-family: FontAwesome;
    content: "\f002";
    position: absolute;
    top: 3px;
    right: 5px;
    width: 15px;
    pointer-events: none;
    z-index: 5;
    color: #27414f;
}

.Dialog > .Header #ServiceID_Search + .InputField_Selection {
    padding: 0;
    width: 150px;
    left: 25px !important;
    background: transparent;
}

.Dialog > .Header #ServiceID_Search + .InputField_Selection:before {
    content: "\e902";
    font-family: 'otobo';
    position: absolute;
    top: 7px;
    right: -50px;
    color: var(--colTextLight);
}

.Dialog > .Header #ServiceID_Search > div {
    content: "\e902";
    font-family: 'otobo';
    position: absolute;
    right: -50px;
}

.Dialog > .Header .InputField_Selection .Remove {
    display: none;
}

.Dialog > .Header .InputField_Selection .Text {
    width: 230px;
    text-align: left;
    height: 45px;
}

.Dialog > .Header .InputField_Container > .InputField_InputContainer > .FocusField, .Dialog > .Header .InputField_Container > .InputField_InputContainer i.fa-times-circle {
    display: none;
}

.Dialog + .InputField_ListContainer {
    z-index: 99999;
    display: block;
    margin-top: 11px;
}

.Dialog + .InputField_ListContainer .InputField_TreeContainer {
    margin: 0;
    border-radius: 10px;
}

.Dialog + .InputField_ListContainer .InputField_TreeContainer .jstree-node:not(:last-child) {
    border-bottom: 1px solid var(--colBGLight);
}

.Dialog + .InputField_ListContainer .InputField_TreeContainer a.jstree-anchor {
    color: var(--colTextLight);
}

.Dialog + .InputField_ListContainer .InputField_TreeContainer .jstree-InputField .jstree-wholerow-ul .jstree-wholerow-clicked {
    background-color: var(--colBGLight);
}

.Dialog + .InputField_ListContainer > .oooClose {
    display: none;
}

.oooServiceField, .oooServiceFieldSearch {
    display: block;
    width: auto;
    height: 58px;
    left: 0px;
    border-radius: 10px;
}

.oooServiceFieldSearch > input {
    width: 90%;
}

.oooServiceFieldSearch:after {
    font-family: FontAwesome;
    content: "\f002";
    position: relative;
    right: 50px;
    font-size: 16px;
    color: var(--colTextLight);
    cursor: text;
}

#oooDetailedToggleSidebar {
    display: none;
}

/* TODO: This should be added to the otobo.svg */
.ooofo-loupe::before {
    content: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' height='48' width='48'%3E%3Cpath d='M24 34.1q.65 0 1.075-.425.425-.425.425-1.075v-6.9h6.9q.65 0 1.075-.425.425-.425.425-1.075 0-.65-.425-1.075-.425-.425-1.075-.425h-6.9v-6.9q0-.65-.425-1.075Q24.65 14.3 24 14.3q-.65 0-1.075.425-.425.425-.425 1.075v6.9h-6.9q-.65 0-1.075.425-.425.425-.425 1.075 0 .65.425 1.075.425.425 1.075.425h6.9v6.9q0 .65.425 1.075.425.425 1.075.425Zm0 9.9q-4.15 0-7.8-1.575-3.65-1.575-6.35-4.275-2.7-2.7-4.275-6.35Q4 28.15 4 24t1.575-7.8Q7.15 12.55 9.85 9.85q2.7-2.7 6.35-4.275Q19.85 4 24 4t7.8 1.575q3.65 1.575 6.35 4.275 2.7 2.7 4.275 6.35Q44 19.85 44 24v15.9q0 1.7-1.2 2.9T39.9 44Zm0-3q7.1 0 12.05-4.95Q41 31.1 41 24q0-7.1-4.95-12.05Q31.1 7 24 7q-7.1 0-12.05 4.95Q7 16.9 7 24q0 7.1 4.95 12.05Q16.9 41 24 41Zm0-16.8Z'/%3E%3C/svg%3E");
    zoom: 0.3;
}

.ooofo-subscription::before {
    content: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' height='48' width='48'%3E%3Cpath d='M15.5 7q-.65 0-1.075-.425Q14 6.15 14 5.5q0-.65.425-1.075Q14.85 4 15.5 4h17q.65 0 1.075.425Q34 4.85 34 5.5q0 .65-.425 1.075Q33.15 7 32.5 7Zm-6.55 6q-.65 0-1.075-.425-.425-.425-.425-1.075 0-.65.425-1.075Q8.3 10 8.95 10h30.1q.65 0 1.075.425.425.425.425 1.075 0 .65-.425 1.075Q39.7 13 39.05 13ZM7 44q-1.2 0-2.1-.9Q4 42.2 4 41V19q0-1.2.9-2.1.9-.9 2.1-.9h34q1.2 0 2.1.9.9.9.9 2.1v22q0 1.2-.9 2.1-.9.9-2.1.9Zm0-3h34V19H7v22Zm15.7-5.15 6.85-4.6q.7-.45.7-1.25t-.7-1.25l-6.85-4.6q-.75-.55-1.55-.1-.8.45-.8 1.35v9.25q0 .9.8 1.3t1.55-.1ZM7 19v22-22Z'/%3E%3C/svg%3E");
    zoom: 0.3;
}

.oooTile_ServiceCatalog {
    padding: 24px 32px;
}

@media only screen and (min-width: 880px) and (max-width: 1279px) {

    .oooServiceBreadcrumb {
        width: calc(100% - 200px);
    }

    .oooScrollLeft {
        left: 114px;
    } 

    .oooParentServiceList {
        max-width: 864px;
    }
}

@media only screen and (min-width: 768px) and (max-width: 879px) {
    
    .oooParentServiceList {
        flex-direction: row;
        align-items: flex-start;
        padding: 0px;
        gap: 8px;
        /* width: 100%;
        max-width: 420px; */
        height: 128px;
        overflow-x: scroll;
        flex: none;
        order: 1;
        flex-grow: 0;
        z-index: 0;
    }

    .oooParentServiceList > li {
        flex-direction: row;
        width: 274.75px;
        flex: none;
        order: 0;
        align-self: stretch;
        flex-grow: 0;
    }

    .oooServiceBreadcrumbField {
        width: 530px;
    }

    .oooScrollLeft {
        left: 114px;
    } 
}

@media only screen and (max-width: 1279px) {
    .Dialog:not(.oooDetailedView) > .Header .ooofo {
        top: 5px;
    }

    .oooServiceBreadcrumbWrap {
        background: var(--colBGLight);
    }

    .oooDetailedView .oooServiceBreadcrumbWrap {
        background: transparent;
    }

    .oooParentServiceList {
        flex-direction: row;
        align-items: flex-start;
        padding: 0px;
        gap: 8px;
        /* width: 100%;
        max-width: 420px; */
        height: 128px;
        overflow-x: scroll;
        flex: none;
        order: 1;
        flex-grow: 0;
        z-index: 0;
    }

    .oooBreadcrumbServiceList {
        max-width: 320px;
    }

    .oooParentServiceList > li {
        flex-direction: row;
        width: 274.75px;
        flex: none;
        order: 0;
        align-self: stretch;
        flex-grow: 0;
    }

    .oooServiceBreadcrumb {
        left: 20px;
        width: 100%
        /* max-width: 320px; */
    }

    .oooServiceResult {
        display: none;
    }

    .oooServiceContainer:hover, .oooDetailedTicketTypeList > a:hover {
        /* width: 100%; */
        left: 0 !important;
        top: 50px !important;
    }

    .oooDetailedDescriptionLong > * {
        width: 80vw;
    }

    .Dialog {
        left: 0 !important;
        width: 100%;
        top: 50px !important;
        bottom: 0;
    }

    .Dialog.oooServiceCatalogModal {
        height: 100%;
    }

    .Dialog.oooServiceCatalogModal > .Content {
        padding: 20px 48px 16px 50px;
    }

    .Dialog > .Header {
        padding: 0;
    overflow: hidden;
    }

    .Dialog > .Header .Close {
        width: 100%;
        height: 30px;
        left: 0;
        top: 0;
    }

    .Dialog > .Header .ooofo {
        position: absolute;
        width: 4px;
        height: 40px;
        background: #E5E5EB;
        left: 50%;
        transform: rotate(90deg);
        border-radius: 20px;
    }

    .Dialog > .Header .Close .ooofo-close:before {
        display: none;
    }

    .Dialog > .Header .oooServiceFieldSearch > input {
        border-radius: 0;
        border: none;
        width: 100%;
        height: 100%;
        border-bottom: 1px solid rgba(127, 128, 157, 0.16);
    }

    .oooServiceFieldSearch:after {
        right: 100px;
    }

    .oooServiceFieldSearch {
        margin-top: 0;
        height: 88px;
        background: #ffffff;
    }

    .Dialog.oooDetailedView > .Header {
        width: 100%;
    }

    .oooTile_ServiceCatalog > h2 {
        display: flex;
    }

    .oooDetailedRight {
        display: none;
        position: initial;
        width: calc(100% - 25px);
    }

    #oooDetailedToggleSidebar {
        display: block;
    }

    #oooDetailedToggleSidebar > button {
        position: fixed;
        bottom: 32px;
        right: 16px;
        width: 48px;
        z-index: 600;
        box-shadow: 0 12px 16px 0 rgb(0 27 255 / 24%);
        box-shadow: 0 12px 16px 0 val(--colShadowMain);
    }

    .oooDetailedTicketTypeList, .oooDetailedAccordionList {
        margin-top: 30px;
    }
}

@media only screen and (max-width: 435px) {
    
    .oooParentServiceList {
        max-width: 360px;
        padding: 3px;
    }

    .oooDetailedLeft {
        width: 300px;
    }

    .oooDetailedRight {
        width: 375px;
    }

    .Dialog.oooServiceCatalogModal > .Content {
        padding: 0 20px;
    }
}
 <?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
<svg xmlns="http://www.w3.org/2000/svg">
<metadata>Generated by IcoMoon</metadata>
<defs>
<font id="otobo" horiz-adv-x="1024">
<font-face units-per-em="1024" ascent="960" descent="-64" />
<missing-glyph horiz-adv-x="1024" />
<glyph unicode="&#x20;" horiz-adv-x="512" d="" />
<glyph unicode="&#xe900;" glyph-name="add" d="M846.36 392.265h-278.626v-278.626c-0.653-30.276-25.351-54.569-55.723-54.569s-55.069 24.293-55.722 54.508l-0.001 0.061v278.626h-278.65c-0.347-0.008-0.756-0.012-1.166-0.012-30.782 0-55.735 24.953-55.735 55.735s24.953 55.735 55.735 55.735c0.41 0 0.819-0.004 1.226-0.013l-0.061 0.001h278.626v278.65c-0.008 0.347-0.012 0.756-0.012 1.166 0 30.782 24.953 55.735 55.735 55.735s55.735-24.953 55.735-55.735c0-0.41-0.004-0.819-0.013-1.226l0.001 0.061v-278.626h278.65c30.276-0.653 54.569-25.351 54.569-55.723s-24.293-55.069-54.508-55.722l-0.061-0.001z" />
<glyph unicode="&#xe901;" glyph-name="archive" d="M876.38 736.85l-59.392 71.68c-11.444 14.354-28.928 23.472-48.542 23.472-0.157 0-0.313-0.001-0.47-0.002h-511.976c-0.063 0-0.137 0-0.212 0-19.841 0-37.556-9.101-49.198-23.356l-0.090-0.114-58.88-71.68c-12.203-14.427-19.621-33.241-19.621-53.788 0-0.141 0-0.282 0.001-0.423v0.022-533.32c0.139-47.076 38.264-85.201 85.327-85.34h597.333c47.076 0.139 85.201 38.264 85.34 85.327v533.333c0.001 0.119 0.001 0.261 0.001 0.402 0 20.547-7.418 39.362-19.722 53.911l0.101-0.123zM497.070 228.27l-219.73 219.73h149.34v85.34h170.66v-85.34h149.34l-219.75-219.73c-3.85-3.758-9.119-6.076-14.93-6.076s-11.080 2.318-14.934 6.080l0.004-0.004zM218.46 746.66l34.468 42.68h512l40.1-42.66z" />
<glyph unicode="&#xe902;" glyph-name="arrow_d" d="M127.57 645.12c-9.704-9.647-15.709-23.005-15.709-37.765s6.006-28.118 15.707-37.763l354.553-354.553c7.693-7.706 18.327-12.472 30.075-12.472s22.382 4.767 30.074 12.472l354.571 354.551c9.667 9.664 15.646 23.016 15.646 37.765 0 29.492-23.908 53.401-53.401 53.401-14.744 0-28.092-5.975-37.755-15.636l-309.248-308.9-309.248 309.248c-9.616 9.521-22.85 15.403-37.458 15.403-14.781 0-28.155-6.022-37.803-15.747l-0.003-0.003z" />
<glyph unicode="&#xe903;" glyph-name="arrow_l" d="M709.12 832.43c-9.646 9.698-23 15.699-37.755 15.699s-28.109-6.002-37.753-15.697l-354.572-354.552c-7.712-7.694-12.483-18.332-12.483-30.085s4.771-22.391 12.482-30.084l354.551-354.571c9.664-9.667 23.016-15.646 37.765-15.646 29.492 0 53.401 23.908 53.401 53.401 0 14.744-5.975 28.092-15.636 37.755l-308.9 309.248 309.248 309.248c9.527 9.617 15.413 22.855 15.413 37.468 0 14.786-6.027 28.164-15.757 37.813l-0.004 0.004z" />
<glyph unicode="&#xe904;" glyph-name="arrow_r" d="M314.88 832.43c9.646 9.698 23 15.699 37.755 15.699s28.109-6.002 37.753-15.697l354.572-354.552c7.712-7.694 12.483-18.332 12.483-30.085s-4.771-22.391-12.482-30.084l-354.633-354.571c-9.662-9.662-23.011-15.639-37.755-15.639-29.488 0-53.393 23.905-53.393 53.393 0 14.744 5.976 28.093 15.639 37.755v0l308.982 309.35-309.248 309.248c-9.502 9.613-15.372 22.834-15.372 37.427 0 14.755 6.002 28.109 15.697 37.753l0.002 0.002z" />
<glyph unicode="&#xe905;" glyph-name="arrow_r2" d="M417.055 197.838c-8.507 8.503-13.769 20.251-13.769 33.229s5.262 24.726 13.768 33.229l150.241 150.2h-519.967c-0.875-0.061-1.896-0.096-2.925-0.096-23.442 0-42.652 18.116-44.395 41.111l-0.009 0.15c1.774 23.148 20.993 41.258 44.442 41.258 1.016 0 2.024-0.034 3.023-0.101l-0.135 0.007h502.989l-133.263 133.243c-8.409 8.635-13.595 20.444-13.595 33.464s5.186 24.83 13.605 33.475l-0.010-0.011c8.494 8.527 20.245 13.803 33.229 13.803s24.735-5.276 33.227-13.801l216.352-216.352c8.507-8.503 13.769-20.251 13.769-33.229s-5.262-24.726-13.768-33.229l-216.371-216.351c-8.503-8.507-20.251-13.769-33.229-13.769s-24.726 5.262-33.229 13.768v0zM727.409 630.027l182.886-182.886-182.886-182.886c-9.029-8.582-14.646-20.681-14.646-34.092 0-25.958 21.043-47.002 47.002-47.002 13.416 0 25.519 5.621 34.083 14.636l0.019 0.020 216.351 216.351c8.517 8.498 13.786 20.248 13.786 33.229s-5.269 24.731-13.785 33.228l-216.352 216.331c-8.498 8.517-20.248 13.786-33.229 13.786s-24.731-5.269-33.228-13.785l-0.001-0.001c-8.418-8.63-13.611-20.441-13.611-33.464s5.193-24.834 13.621-33.474l-0.010 0.010z" />
<glyph unicode="&#xe906;" glyph-name="arrow_u" d="M127.57 250.88c-9.698 9.646-15.699 23-15.699 37.755s6.002 28.109 15.697 37.753l354.552 354.572c7.694 7.712 18.332 12.483 30.085 12.483s22.391-4.771 30.084-12.482l354.571-354.633c9.662-9.662 15.639-23.011 15.639-37.755 0-29.488-23.905-53.393-53.393-53.393-14.744 0-28.093 5.976-37.755 15.639v0l-309.35 308.982-309.248-309.248c-9.613-9.502-22.834-15.372-37.427-15.372-14.755 0-28.109 6.002-37.753 15.697l-0.002 0.002z" />
<glyph unicode="&#xe907;" glyph-name="attachment" d="M704.020 672.010v-451.42c0.014-0.828 0.022-1.804 0.022-2.783 0-89.389-66.785-163.18-153.181-174.196l-0.871-0.091c-5.079-0.537-10.972-0.844-16.937-0.844-94.094 0-170.373 76.279-170.373 170.373 0 0.102 0 0.205 0 0.307v-0.016 527.36c-0.018 0.743-0.028 1.618-0.028 2.495 0 55.826 41.303 102.006 95.019 109.646l0.59 0.069c3.323 0.367 7.177 0.577 11.080 0.577 58.918 0 106.68-47.762 106.68-106.68 0-0.052 0-0.103 0-0.155v0.008-447.98c0-23.566-19.104-42.67-42.67-42.67s-42.67 19.104-42.67 42.67v0 373.33c-0.452 17.327-14.606 31.201-32 31.201s-31.548-13.874-31.999-31.159l-0.001-0.042v-367.37c-0.018-0.743-0.028-1.618-0.028-2.495 0-55.826 41.303-102.006 95.019-109.646l0.59-0.069c3.323-0.367 7.177-0.577 11.080-0.577 58.918 0 106.68 47.762 106.68 106.68 0 0.052 0 0.103 0 0.155v-0.008 440.73c0.014 0.828 0.022 1.804 0.022 2.783 0 89.389-66.785 163.18-153.181 174.196l-0.871 0.091c-5.011 0.522-10.826 0.821-16.712 0.821-94.219 0-170.598-76.38-170.598-170.598 0-0.008 0-0.015 0-0.023v0.001-523.53c0-122.45 89.6-232.1 211.62-243.712 6.847-0.709 14.794-1.113 22.835-1.113 129.723 0 234.885 105.162 234.885 234.885 0 0.046 0 0.091 0 0.137v-0.007 458.752c-0.452 17.327-14.606 31.201-32 31.201s-31.548-13.874-31.999-31.159l-0.001-0.042z" />
<glyph unicode="&#xe908;" glyph-name="boxcheck_ed" d="M97.524 960c-53.185 0-97.524-44.339-97.524-97.524v-828.952c0-53.185 44.339-97.524 97.524-97.524h828.952c53.185 0 97.524 44.339 97.524 97.524v828.952c0 53.185-44.339 97.524-97.524 97.524h-828.952zM97.524 862.476h828.952v-828.952h-828.952v828.952zM745.89 630.906c-0.183 0.002-0.398 0.004-0.614 0.004-13.467 0-25.658-5.461-34.481-14.289l-258.334-258.334-102.19 102.143c-8.822 8.826-21.012 14.285-34.476 14.285s-25.654-5.459-34.476-14.285v0c-8.811-8.82-14.261-21-14.261-34.452s5.449-25.633 14.261-34.453v0l136.667-136.667c8.823-8.824 21.012-14.283 34.476-14.283s25.654 5.458 34.476 14.283l292.81 292.81c8.826 8.822 14.285 21.012 14.285 34.476s-5.459 25.654-14.285 34.476v0c-8.679 8.685-20.618 14.111-33.824 14.285h-0.033z" />
<glyph unicode="&#xe909;" glyph-name="boxcheck_ooo" d="M133.337 896c-73.048-0.205-133.128-60.285-133.333-133.333 0-0.019 0-0.041 0-0.063s0-0.044 0-0.066v0.003-627.292c0-0.019 0-0.041 0-0.063s0-0.044 0-0.066v0.003c0.205-73.048 60.285-133.128 133.333-133.333 0.012 0 0.027 0 0.042 0s0.029 0 0.044 0h627.331c0.019 0 0.041 0 0.063 0s0.044 0 0.066 0h-0.003c73.048 0.205 133.128 60.285 133.333 133.333 0 0.019 0 0.041 0 0.063s0 0.044 0 0.066v-0.003 267.75c0 23.564-19.103 42.667-42.667 42.667v0c-23.564 0-42.667-19.103-42.667-42.667v0-267.667c-0.076-27.1-21.149-48.132-48.25-48.208h-627.083c-27.1 0.076-48.132 21.108-48.208 48.208v627.125c0.076 27.101 21.108 48.132 48.208 48.208h566.875c23.564 0 42.667 19.103 42.667 42.667v0c0 23.564-19.103 42.667-42.667 42.667v0h-567c-0.012 0-0.027 0-0.042 0s-0.029 0-0.044 0h0.002zM955.59 827.733c-0.158 0.002-0.345 0.003-0.532 0.003-11.785 0-22.455-4.778-30.176-12.503l-480.083-480.083c-7.732-7.723-12.514-18.397-12.514-30.187s4.783-22.465 12.514-30.187v0c7.721-7.719 18.386-12.494 30.167-12.494s22.446 4.774 30.167 12.494l480.125 480.125c7.719 7.721 12.494 18.386 12.494 30.167s-4.774 22.446-12.494 30.167v0c-7.604 7.607-18.067 12.357-29.64 12.5h-0.027zM280.499 542.656c-0.158 0.002-0.345 0.003-0.532 0.003-11.785 0-22.455-4.778-30.176-12.503v0c-7.719-7.721-12.494-18.386-12.494-30.167s4.774-22.446 12.494-30.167l65.417-65.417c7.721-7.719 18.386-12.494 30.167-12.494s22.446 4.774 30.167 12.494v0c7.719 7.721 12.494 18.386 12.494 30.167s-4.774 22.446-12.494 30.167l-65.417 65.417c-7.595 7.598-18.041 12.345-29.596 12.5h-0.029z" />
<glyph unicode="&#xe90a;" glyph-name="boxcheck_semi" d="M97.524 960c-53.185 0-97.524-44.339-97.524-97.524v-828.952c0-53.185 44.339-97.524 97.524-97.524h828.952c53.185 0 97.524 44.339 97.524 97.524v828.952c0 53.185-44.339 97.524-97.524 97.524h-828.952zM97.524 862.476h828.952v-828.952h-828.952v828.952zM719.19 484.619l-388.667-0.238c-26.91-0.027-48.714-21.848-48.714-48.762 0-0.017 0-0.034 0-0.050v0.003c0.027-26.91 21.848-48.714 48.762-48.714l388.667 0.238c26.91 0.027 48.714 21.848 48.714 48.762v0c0 26.93-21.831 48.762-48.762 48.762v0z" />
<glyph unicode="&#xe90b;" glyph-name="boxcheck" d="M97.524 862.476v-828.952h828.952v828.952h-828.952zM97.524 960h828.952c53.861 0 97.524-43.663 97.524-97.524v0-828.952c0-53.861-43.663-97.524-97.524-97.524v0h-828.952c-53.861 0-97.524 43.663-97.524 97.524v0 828.952c0 53.861 43.663 97.524 97.524 97.524v0z" />
<glyph unicode="&#xe90c;" glyph-name="calendar" d="M806.011 825.979h-46.551v46.531c0 25.698-20.832 46.531-46.531 46.531s-46.531-20.832-46.531-46.531v-46.531h-372.285v46.531c0 25.698-20.832 46.531-46.531 46.531s-46.531-20.832-46.531-46.531v0-46.531h-46.551c-51.153-0.023-92.611-41.496-92.611-92.652 0-0.144 0-0.288 0.001-0.432v0.022l-0.451-651.51c0-0.006 0-0.013 0-0.020 0-51.385 41.656-93.041 93.041-93.041 0.007 0 0.014 0 0.022 0h651.509c51.331 0.162 92.899 41.73 93.061 93.046v651.505c-0.151 51.339-41.723 92.919-93.045 93.082h-0.016zM806.011 127.959c-0.070-25.681-20.87-46.481-46.544-46.551h-558.415c-25.665 0.081-46.449 20.865-46.531 46.523v465.355h651.489zM247.583 500.224h93.061v-93.061h-93.061zM433.725 500.224h93.061v-93.061h-93.061zM619.868 500.224h93.061v-93.061h-93.061z" />
<glyph unicode="&#xe90d;" glyph-name="close" d="M875.276 810.715c-10.396 10.423-24.772 16.872-40.655 16.872s-30.259-6.449-40.654-16.871l-0.001-0.001-281.966-281.405-281.99 281.966c-10.312 9.905-24.344 16.005-39.801 16.005-31.751 0-57.49-25.739-57.49-57.49 0-15.457 6.1-29.489 16.024-39.82l-0.018 0.019 281.966-281.99-281.966-281.99c-9.905-10.312-16.005-24.344-16.005-39.801 0-31.751 25.739-57.49 57.49-57.49 15.457 0 29.489 6.1 39.82 16.024l-0.019-0.018 281.99 281.966 281.99-281.966c10.312-9.905 24.344-16.005 39.801-16.005 31.751 0 57.49 25.739 57.49 57.49 0 15.457-6.1 29.489-16.024 39.82l0.018-0.019-281.966 281.99 281.966 281.99c10.164 10.405 16.434 24.652 16.434 40.363s-6.27 29.958-16.445 40.374l0.011-0.011z" />
<glyph unicode="&#xe90e;" glyph-name="dashboard" d="M170.66 405.34h256c23.532 0.070 42.59 19.127 42.66 42.653v341.347c-0.070 23.532-19.127 42.59-42.653 42.66h-256.007c-23.532-0.070-42.59-19.127-42.66-42.653v-341.347c0.070-23.532 19.127-42.59 42.653-42.66h0.007zM170.66 64h256c23.532 0.070 42.59 19.127 42.66 42.653v170.687c-0.070 23.532-19.127 42.59-42.653 42.66h-256.007c-23.532-0.070-42.59-19.127-42.66-42.653v-170.667c0.058-23.541 19.12-42.611 42.653-42.68h0.007zM597.32 64h256c23.541 0.058 42.611 19.12 42.68 42.653v341.347c-0.070 23.532-19.127 42.59-42.653 42.66h-256.007c-23.532-0.070-42.59-19.127-42.66-42.653v-341.347c0.070-23.532 19.127-42.59 42.653-42.66h0.007zM554.66 789.34v-170.66c0.058-23.548 19.132-42.622 42.675-42.68h256.006c23.532 0.070 42.59 19.127 42.66 42.653v170.687c-0.070 23.532-19.127 42.59-42.653 42.66h-256.007c-23.541-0.058-42.611-19.12-42.68-42.653v-0.007z" />
<glyph unicode="&#xe90f;" glyph-name="delete_outl" d="M292.577 199.107c0.7-39.422 32.822-71.111 72.345-71.111 0.277 0 0.554 0.002 0.831 0.005h292.535c0.234-0.003 0.512-0.004 0.789-0.004 39.523 0 71.645 31.689 72.344 71.045l0.001 0.066v355.553c-0.7 39.422-32.822 71.111-72.345 71.111-0.277 0-0.554-0.002-0.831-0.005h-292.535c-0.234 0.003-0.512 0.004-0.789 0.004-39.523 0-71.645-31.689-72.344-71.045l-0.001-0.066zM402.289 554.66h219.423c0.117 0.001 0.256 0.002 0.395 0.002 19.764 0 35.827-15.843 36.182-35.522v-284.48c-0.356-19.712-16.419-35.555-36.183-35.555-0.139 0-0.277 0.001-0.416 0.002h-219.402c-0.117-0.001-0.256-0.002-0.395-0.002-19.764 0-35.827 15.843-36.182 35.522v284.48c0.356 19.712 16.419 35.555 36.183 35.555 0.139 0 0.277-0.001 0.416-0.002h-0.021zM640 732.447l-25.969 25.313c-6.663 6.313-15.673 10.205-25.593 10.24h-152.87c-9.927-0.035-18.937-3.927-25.617-10.256l0.017 0.016-25.969-25.313h-91.423c-0.36 0.013-0.782 0.020-1.207 0.020-19.647 0-35.574-15.927-35.574-35.574s15.927-35.574 35.574-35.574c0.424 0 0.847 0.007 1.268 0.022l-0.061-0.002h438.845c0.36-0.013 0.782-0.020 1.207-0.020 19.647 0 35.574 15.927 35.574 35.574s-15.927 35.574-35.574 35.574c-0.424 0-0.847-0.007-1.268-0.022l0.061 0.002z" />
<glyph unicode="&#xe910;" glyph-name="delete" d="M255.98 149.34c0.139-47.076 38.264-85.201 85.327-85.34h341.353c47.076 0.139 85.201 38.264 85.34 85.327v426.673c-0.139 47.076-38.264 85.201-85.327 85.34h-341.353c-47.076-0.139-85.201-38.264-85.34-85.327v-0.013zM767.98 789.34h-106.66l-30.208 30.372c-7.714 7.563-18.277 12.244-29.933 12.288h-178.369c-11.635-0.067-22.165-4.744-29.867-12.295l0.007 0.007-30.29-30.372h-106.68c-23.566 0-42.67-19.104-42.67-42.67s19.104-42.67 42.67-42.67h512c23.566 0 42.67 19.104 42.67 42.67s-19.104 42.67-42.67 42.67v0z" />
<glyph unicode="&#xe911;" glyph-name="faq" d="M855.941 705.864h-43.008v-343.839c-0.058-23.729-19.279-42.95-43.002-43.008h-515.774v-43.008c0.128-47.454 38.562-85.888 86.004-86.016h429.805l172.032-172.032v601.989c-0.186 47.424-38.621 85.809-86.047 85.914h-0.010zM726.917 490.824v301.056c-0.128 47.454-38.562 85.888-86.004 86.016h-472.772c-47.454-0.128-85.888-38.562-86.016-86.004v-558.85l172.032 172.032h386.826c47.409 0.139 85.81 38.511 85.995 85.896v0.018z" />
<glyph unicode="&#xe912;" glyph-name="filter_list" d="M469.34 192h85.34c23.566 0 42.67 19.104 42.67 42.67s-19.104 42.67-42.67 42.67h-85.34c-23.566 0-42.67-19.104-42.67-42.67s19.104-42.67 42.67-42.67v0zM128 661.34c0.070-23.532 19.127-42.59 42.653-42.66h682.687c23.566 0 42.67 19.104 42.67 42.67s-19.104 42.67-42.67 42.67h-682.68c-23.539-0.070-42.602-19.139-42.66-42.675v-0.006zM298.66 405.34h426.68c23.566 0 42.67 19.104 42.67 42.67s-19.104 42.67-42.67 42.67h-426.68c-23.566 0-42.67-19.104-42.67-42.67s19.104-42.67 42.67-42.67v0z" />
<glyph unicode="&#xe913;" glyph-name="filter" d="M46.545 925.091c-25.704-0.006-46.539-20.845-46.539-46.55 0-11.088 3.877-21.271 10.349-29.267l-0.069 0.088 349.324-434.318v-395.727c0.010-25.701 20.847-46.533 46.55-46.533 7.020 0 13.676 1.554 19.645 4.336l-0.286-0.12 202.449 92.726c16.17 7.528 27.178 23.638 27.183 42.319v302.684l358.214 434.181c6.628 7.984 10.65 18.339 10.65 29.633 0 25.709-20.841 46.55-46.55 46.55-0.004 0-0.007 0-0.011 0h0.001zM143.732 832h734.953l-305.99-370.956c-6.619-7.981-10.636-18.329-10.636-29.615 0-0.007 0-0.014 0-0.021v0.001-289.501l-109.359-50.090v339.591c-0.001 11.090-3.88 21.273-10.355 29.269l0.068-0.087z" />
<glyph unicode="&#xe914;" glyph-name="help" d="M512.020 861.020c-0.006 0-0.013 0-0.020 0-228.105 0-413.020-184.915-413.020-413.020s184.915-413.020 413.020-413.020c228.105 0 413.020 184.915 413.020 413.020v0c-0.082 228.065-184.937 412.927-412.991 413.020h-0.009zM512.020 117.596c-182.477 0-330.404 147.927-330.404 330.404s147.927 330.404 330.404 330.404c182.477 0 330.404-147.927 330.404-330.404v0c-0.256-182.374-148.030-330.148-330.38-330.404h-0.024zM470.712 282.808h82.596v-82.596h-82.596zM537.272 694.17c-7.469 1.196-16.080 1.879-24.85 1.879-74.102 0-136.815-48.762-157.803-115.949l-0.315-1.171c-1.020-3.248-1.607-6.983-1.607-10.855 0-20.687 16.77-37.458 37.458-37.458 0.032 0 0.064 0 0.097 0h8.187c17.056 0.64 31.313 11.931 36.355 27.387l0.079 0.281c11.818 32.15 42.174 54.67 77.789 54.67 6.061 0 11.97-0.652 17.661-1.89l-0.546 0.1c37.501-8.756 65.007-41.902 65.007-81.473 0-1.858-0.061-3.701-0.18-5.529l0.013 0.249c-4.096-55.296-66.908-67.318-101.192-118.948 0-0.41-0.41-0.41-0.41-0.819-0.41-0.819-0.819-1.249-1.249-2.048-3.61-5.843-7.047-12.635-9.91-19.721l-0.33-0.923c-0.41-1.249-1.229-2.048-1.659-3.297-0.277-0.757-0.559-1.723-0.785-2.711l-0.034-0.177c-5.201-14.77-8.206-31.801-8.206-49.534 0-0.737 0.005-1.473 0.016-2.207l-0.001 0.111h82.596c-0.001 0.191-0.002 0.417-0.002 0.642 0 16.024 4.296 31.045 11.799 43.974l-0.225-0.42c0.819 1.229 1.229 2.478 2.048 3.727 3.643 6.093 7.464 11.361 11.695 16.264l-0.124-0.147c0.41 0.41 0.819 1.229 1.249 1.659 4.307 5.070 8.759 9.658 13.493 13.937l0.126 0.112c39.506 37.519 93.266 68.014 82.063 146.964-10.148 73.083-65.996 130.624-137.35 143.212l-1.013 0.148z" />
<glyph unicode="&#xe915;" glyph-name="info" d="M512 960c-282.242 0-512-229.758-512-512s229.758-512 512-512c282.242 0 512 229.758 512 512s-229.758 512-512 512zM512 870.957c234.12 0 422.957-188.837 422.957-422.957s-188.837-422.957-422.957-422.957c-234.12 0-422.957 188.837-422.957 422.957s188.837 422.957 422.957 422.957zM512 688.435c-0.005 0-0.011 0-0.017 0-28.277 0-51.2-22.923-51.2-51.2 0-0.006 0-0.012 0-0.018v0.001-22.261c0-0.005 0-0.011 0-0.017 0-28.277 22.923-51.2 51.2-51.2 0.006 0 0.012 0 0.018 0h-0.001c0.005 0 0.011 0 0.017 0 28.277 0 51.2 22.923 51.2 51.2 0 0.006 0 0.012 0 0.018v-0.001 22.261c0 0.005 0 0.011 0 0.017 0 28.277-22.923 51.2-51.2 51.2-0.006 0-0.012 0-0.018 0h0.001zM512 488.087c-0.005 0-0.011 0-0.017 0-28.277 0-51.2-22.923-51.2-51.2 0-0.006 0-0.012 0-0.018v0.001-178.087c0-0.005 0-0.011 0-0.017 0-28.277 22.923-51.2 51.2-51.2 0.006 0 0.012 0 0.018 0h-0.001c0.005 0 0.011 0 0.017 0 28.277 0 51.2 22.923 51.2 51.2 0 0.006 0 0.012 0 0.018v-0.001 178.087c0 0.005 0 0.011 0 0.017 0 28.277-22.923 51.2-51.2 51.2-0.006 0-0.012 0-0.018 0h0.001z" />
<glyph unicode="&#xe916;" glyph-name="invisible" d="M512 682.68c0.791 0.011 1.724 0.017 2.659 0.017 116.365 0 210.698-94.333 210.698-210.698 0-23.21-3.753-45.543-10.685-66.426l0.428 1.488 130.56-130.56c58.758 51.928 104.98 116.65 134.476 189.906l1.204 3.384c-76.014 188.766-257.628 319.581-469.795 319.581-55.334 0-108.589-8.898-158.414-25.341l3.569 1.020 92.59-92.59c18.681 6.142 40.204 9.859 62.541 10.237l0.189 0.003zM115.61 825.18c-7.706-7.693-12.472-18.327-12.472-30.075s4.767-22.382 12.472-30.074l83.969-83.969c-69.003-55.030-122.736-126.377-155.705-208.311l-1.212-3.411c75.719-188.884 257.216-319.876 469.324-320h0.016c66.248 0.148 129.458 12.978 187.388 36.188l-3.416-1.208 116.060-116.060c7.539-6.916 17.632-11.155 28.715-11.155 23.493 0 42.537 19.044 42.537 42.537 0 11.098-4.25 21.204-11.212 28.778l0.028-0.031-695.89 696.791c-7.772 7.717-18.479 12.486-30.3 12.486s-22.528-4.769-30.303-12.489l0.003 0.002zM512 256c-117.81 0.035-213.305 95.53-213.34 213.337v0.003c0 0.017 0 0.036 0 0.056 0 33.192 7.718 64.582 21.457 92.473l-0.547-1.229 66.99-66.99c-1.445-7.209-2.368-15.587-2.557-24.146l-0.003-0.163c0-0.049 0-0.106 0-0.164 0-70.602 57.234-127.836 127.836-127.836 0.058 0 0.115 0 0.173 0h-0.009c8.696 0.138 17.069 1.221 25.113 3.148l-0.783-0.158 66.99-66.99c-26.578-13.458-57.943-21.34-91.15-21.34-0.060 0-0.12 0-0.18 0h0.009zM638.73 483.328c-6.477 59.421-53.219 106.163-112.075 112.59l-0.565 0.050z" />
<glyph unicode="&#xe917;" glyph-name="menu" d="M163.84 202.24h655.36c22.622 0 40.96 18.338 40.96 40.96s-18.338 40.96-40.96 40.96v0h-655.36c-22.622 0-40.96-18.338-40.96-40.96s18.338-40.96 40.96-40.96v0zM163.84 407.040h655.36c22.622 0 40.96 18.338 40.96 40.96s-18.338 40.96-40.96 40.96v0h-655.36c-22.622 0-40.96-18.338-40.96-40.96s18.338-40.96 40.96-40.96v0zM122.88 652.8c0.070-22.594 18.366-40.89 40.953-40.96h655.367c22.622 0 40.96 18.338 40.96 40.96s-18.338 40.96-40.96 40.96v0h-655.36c-22.594-0.070-40.89-18.366-40.96-40.953v-0.007z" />
<glyph unicode="&#xe918;" glyph-name="more_h" d="M128 576c-70.692 0-128-57.308-128-128s57.308-128 128-128c70.692 0 128 57.308 128 128v0c-0.205 70.61-57.39 127.795-127.98 128h-0.020zM896 576c-70.692 0-128-57.308-128-128s57.308-128 128-128c70.692 0 128 57.308 128 128v0c-0.205 70.61-57.39 127.795-127.98 128h-0.020zM512 576c-70.692 0-128-57.308-128-128s57.308-128 128-128c70.692 0 128 57.308 128 128v0c-0.205 70.61-57.39 127.795-127.98 128h-0.020z" />
<glyph unicode="&#xe919;" glyph-name="more_v" d="M512 704c70.692 0 128 57.308 128 128s-57.308 128-128 128c-70.692 0-128-57.308-128-128v0c0.205-70.61 57.39-127.795 127.98-128h0.020zM512 576c-70.692 0-128-57.308-128-128s57.308-128 128-128c70.692 0 128 57.308 128 128v0c-0.205 70.61-57.39 127.795-127.98 128h-0.020zM512 192c-70.692 0-128-57.308-128-128s57.308-128 128-128c70.692 0 128 57.308 128 128v0c-0.205 70.61-57.39 127.795-127.98 128h-0.020z" />
<glyph unicode="&#xe91a;" glyph-name="pdf" d="M853.32 874.66h-512c-47.076-0.139-85.201-38.264-85.34-85.327v-512.013c0.151-47.067 38.271-85.18 85.327-85.32h512.013c47.076 0.139 85.201 38.264 85.34 85.327v512.013c-0.151 47.067-38.271 85.18-85.327 85.32h-0.013zM490.66 554.66c0-0.024 0-0.053 0-0.082 0-35.301-28.617-63.918-63.918-63.918-0.029 0-0.058 0-0.086 0h-42.675v-53.248c-0.452-17.327-14.606-31.201-32-31.201s-31.548 13.874-31.999 31.159l-0.001 0.042v181.248c0.070 23.532 19.127 42.59 42.653 42.66h64.007c0.024 0 0.053 0 0.082 0 35.301 0 63.918-28.617 63.918-63.918 0-0.029 0-0.058 0-0.086v0.005zM704 469.32c0-0.024 0-0.053 0-0.082 0-35.301-28.617-63.918-63.918-63.918-0.029 0-0.058 0-0.086 0h-85.335c-0.061-0.001-0.133-0.001-0.206-0.001-11.673 0-21.135 9.463-21.135 21.135 0 0.072 0 0.145 0.001 0.217v-0.011 213.34c-0.001 0.061-0.001 0.133-0.001 0.206 0 11.673 9.463 21.135 21.135 21.135 0.072 0 0.145 0 0.217-0.001h85.329c0.024 0 0.053 0 0.082 0 35.301 0 63.918-28.617 63.918-63.918 0-0.029 0-0.058 0-0.086v0.005zM874.66 629.33c-0.127-17.62-14.371-31.872-31.977-32.010h-32.023v-42.66h32.010c17.327-0.452 31.201-14.606 31.201-32s-13.874-31.548-31.159-31.999l-0.042-0.001h-32.010v-53.248c-0.452-17.327-14.606-31.201-32-31.201s-31.548 13.874-31.999 31.159l-0.001 0.042v181.248c0.070 23.532 19.127 42.59 42.653 42.66h53.255c17.656-0.080 31.953-14.342 32.092-31.977v-0.013zM383.98 554.66h42.66v42.66h-42.66zM127.98 704c-23.539-0.070-42.602-19.139-42.66-42.675v-554.666c0.139-47.076 38.264-85.201 85.327-85.34h554.673c23.566 0 42.67 19.104 42.67 42.67s-19.104 42.67-42.67 42.67h-512c-23.532 0.070-42.59 19.127-42.66 42.653v512.007c-0.058 23.548-19.132 42.622-42.675 42.68h-0.006zM597.32 469.32h42.66v128h-42.66z" />
<glyph unicode="&#xe91b;" glyph-name="photo_library" d="M938.66 277.32v512c-0.139 47.076-38.264 85.201-85.327 85.34h-512.013c-47.076-0.139-85.201-38.264-85.34-85.327v-512.013c0.151-47.067 38.271-85.18 85.327-85.32h512.013c47.069 0.139 85.189 38.253 85.34 85.305v0.014zM486.38 425.37l69.632-93.020 110.080 137.38c3.936 4.897 9.925 8.004 16.64 8.004s12.704-3.107 16.608-7.962l0.032-0.041 126.3-157.86c2.918-3.609 4.684-8.254 4.684-13.312 0-11.741-9.518-21.258-21.258-21.258-0.020 0-0.039 0-0.059 0h-425.059c-0.012 0-0.027 0-0.041 0-11.775 0-21.32 9.545-21.32 21.32 0 4.845 1.616 9.313 4.339 12.893l-0.038-0.052 85.34 113.91c4.003 5.086 10.158 8.322 17.070 8.322s13.067-3.236 17.035-8.276l0.035-0.046zM85.32 661.32v-554.66c0.139-47.076 38.264-85.201 85.327-85.34h554.673c23.566 0 42.67 19.104 42.67 42.67s-19.104 42.67-42.67 42.67h-512c-23.532 0.070-42.59 19.127-42.66 42.653v512.007c0 23.566-19.104 42.67-42.67 42.67s-42.67-19.104-42.67-42.67v0z" />
<glyph unicode="&#xe91c;" glyph-name="photo" d="M896 149.34v597.32c-0.139 47.076-38.264 85.201-85.327 85.34h-597.333c-47.076-0.139-85.201-38.264-85.34-85.327v-597.333c0.139-47.076 38.264-85.201 85.327-85.34h597.333c47.076 0.139 85.201 38.264 85.34 85.327v0.013zM379.74 363.52l89.6-107.95 132.26 170.23c3.957 5.051 10.056 8.267 16.907 8.267 7.041 0 13.288-3.396 17.193-8.64l0.040-0.057 149.668-199.578c2.675-3.524 4.285-7.984 4.285-12.82 0-11.775-9.545-21.32-21.32-21.32-0.009 0-0.018 0-0.027 0h-511.487c-0.012 0-0.025 0-0.039 0-11.741 0-21.258 9.518-21.258 21.258 0 5.048 1.76 9.686 4.699 13.332l-0.032-0.041 106.23 136.54c3.877 5.213 10.019 8.554 16.941 8.554 6.576 0 12.448-3.015 16.309-7.738l0.030-0.038z" />
<glyph unicode="&#xe91d;" glyph-name="print" d="M810.66 618.66h-597.34c-0.049 0-0.106 0-0.164 0-70.602 0-127.836-57.234-127.836-127.836 0-0.058 0-0.115 0-0.173v0.009-170.66c0.139-47.076 38.264-85.201 85.327-85.34h85.353v-85.34c0.151-47.060 38.26-85.169 85.305-85.32h341.354c47.076 0.139 85.201 38.264 85.34 85.327v85.333h85.32c47.076 0.139 85.201 38.264 85.34 85.327v170.673c0 0.049 0 0.106 0 0.164 0 70.602-57.234 127.836-127.836 127.836-0.058 0-0.115 0-0.173 0h0.009zM639.98 149.34h-256c-23.532 0.070-42.59 19.127-42.66 42.653v170.667h341.34v-170.66c-0.070-23.539-19.139-42.602-42.675-42.66h-0.006zM810.66 448c-23.56 0-42.66 19.099-42.66 42.66s19.099 42.66 42.66 42.66c23.56 0 42.66-19.099 42.66-42.66v0c-0.070-23.532-19.127-42.59-42.653-42.66h-0.007zM725.32 832h-426.66c-23.532-0.070-42.59-19.127-42.66-42.653v-85.347c0.070-23.532 19.127-42.59 42.653-42.66h426.667c23.532 0.070 42.59 19.127 42.66 42.653v85.347c-0.070 23.532-19.127 42.59-42.653 42.66h-0.007z" />
<glyph unicode="&#xe91e;" glyph-name="radio_checked" d="M512 870.666c-233.412-0.012-422.625-189.232-422.625-422.646 0-233.421 189.225-422.646 422.646-422.646s422.646 189.225 422.646 422.646v0c-0.093 233.391-189.274 422.564-422.659 422.646h-0.008zM512 109.896c-186.741 0-338.125 151.384-338.125 338.125s151.384 338.125 338.125 338.125c186.741 0 338.125-151.384 338.125-338.125v0c0-0.030 0-0.066 0-0.102 0-186.685-151.338-338.022-338.022-338.022-0.036 0-0.072 0-0.108 0h0.005zM743.69 448c0-124.419-100.861-225.28-225.28-225.28s-225.28 100.861-225.28 225.28c0 124.419 100.861 225.28 225.28 225.28s225.28-100.861 225.28-225.28z" />
<glyph unicode="&#xe91f;" glyph-name="radio" d="M512 870.666c-233.412-0.012-422.625-189.232-422.625-422.646 0-233.421 189.225-422.646 422.646-422.646s422.646 189.225 422.646 422.646v0c-0.093 233.391-189.274 422.564-422.659 422.646h-0.008zM512 109.896c-186.741 0-338.125 151.384-338.125 338.125s151.384 338.125 338.125 338.125c186.741 0 338.125-151.384 338.125-338.125v0c0-0.030 0-0.066 0-0.102 0-186.685-151.338-338.022-338.022-338.022-0.036 0-0.072 0-0.108 0h0.005z" />
<glyph unicode="&#xe920;" glyph-name="remove" d="M768 405.333h-512c-23.564 0-42.667 19.103-42.667 42.667s19.103 42.667 42.667 42.667v0h512c23.564 0 42.667-19.103 42.667-42.667s-19.103-42.667-42.667-42.667v0z" />
<glyph unicode="&#xe921;" glyph-name="rplus" d="M512 683.52c-25.982-0.081-47.023-21.122-47.104-47.096v-141.32h-141.312c-26.015 0-47.104-21.089-47.104-47.104s21.089-47.104 47.104-47.104v0h141.312v-141.312c0-26.015 21.089-47.104 47.104-47.104s47.104 21.089 47.104 47.104v0 141.312h141.312c26.015 0 47.104 21.089 47.104 47.104s-21.089 47.104-47.104 47.104v0h-141.312v141.312c-0.081 25.982-21.122 47.023-47.096 47.104h-0.008zM512 919.040c-260.148 0-471.040-210.892-471.040-471.040s210.892-471.040 471.040-471.040c260.148 0 471.040 210.892 471.040 471.040v0c-0.442 259.97-211.069 470.597-470.997 471.040h-0.043zM512 71.168c-208.119 0-376.832 168.713-376.832 376.832s168.713 376.832 376.832 376.832c208.119 0 376.832-168.713 376.832-376.832v0c-0.28-208.006-168.826-376.552-376.805-376.832h-0.027z" />
<glyph unicode="&#xe922;" glyph-name="save" d="M810.66 405.34v-213.34c-0.070-23.532-19.127-42.59-42.653-42.66h-512.007c-23.532 0.070-42.59 19.127-42.66 42.653v213.347c0 23.566-19.104 42.67-42.67 42.67s-42.67-19.104-42.67-42.67v0-256c0.139-47.076 38.264-85.201 85.327-85.34h597.333c47.076 0.139 85.201 38.264 85.34 85.327v256.013c0 23.566-19.104 42.67-42.67 42.67s-42.67-19.104-42.67-42.67v0zM554.66 419.43l80.22 80.22c7.699 7.701 18.336 12.465 30.085 12.465 23.494 0 42.54-19.046 42.54-42.54 0-11.744-4.759-22.377-12.455-30.075l-153.17-153.17c-7.694-7.712-18.332-12.483-30.085-12.483s-22.391 4.771-30.084 12.482l-153.171 153.171c-7.965 7.739-12.907 18.552-12.907 30.52 0 23.493 19.044 42.537 42.537 42.537 11.968 0 22.781-4.942 30.51-12.897l0.010-0.010 80.65-80.22v369.91c0 23.566 19.104 42.67 42.67 42.67s42.67-19.104 42.67-42.67v0z" />
<glyph unicode="&#xe923;" glyph-name="search" d="M661.34 362.68h-33.628l-11.94 11.53c41.7 48.355 67.097 111.793 67.097 181.162 0 153.601-124.518 278.118-278.118 278.118s-278.118-124.518-278.118-278.118c0-153.601 124.518-278.118 278.118-278.118 69.37 0 132.807 25.397 181.522 67.4l-0.36-0.304 11.53-11.94v-33.71l181.248-181.432c7.933-7.17 18.5-11.557 30.091-11.557 24.827 0 44.954 20.126 44.954 44.954 0 11.591-4.387 22.158-11.592 30.13l0.035-0.039zM405.34 362.68c-106.039 0-192 85.961-192 192s85.961 192 192 192c106.039 0 192-85.961 192-192v0c0-0.079 0-0.173 0-0.266 0-105.892-85.842-191.734-191.734-191.734-0.094 0-0.187 0-0.281 0h0.014z" />
<glyph unicode="&#xe924;" glyph-name="sort" d="M177.398 196.751h167.506c22.729 0.519 40.956 19.066 40.956 41.871s-18.227 41.353-40.907 41.87l-0.048 0.001h-167.506c-22.729-0.519-40.956-19.066-40.956-41.871s18.227-41.353 40.907-41.87l0.048-0.001zM135.516 657.367c0.070-23.103 18.779-41.812 41.875-41.882h669.99c22.729 0.519 40.956 19.066 40.956 41.871s-18.227 41.353-40.907 41.87l-0.048 0.001h-669.983c-23.095-0.070-41.8-18.767-41.882-41.853v-0.008zM177.398 406.118h418.734c22.729 0.519 40.956 19.066 40.956 41.871s-18.227 41.353-40.907 41.87l-0.048 0.001h-418.734c-22.729-0.519-40.956-19.066-40.956-41.871s18.227-41.353 40.907-41.87l0.048-0.001z" />
<glyph unicode="&#xe925;" glyph-name="text" d="M622.51 849.49c-15.498 15.549-36.936 25.17-60.621 25.17-0.014 0-0.029 0-0.043 0h-305.826c-47.076-0.139-85.201-38.264-85.34-85.327v-682.673c0-0.037 0-0.080 0-0.123 0-46.956 37.978-85.042 84.893-85.217h512.447c47.067 0.151 85.18 38.271 85.32 85.327v476.603c0 0.037 0 0.081 0 0.124 0 23.513-9.664 44.768-25.237 60.011l-0.015 0.015-205.578 206.090zM640 192.082h-256c-23.566 0-42.67 19.104-42.67 42.67s19.104 42.67 42.67 42.67h256c23.566 0 42.67-19.104 42.67-42.67s-19.104-42.67-42.67-42.67v0zM640 362.742h-256c-23.566 0-42.67 19.104-42.67 42.67s19.104 42.67 42.67 42.67h256c23.566 0 42.67-19.104 42.67-42.67s-19.104-42.67-42.67-42.67v0zM554.68 618.66v192l234.66-234.66h-192c-23.532 0.070-42.59 19.127-42.66 42.653v0.007z" />
<glyph unicode="&#xe926;" glyph-name="ticketlist" d="M135.168 124.416h753.664c52.030 0 94.208 42.178 94.208 94.208s-42.178 94.208-94.208 94.208v0h-753.664c-52.030 0-94.208-42.178-94.208-94.208s42.178-94.208 94.208-94.208v0zM135.168 265.728h94.208v-94.208h-94.208zM40.96 783.872c0.162-51.964 42.244-94.046 94.192-94.208h753.68c52.030 0 94.208 42.178 94.208 94.208s-42.178 94.208-94.208 94.208v0h-753.664c-51.964-0.162-94.046-42.244-94.208-94.192v-0.016zM229.376 736.768h-94.208v94.208h94.208zM135.168 407.040h753.664c52.030 0 94.208 42.178 94.208 94.208s-42.178 94.208-94.208 94.208v0h-753.664c-52.030 0-94.208-42.178-94.208-94.208s42.178-94.208 94.208-94.208v0zM135.168 548.352h94.208v-94.208h-94.208z" />
<glyph unicode="&#xe927;" glyph-name="time" d="M511.57 883.2c-240.169-0.245-434.77-194.997-434.77-435.2 0-240.354 194.846-435.2 435.2-435.2s435.2 194.846 435.2 435.2v0c0 0.061 0 0.133 0 0.205 0 240.241-194.754 434.995-434.995 434.995-0.223 0-0.447 0-0.67-0.001h0.035zM512 99.84c-192.283 0-348.16 155.877-348.16 348.16s155.877 348.16 348.16 348.16c192.283 0 348.16-155.877 348.16-348.16v0c0-192.283-155.877-348.16-348.16-348.16v0zM502.415 665.6h-2.621c-0.037 0-0.080 0-0.123 0-17.238 0-31.212-13.974-31.212-31.212 0-0.043 0-0.087 0-0.13v0.007-205.414c-0.001-0.082-0.001-0.18-0.001-0.277 0-15.761 8.478-29.541 21.121-37.030l0.199-0.109 180.634-108.298c4.652-2.918 10.306-4.649 16.365-4.649 17.192 0 31.13 13.937 31.13 31.13 0 11.529-6.267 21.593-15.58 26.974l-0.15 0.080-168.428 100.065v197.53c0 0.037 0 0.080 0 0.123 0 17.238-13.974 31.212-31.212 31.212-0.043 0-0.087 0-0.13 0h0.007z" />
<glyph unicode="&#xe928;" glyph-name="toggle_off" d="M737.36 708.256h-433.744c-143.727 0-260.24-116.513-260.24-260.24s116.513-260.24 260.24-260.24v0h433.744c143.727 0 260.24 116.513 260.24 260.24s-116.513 260.24-260.24 260.24v0zM737.36 274.512h-433.744c-95.819 0-173.496 77.677-173.496 173.496s77.677 173.496 173.496 173.496v0h433.744c95.819 0 173.496-77.677 173.496-173.496s-77.677-173.496-173.496-173.496v0zM303.616 578.128c-71.854-0.018-130.096-58.272-130.096-130.128 0-71.868 58.26-130.128 130.128-130.128s130.128 58.26 130.128 130.128c0 0.006 0 0.011 0 0.017v-0.001c0 0.048 0 0.104 0 0.16 0 71.771-58.181 129.952-129.952 129.952-0.073 0-0.146 0-0.22 0h0.011z" />
<glyph unicode="&#xe929;" glyph-name="toggle_on" d="M737.36 708.256h-433.744c-143.727 0-260.24-116.513-260.24-260.24s116.513-260.24 260.24-260.24v0h433.744c143.727 0 260.24 116.513 260.24 260.24s-116.513 260.24-260.24 260.24v0zM737.36 274.512h-433.744c-95.819 0-173.496 77.677-173.496 173.496s77.677 173.496 173.496 173.496v0h433.744c95.819 0 173.496-77.677 173.496-173.496s-77.677-173.496-173.496-173.496v0zM737.36 578.128c-71.868 0-130.128-58.26-130.128-130.128s58.26-130.128 130.128-130.128c71.868 0 130.128 58.26 130.128 130.128v0c0 0.052 0 0.114 0 0.176 0 71.771-58.181 129.952-129.952 129.952-0.062 0-0.124 0-0.186 0h0.009z" />
<glyph unicode="&#xe92a;" glyph-name="visible" d="M512 789.34c-212.123-0.124-393.62-131.116-468.136-316.605l-1.205-3.395c75.623-188.953 257.173-319.993 469.33-319.993s393.707 131.041 468.128 316.599l1.202 3.395c-75.717 188.877-257.204 319.867-469.302 320h-0.017zM512 256c-0.006 0-0.013 0-0.020 0-117.825 0-213.34 95.516-213.34 213.34s95.516 213.34 213.34 213.34c117.825 0 213.34-95.516 213.34-213.34v0c-0.035-117.803-95.518-213.293-213.315-213.34h-0.005zM512 597.34c-70.692 0-128-57.308-128-128s57.308-128 128-128c70.692 0 128 57.308 128 128v0c0 0.049 0 0.106 0 0.164 0 70.602-57.234 127.836-127.836 127.836-0.058 0-0.115 0-0.173 0h0.009z" />
<glyph unicode="&#xe930;" glyph-name="access_time_black_24dp" d="M511.573 874.667c-235.52 0-426.24-191.147-426.24-426.667s190.72-426.667 426.24-426.667c235.947 0 427.093 191.147 427.093 426.667s-191.147 426.667-427.093 426.667zM512 106.667c-188.587 0-341.333 152.747-341.333 341.333s152.747 341.333 341.333 341.333 341.333-152.747 341.333-341.333-152.747-341.333-341.333-341.333zM502.613 661.333h-2.56c-17.067 0-30.72-13.653-30.72-30.72v-201.387c0-14.933 7.68-29.013 20.907-36.693l177.067-106.24c14.507-8.533 33.28-4.267 41.813 10.24 8.96 14.507 4.267 33.707-10.667 42.24l-165.12 98.133v193.707c0 17.067-13.653 30.72-30.72 30.72z" />
<glyph unicode="&#xe931;" glyph-name="access_time_filled_black_24dp" d="M511.573 874.667c-235.52 0-426.24-191.147-426.24-426.667s190.72-426.667 426.24-426.667c235.947 0 427.093 191.147 427.093 426.667s-191.147 426.667-427.093 426.667zM682.667 277.333c-16.64-16.64-43.52-16.64-60.16 0l-140.373 140.373c-8.107 8.107-12.8 18.773-12.8 30.293v170.667c0 23.467 19.2 42.667 42.667 42.667v0c23.467 0 42.667-19.2 42.667-42.667v-153.173l128-128c16.64-16.64 16.64-43.52 0-60.16z" />
<glyph unicode="&#xe932;" glyph-name="account_tree_black_24dp" d="M725.333 490.667h128c47.36 0 85.333 38.4 85.333 85.333v170.667c0 47.36-38.4 85.333-85.333 85.333h-128c-47.36 0-85.333-38.4-85.333-85.333v-42.667h-255.573v42.667c0 47.36-38.4 85.333-85.333 85.333h-128.427c-46.933 0-85.333-38.4-85.333-85.333v-170.667c0-47.36 38.4-85.333 85.333-85.333h128c47.36 0 85.333 38.4 85.333 85.333v42.667h85.333v-299.093c0-70.4 57.173-127.573 127.573-127.573h43.093v-42.667c0-47.36 38.4-85.333 85.333-85.333h128c47.36 0 85.333 38.4 85.333 85.333v170.667c0 47.36-38.4 85.333-85.333 85.333h-128c-47.36 0-85.333-38.4-85.333-85.333v-42.667h-43.093c-23.040 0-42.24 19.2-42.24 42.24v299.093h85.333v-42.667c0-46.933 38.4-85.333 85.333-85.333z" />
<glyph unicode="&#xe933;" glyph-name="add_alert_black_24dp" d="M512 21.333c46.933 0 85.333 38.4 85.333 85.333h-170.667c0-46.933 38.4-85.333 85.333-85.333zM810.667 234.667h-42.667v298.667c0 119.040-81.493 219.307-192 247.467v29.867c0 35.413-28.587 64-64 64s-64-28.587-64-64v-29.867c-110.507-28.16-192-128.427-192-247.467v-298.667h-42.667c-23.467 0-42.667-19.2-42.667-42.667s19.2-42.667 42.667-42.667h597.333c23.467 0 42.667 19.2 42.667 42.667s-19.2 42.667-42.667 42.667zM597.333 405.333h-42.667v-42.667c0-23.467-19.2-42.667-42.667-42.667s-42.667 19.2-42.667 42.667v42.667h-42.667c-23.467 0-42.667 19.2-42.667 42.667s19.2 42.667 42.667 42.667h42.667v42.667c0 23.467 19.2 42.667 42.667 42.667s42.667-19.2 42.667-42.667v-42.667h42.667c23.467 0 42.667-19.2 42.667-42.667s-19.2-42.667-42.667-42.667z" />
<glyph unicode="&#xe934;" glyph-name="alarm_black_24dp" d="M677.12 309.333l-143.787 85.333v193.28c0 17.067-13.653 30.72-30.72 30.72h-2.56c-17.067 0-30.72-13.653-30.72-30.72v-201.387c0-14.933 7.68-29.013 20.907-36.693l155.733-93.44c14.507-8.533 33.28-4.267 41.813 10.24 8.96 14.933 4.267 34.133-10.667 42.667zM903.68 746.24l-131.413 109.227c-17.92 14.933-44.8 12.8-60.16-5.547-14.933-17.92-12.373-44.8 5.547-60.16l130.987-109.227c17.92-14.933 44.8-12.8 60.16 5.547 15.36 17.92 12.8 44.8-5.12 60.16zM174.933 680.533l130.987 109.227c18.347 15.36 20.907 42.24 5.547 60.16-14.933 18.347-41.813 20.48-59.733 5.547l-131.413-109.227c-17.92-15.36-20.48-42.24-5.12-60.16 14.933-18.347 41.813-20.48 59.733-5.547zM512 789.333c-212.053 0-384-171.947-384-384s171.947-384 384-384 384 171.947 384 384-171.947 384-384 384zM512 106.667c-164.693 0-298.667 133.973-298.667 298.667s133.973 298.667 298.667 298.667 298.667-133.973 298.667-298.667-133.973-298.667-298.667-298.667z" />
<glyph unicode="&#xe935;" glyph-name="announcement_black_24dp" d="M853.333 874.667h-682.667c-46.933 0-85.333-38.4-85.333-85.333v-768l170.667 170.667h597.333c46.933 0 85.333 38.4 85.333 85.333v512c0 46.933-38.4 85.333-85.333 85.333zM512 490.667c-23.467 0-42.667 19.2-42.667 42.667v170.667c0 23.467 19.2 42.667 42.667 42.667s42.667-19.2 42.667-42.667v-170.667c0-23.467-19.2-42.667-42.667-42.667zM554.667 320h-85.333v85.333h85.333v-85.333z" />
<glyph unicode="&#xe936;" glyph-name="auto_delete_black_24dp" d="M682.667 576c-29.867 0-58.453-4.267-85.333-12.373v97.707c0 46.933-38.4 85.333-85.333 85.333h-341.333c-46.933 0-85.333-38.4-85.333-85.333v-426.667c0-46.933 38.4-85.333 85.333-85.333h242.347c47.787-100.693 150.613-170.667 269.653-170.667 165.12 0 298.667 133.547 298.667 298.667s-133.547 298.667-298.667 298.667zM682.667 64c-117.76 0-213.333 95.573-213.333 213.333s95.573 213.333 213.333 213.333 213.333-95.573 213.333-213.333-95.573-213.333-213.333-213.333zM597.333 789.333c23.467 0 42.667 19.2 42.667 42.667s-19.2 42.667-42.667 42.667h-106.667l-30.293 30.293c-7.68 7.68-18.773 12.373-29.867 12.373h-178.347c-11.093 0-22.187-4.693-29.867-12.373l-30.293-30.293h-106.667c-23.467 0-42.667-19.2-42.667-42.667s19.2-42.667 42.667-42.667h512zM672 448v0c-17.493 0-32-14.507-32-32v-157.013c0-15.36 8.107-29.013 21.333-36.693l107.52-62.72c14.080-8.107 32-3.84 40.96 9.387v0c9.813 14.507 5.12 34.56-10.24 43.52l-95.573 56.32v147.2c0 17.493-14.507 32-32 32z" />
<glyph unicode="&#xe937;" glyph-name="bug_report_black_24dp" d="M810.667 618.667h-77.227c-19.2 33.28-45.653 61.867-77.653 83.627l39.68 39.68c16.64 16.64 16.64 43.52 0 60.16s-43.52 16.64-60.16 0l-62.72-62.72c-19.627 4.693-39.68 7.253-60.587 7.253s-40.96-2.56-60.16-7.253l-63.147 62.72c-16.64 16.64-43.52 16.64-60.16 0s-16.64-43.52 0-60.16l39.253-39.68c-31.573-21.76-58.027-50.347-77.227-83.627h-77.227c-23.467 0-42.667-19.2-42.667-42.667s19.2-42.667 42.667-42.667h46.507c-2.133-14.080-3.84-28.16-3.84-42.667v-42.667h-42.667c-23.467 0-42.667-19.2-42.667-42.667s19.2-42.667 42.667-42.667h42.667v-42.667c0-14.507 1.707-28.587 3.84-42.667h-46.507c-23.467 0-42.667-19.2-42.667-42.667s19.2-42.667 42.667-42.667h77.227c44.373-76.373 126.72-128 221.44-128s177.067 51.627 221.44 128h77.227c23.467 0 42.667 19.2 42.667 42.667s-19.2 42.667-42.667 42.667h-46.507c2.133 14.080 3.84 28.16 3.84 42.667v42.667h42.667c23.467 0 42.667 19.2 42.667 42.667s-19.2 42.667-42.667 42.667h-42.667v42.667c0 14.507-1.707 28.587-3.84 42.667h46.507c23.467 0 42.667 19.2 42.667 42.667s-19.2 42.667-42.667 42.667zM554.667 277.333h-85.333c-23.467 0-42.667 19.2-42.667 42.667s19.2 42.667 42.667 42.667h85.333c23.467 0 42.667-19.2 42.667-42.667s-19.2-42.667-42.667-42.667zM554.667 448h-85.333c-23.467 0-42.667 19.2-42.667 42.667s19.2 42.667 42.667 42.667h85.333c23.467 0 42.667-19.2 42.667-42.667s-19.2-42.667-42.667-42.667z" />
<glyph unicode="&#xe938;" glyph-name="business_center_black_24dp" d="M554.667 277.333h-85.333c-23.467 0-42.667 19.2-42.667 42.667h-298.24v-170.667c0-46.933 38.4-85.333 85.333-85.333h596.907c46.933 0 85.333 38.4 85.333 85.333v170.667h-298.667c0-23.467-19.2-42.667-42.667-42.667zM853.333 661.333h-170.667c0 94.293-76.373 170.667-170.667 170.667s-170.667-76.373-170.667-170.667h-170.667c-46.933 0-85.333-38.4-85.333-85.333v-128c0-47.36 37.973-85.333 85.333-85.333h256v42.667c0 23.467 19.2 42.667 42.667 42.667h85.333c23.467 0 42.667-19.2 42.667-42.667v-42.667h256c46.933 0 85.333 38.4 85.333 85.333v128c0 46.933-38.4 85.333-85.333 85.333zM426.667 661.333c0 46.933 38.4 85.333 85.333 85.333s85.333-38.4 85.333-85.333h-170.667z" />
<glyph unicode="&#xe939;" glyph-name="check_box_black_24dp" d="M810.667 832h-597.333c-46.933 0-85.333-38.4-85.333-85.333v-597.333c0-46.933 38.4-85.333 85.333-85.333h597.333c46.933 0 85.333 38.4 85.333 85.333v597.333c0 46.933-38.4 85.333-85.333 85.333zM456.96 264.96c-16.64-16.64-43.52-16.64-60.16 0l-153.173 153.173c-16.64 16.64-16.64 43.52 0 60.16s43.52 16.64 60.16 0l122.88-122.88 293.547 293.547c16.64 16.64 43.52 16.64 60.16 0s16.64-43.52 0-60.16l-323.413-323.84z" />
<glyph unicode="&#xe93a;" glyph-name="check_box_outline_blank_black_24dp" d="M768 149.333h-512c-23.467 0-42.667 19.2-42.667 42.667v512c0 23.467 19.2 42.667 42.667 42.667h512c23.467 0 42.667-19.2 42.667-42.667v-512c0-23.467-19.2-42.667-42.667-42.667zM810.667 832h-597.333c-46.933 0-85.333-38.4-85.333-85.333v-597.333c0-46.933 38.4-85.333 85.333-85.333h597.333c46.933 0 85.333 38.4 85.333 85.333v597.333c0 46.933-38.4 85.333-85.333 85.333z" />
<glyph unicode="&#xe93b;" glyph-name="chevron_left_black_24dp" d="M627.627 673.707c-16.64 16.64-43.52 16.64-60.16 0l-195.84-195.84c-16.64-16.64-16.64-43.52 0-60.16l195.84-195.84c16.64-16.64 43.52-16.64 60.16 0s16.64 43.52 0 60.16l-165.547 165.973 165.547 165.547c16.64 16.64 16.213 43.947 0 60.16z" />
<glyph unicode="&#xe93c;" glyph-name="chevron_right_black_24dp" d="M396.373 673.707c-16.64-16.64-16.64-43.52 0-60.16l165.547-165.547-165.547-165.547c-16.64-16.64-16.64-43.52 0-60.16s43.52-16.64 60.16 0l195.84 195.84c16.64 16.64 16.64 43.52 0 60.16l-195.84 195.84c-16.213 16.213-43.52 16.213-60.16-0.427z" />
<glyph unicode="&#xe93d;" glyph-name="cottage_black_24dp" d="M955.307 439.893c14.507 18.773 10.667 45.653-8.107 59.733l-409.6 312.747c-15.36 11.52-36.693 11.52-51.627 0l-229.973-175.787v24.747c0 23.467-19.2 42.667-42.667 42.667s-42.667-19.2-42.667-42.667v-90.027l-94.293-71.68c-18.773-14.080-22.187-40.96-8.107-59.733 14.507-18.773 40.96-22.187 59.733-8.107l42.667 32.427v-357.547c0-23.467 19.2-42.667 42.667-42.667h256v213.333c0 23.467 19.2 42.667 42.667 42.667s42.667-19.2 42.667-42.667v-213.333h256c23.467 0 42.667 19.2 42.667 42.667v357.547l42.24-32.427c18.773-14.507 45.653-10.667 59.733 8.107zM224.853 746.667c-31.573 0-53.76 34.133-38.4 61.867 22.187 39.68 64 66.133 112.213 66.133 16.213 0 30.72 9.387 37.973 22.613 6.4 13.227 21.333 20.053 35.84 20.053 31.573 0 53.76-34.133 38.4-61.867-22.187-39.68-64-66.133-112.213-66.133-16.213 0-30.72-9.387-37.973-22.613-6.4-13.227-21.333-20.053-35.84-20.053z" />
<glyph unicode="&#xe93e;" glyph-name="delete_black_24dp" d="M256 149.333c0-46.933 38.4-85.333 85.333-85.333h341.333c46.933 0 85.333 38.4 85.333 85.333v426.667c0 46.933-38.4 85.333-85.333 85.333h-341.333c-46.933 0-85.333-38.4-85.333-85.333v-426.667zM768 789.333h-106.667l-30.293 30.293c-7.68 7.68-18.773 12.373-29.867 12.373h-178.347c-11.093 0-22.187-4.693-29.867-12.373l-30.293-30.293h-106.667c-23.467 0-42.667-19.2-42.667-42.667s19.2-42.667 42.667-42.667h512c23.467 0 42.667 19.2 42.667 42.667s-19.2 42.667-42.667 42.667z" />
<glyph unicode="&#xe93f;" glyph-name="directions_run_black_24dp" d="M575.573 726.187c46.933 0 85.333 38.4 85.333 85.333s-38.4 85.333-85.333 85.333-85.333-38.4-85.333-85.333 38.4-85.333 85.333-85.333zM440.32 214.187l24.32 106.667 89.6-85.333v-213.333c0-23.467 19.2-42.667 42.667-42.667s42.667 19.2 42.667 42.667v240.64c0 23.467-9.387 45.653-26.453 61.867l-63.147 60.16 25.6 128c45.653-52.907 111.787-90.88 186.027-102.827 25.6-3.84 48.64 16.64 48.64 42.667 0 20.907-15.36 38.4-36.267 41.813-64.853 10.667-118.613 49.067-147.2 99.413l-42.667 68.267c-17.067 25.6-42.667 42.667-72.533 42.667-12.8 0-21.333-4.267-34.133-4.267l-169.813-71.68c-31.573-13.653-52.053-44.373-52.053-78.933v-101.12c0-23.467 19.2-42.667 42.667-42.667s42.667 19.2 42.667 42.667v102.4l76.8 29.867-68.267-345.6-167.253 34.133c-23.040 4.693-45.653-10.24-50.347-33.28v-1.707c-4.693-23.040 10.24-45.653 33.28-50.347l175.36-34.987c45.227-8.96 89.6 19.627 99.84 64.853z" />
<glyph unicode="&#xe940;" glyph-name="do_disturb_black_24dp" d="M512 874.667c-235.52 0-426.667-191.147-426.667-426.667s191.147-426.667 426.667-426.667 426.667 191.147 426.667 426.667-191.147 426.667-426.667 426.667zM512 106.667c-188.587 0-341.333 152.747-341.333 341.333 0 78.933 26.88 151.467 72.107 209.067l478.293-478.293c-57.6-45.227-130.133-72.107-209.067-72.107zM781.227 238.933l-478.293 478.293c57.6 45.227 130.133 72.107 209.067 72.107 188.587 0 341.333-152.747 341.333-341.333 0-78.933-26.88-151.467-72.107-209.067z" />
<glyph unicode="&#xe941;" glyph-name="error_black_24dp" d="M512 874.667c-235.52 0-426.667-191.147-426.667-426.667s191.147-426.667 426.667-426.667 426.667 191.147 426.667 426.667-191.147 426.667-426.667 426.667zM512 405.333c-23.467 0-42.667 19.2-42.667 42.667v170.667c0 23.467 19.2 42.667 42.667 42.667s42.667-19.2 42.667-42.667v-170.667c0-23.467-19.2-42.667-42.667-42.667zM554.667 234.667h-85.333v85.333h85.333v-85.333z" />
<glyph unicode="&#xe942;" glyph-name="error_outline_black_24dp" d="M512 661.333c23.467 0 42.667-19.2 42.667-42.667v-170.667c0-23.467-19.2-42.667-42.667-42.667s-42.667 19.2-42.667 42.667v170.667c0 23.467 19.2 42.667 42.667 42.667zM511.573 874.667c-235.52 0-426.24-191.147-426.24-426.667s190.72-426.667 426.24-426.667c235.947 0 427.093 191.147 427.093 426.667s-191.147 426.667-427.093 426.667zM512 106.667c-188.587 0-341.333 152.747-341.333 341.333s152.747 341.333 341.333 341.333 341.333-152.747 341.333-341.333-152.747-341.333-341.333-341.333zM554.667 234.667h-85.333v85.333h85.333v-85.333z" />
<glyph unicode="&#xe943;" glyph-name="event_available_black_24dp" d="M682.667 510.72c-12.373 12.373-32.853 12.373-45.227 0l-185.6-185.6-67.84 67.84c-12.373 12.373-32.853 12.373-45.227 0s-12.373-32.853 0-45.227l82.773-82.773c16.64-16.64 43.52-16.64 60.16 0l200.533 200.533c12.8 12.373 12.8 32.853 0.427 45.227zM810.667 832h-42.667v42.667c0 23.467-19.2 42.667-42.667 42.667s-42.667-19.2-42.667-42.667v-42.667h-341.333v42.667c0 23.467-19.2 42.667-42.667 42.667s-42.667-19.2-42.667-42.667v-42.667h-42.667c-47.36 0-84.907-38.4-84.907-85.333l-0.427-597.333c0-46.933 37.973-85.333 85.333-85.333h597.333c46.933 0 85.333 38.4 85.333 85.333v597.333c0 46.933-38.4 85.333-85.333 85.333zM768 149.333h-512c-23.467 0-42.667 19.2-42.667 42.667v426.667h597.333v-426.667c0-23.467-19.2-42.667-42.667-42.667z" />
<glyph unicode="&#xe944;" glyph-name="flutter_dash_black_24dp" d="M472.32 460.8c12.373 16.64 34.56 23.893 54.187 15.787 7.253-2.987 13.653-7.68 18.347-14.080 9.387-11.947 10.667-25.173 9.387-36.267-2.133-14.080-10.667-26.88-23.040-33.707 0 0-207.787-125.867-216.32-114.773s157.44 183.040 157.44 183.040zM938.667 533.333c0-106.667-42.667-128-64-128-9.813 0-18.773 4.267-26.453 11.093-20.48-141.653-100.693-226.56-227.413-255.573 4.693-18.773 20.48-32.853 40.533-32.853v0h24.747c9.387 0 17.493-6.4 20.48-15.36 7.253-22.187 28.16-43.52 43.52-56.32 10.667-8.96 10.24-25.173-1.28-33.28-14.507-10.24-38.4-20.907-76.373-22.613-7.68-0.427-14.933 2.987-19.2 9.387-5.547 8.533-13.227 23.893-13.227 43.093 0 12.8 1.707 24.32 3.84 34.133-33.28 6.827-59.307 33.28-66.133 66.56-20.907-2.56-42.667-4.267-65.707-4.267-37.547 0-72.533 3.84-104.533 10.667-0.853-3.413-2.133-6.827-2.133-10.667 0-23.467 19.2-42.667 42.667-42.667v0h24.747c9.387 0 17.493-6.4 20.48-15.36 7.253-22.187 28.16-43.52 43.52-56.32 10.667-8.96 10.24-25.173-1.28-33.28-14.507-10.24-38.4-20.907-76.373-22.613-7.68-0.427-14.933 2.987-19.2 9.387-5.547 8.533-13.227 23.893-13.227 43.093 0 12.8 1.707 24.32 3.84 34.133-38.4 8.107-67.84 42.667-67.84 83.627 0 7.68 1.28 15.36 3.413 22.613-104.96 36.693-171.947 118.613-190.293 244.907-7.68-7.253-16.213-11.52-26.453-11.52-21.333 0-64 21.333-64 128 0 96.853 72.533 192 128 192 18.347 0 20.907-20.907 21.333-36.267 54.613 75.947 139.093 128.853 236.8 140.373 8.533 40.96 46.080 66.56 83.2 66.56v-42.667c0 0 14.080 21.333 42.667 21.333s42.667-21.333 42.667-21.333c-20.907 0-36.267-14.933-40.96-32.853 77.653-20.48 144.64-67.84 190.293-131.413 0.427 15.36 2.987 36.267 21.333 36.267 55.467 0 128-95.147 128-192zM213.333 490.667c0-34.56 4.267-65.28 10.667-94.293 7.68 29.44 19.627 56.747 35.413 81.92-8.96 20.053-14.507 42.24-14.507 65.707 0.427 88.32 72.107 160 160.427 160 40.96 0 78.507-15.787 106.667-41.387 28.16 25.6 65.707 41.387 106.667 41.387 88.32 0 160-71.68 160-160 0-23.467-5.12-45.653-14.507-65.707 15.787-25.173 28.16-52.907 35.84-82.773 6.4 29.013 10.667 60.16 10.667 95.147 0 164.693-133.973 298.667-298.667 298.667s-298.667-133.973-298.667-298.667zM767.147 307.627c0 4.267 0.853 8.107 0.853 12.373 0 43.093-11.093 83.2-29.867 118.613-29.44-33.28-71.68-54.613-119.467-54.613-11.52 0-23.040 1.28-33.707 3.84 5.973 9.813 9.813 20.907 11.52 32.853 0.427 2.987 0.427 5.547 0.853 8.107 7.253-1.28 14.080-2.133 21.333-2.133 64.853 0 117.333 52.48 117.333 117.333s-52.48 117.333-117.333 117.333c-28.587 0-56.32-10.667-78.080-30.72l-28.587-25.6-28.587 25.6c-21.76 20.053-49.493 30.72-78.080 30.72-64.853 0-117.333-52.48-117.333-117.333 0-57.173 40.96-104.96 95.147-115.2l-32.427-35.413c-25.6 9.387-47.787 25.173-65.28 44.8-18.347-35.413-29.44-75.52-29.44-118.187 0-3.413 0.427-6.4 0.427-10.24 47.787-77.653 133.547-117.76 255.573-117.76 122.88 0 208.213 38.827 255.147 115.627zM682.667 544c0-41.387-28.587-74.667-64-74.667s-64 33.28-64 74.667 28.587 74.667 64 74.667 64-33.28 64-74.667zM650.667 581.12c0 8.96-7.253 16.213-16.213 16.213s-15.787-7.253-15.787-16.213 7.253-16.213 16.213-16.213 15.787 7.68 15.787 16.213zM469.333 544c0-41.387-28.587-74.667-64-74.667s-64 33.28-64 74.667 28.587 74.667 64 74.667 64-33.28 64-74.667zM437.333 581.12c0 8.96-7.253 16.213-16.213 16.213s-15.787-7.253-15.787-16.213 7.253-16.213 16.213-16.213 15.787 7.68 15.787 16.213z" />
<glyph unicode="&#xe945;" glyph-name="help_center_black_24dp" d="M810.667 832h-597.333c-46.933 0-85.333-38.4-85.333-85.333v-597.333c0-46.933 38.4-85.333 85.333-85.333h597.333c46.933 0 85.333 38.4 85.333 85.333v597.333c0 46.933-38.4 85.333-85.333 85.333zM512.427 192c-29.867 0-53.76 23.893-53.76 53.76 0 30.293 23.893 53.333 53.76 53.333 30.293 0 53.333-23.040 53.333-53.333-0.427-29.44-23.040-53.76-53.333-53.76zM640.853 507.733c-32.427-47.36-63.147-62.293-79.787-92.587-4.267-7.68-6.827-13.653-8.107-26.88-2.133-19.2-19.2-33.28-38.4-33.28h-2.56c-22.187 0-39.68 18.773-37.547 40.96 1.28 14.507 4.693 29.44 12.8 43.947 20.907 37.12 60.587 59.307 83.627 92.16 24.32 34.56 10.667 99.413-58.453 99.413-30.293 0-50.347-15.36-62.72-33.707-10.667-15.36-29.44-22.613-46.933-15.36v0c-22.613 8.96-30.72 36.267-17.067 55.893 26.027 37.973 69.547 65.707 125.867 65.707 63.147 0 106.24-28.587 128.427-64.853 18.773-30.72 29.867-88.32 0.853-131.413z" />
<glyph unicode="&#xe946;" glyph-name="import_contacts_black_24dp" d="M746.667 768c-83.2 0-172.8-17.067-234.667-64-61.867 46.933-151.467 64-234.667 64-61.867 0-127.573-9.387-182.613-33.707-31.147-14.080-52.053-44.373-52.053-78.933v-481.28c0-55.467 52.053-96.427 105.813-82.773 41.813 10.667 86.187 15.36 128.853 15.36 66.56 0 137.387-11.093 194.56-39.253 25.6-12.8 54.613-12.8 79.787 0 57.173 28.587 128 39.253 194.56 39.253 42.667 0 87.040-4.693 128.853-15.36 53.76-14.080 105.813 26.88 105.813 82.773v481.28c0 34.56-20.907 64.853-52.053 78.933-54.613 24.32-120.32 33.707-182.187 33.707zM896 224.853c0-26.88-24.747-46.507-51.2-41.813-32 5.973-65.28 8.533-98.133 8.533-72.533 0-177.067-27.733-234.667-64v491.093c57.6 36.267 162.133 64 234.667 64 39.253 0 78.080-3.84 115.2-11.947 19.627-4.267 34.133-21.76 34.133-41.813v-404.053z" />
<glyph unicode="&#xe947;" glyph-name="indeterminate_check_box_black_24dp" d="M810.667 832h-597.333c-46.933 0-85.333-38.4-85.333-85.333v-597.333c0-46.933 38.4-85.333 85.333-85.333h597.333c46.933 0 85.333 38.4 85.333 85.333v597.333c0 46.933-38.4 85.333-85.333 85.333zM682.667 405.333h-341.333c-23.467 0-42.667 19.2-42.667 42.667s19.2 42.667 42.667 42.667h341.333c23.467 0 42.667-19.2 42.667-42.667s-19.2-42.667-42.667-42.667z" />
<glyph unicode="&#xe948;" glyph-name="info_outline_black_24dp" d="M469.333 661.333h85.333v-85.333h-85.333zM512 234.667c23.467 0 42.667 19.2 42.667 42.667v170.667c0 23.467-19.2 42.667-42.667 42.667s-42.667-19.2-42.667-42.667v-170.667c0-23.467 19.2-42.667 42.667-42.667zM512 874.667c-235.52 0-426.667-191.147-426.667-426.667s191.147-426.667 426.667-426.667 426.667 191.147 426.667 426.667-191.147 426.667-426.667 426.667zM512 106.667c-188.16 0-341.333 153.173-341.333 341.333s153.173 341.333 341.333 341.333 341.333-153.173 341.333-341.333-153.173-341.333-341.333-341.333z" />
<glyph unicode="&#xe949;" glyph-name="live_help_black_24dp" d="M810.667 874.667h-597.333c-47.36 0-85.333-38.4-85.333-85.333v-597.333c0-46.933 38.4-85.333 85.333-85.333h170.667l97.707-97.707c16.64-16.64 43.52-16.64 60.16 0l98.133 97.707h170.667c46.933 0 85.333 38.4 85.333 85.333v597.333c0 46.933-38.4 85.333-85.333 85.333zM554.667 192h-85.333v85.333h85.333v-85.333zM642.987 522.667l-38.4-39.253c-24.747-25.173-42.24-46.933-47.787-87.893-2.56-18.347-17.493-32.427-36.267-32.427h-13.227c-22.187 0-39.253 19.627-36.267 41.813 4.693 38.827 22.613 73.387 48.64 99.84l52.907 53.76c15.36 15.36 24.747 36.693 24.747 60.16 0 46.933-38.4 85.333-85.333 85.333-37.12 0-69.12-24.32-80.64-57.6-5.547-15.787-18.773-27.307-35.413-27.307h-12.8c-24.747 0-41.813 23.893-34.987 47.787 20.907 70.827 86.187 122.453 163.84 122.453 94.293 0 170.667-76.373 170.667-170.667 0-37.547-15.36-71.68-39.68-96z" />
<glyph unicode="&#xe94a;" glyph-name="mark_chat_read_black_24dp" d="M770.133 136.96c-16.64-16.64-43.52-16.64-60.16 0l-90.453 90.453c-16.64 16.64-16.64 43.52 0 60.16v0c16.64 16.64 43.52 16.64 60.16 0l60.16-60.16 151.040 151.040c16.64 16.64 43.52 16.64 60.16 0v0c16.64-16.64 16.64-43.52 0-60.16l-180.907-181.333zM512 234.667c0 165.12 133.547 298.667 298.667 298.667 46.080 0 89.173-10.667 128-29.013v285.013c0 46.933-38.4 85.333-85.333 85.333h-682.667c-46.933 0-85.333-38.4-85.333-85.333v-768l170.667 170.667h256c0 7.253 0.427 14.080 1.28 21.333-0.853 7.253-1.28 14.080-1.28 21.333z" />
<glyph unicode="&#xe94b;" glyph-name="mark_chat_unread_black_24dp" d="M938.667 662.187v-384.853c0-46.933-38.4-85.333-85.333-85.333h-597.333l-170.667-170.667v768c0 46.933 38.4 85.333 85.333 85.333h430.933c-2.56-13.653-4.267-28.16-4.267-42.667 0-117.76 95.573-213.333 213.333-213.333 48.213 0 92.16 16.64 128 43.52zM682.667 832c0-70.827 57.173-128 128-128s128 57.173 128 128-57.173 128-128 128-128-57.173-128-128z" />
<glyph unicode="&#xe94c;" glyph-name="miscellaneous_services_black_24dp" d="M604.587 375.040l59.733 103.253c3.84 6.4 2.133 14.507-3.413 19.2l-63.147 49.493c1.28 9.387 2.133 19.2 2.133 29.013s-0.853 19.627-2.133 29.44l63.147 49.493c5.547 4.693 7.253 12.8 3.413 19.2l-59.733 103.253c-3.84 6.4-11.52 8.96-18.347 6.4l-74.24-29.867c-15.36 11.947-32 21.76-50.347 29.44l-11.093 78.933c-1.28 6.827-7.68 12.373-14.933 12.373h-119.467c-7.253 0-13.653-5.547-14.933-12.8l-11.093-78.933c-17.92-7.68-34.987-17.493-50.347-29.44l-74.24 29.867c-6.827 2.56-14.507 0-18.347-6.4l-59.733-103.253c-3.84-6.4-2.133-14.507 3.413-19.2l63.147-49.493c-1.28-9.387-2.133-19.2-2.133-29.013s0.853-19.627 2.133-29.44l-63.147-49.493c-5.547-4.693-7.253-12.8-3.413-19.2l59.733-103.253c3.84-6.4 11.52-8.96 18.347-6.4l74.24 29.867c15.36-11.947 32-21.76 50.347-29.44l11.093-78.933c1.28-6.827 7.68-12.373 14.933-12.373h119.467c7.253 0 13.653 5.547 14.933 12.8l11.093 78.933c17.92 7.68 34.987 17.493 50.347 29.44l74.24-29.867c6.827-2.56 14.507 0 18.347 6.4zM375.893 490.667c-46.933 0-85.333 38.4-85.333 85.333s38.4 85.333 85.333 85.333 85.333-38.4 85.333-85.333c0-46.933-38.4-85.333-85.333-85.333zM935.253 163.413l-40.96 31.573c0.853 5.973 1.707 12.373 1.707 18.773s-0.427 12.8-1.707 18.773l40.533 31.573c3.413 2.987 4.693 8.107 2.133 12.373l-38.4 66.133c-2.133 4.267-7.253 5.547-11.947 4.267l-47.36-19.2c-9.813 7.68-20.48 14.080-32.427 18.773l-7.253 50.347c-0.427 5.12-4.693 8.533-8.96 8.533h-76.373c-4.693 0-8.96-3.413-9.387-8.107l-7.253-50.347c-11.52-5.12-22.613-11.093-32.427-18.773l-47.36 19.2c-4.267 1.707-9.387 0-11.947-4.267l-38.4-66.133c-2.133-4.267-1.707-9.387 2.133-12.373l40.533-31.573c-0.853-5.973-1.28-12.373-1.28-18.773s0.427-12.8 1.28-18.773l-40.533-31.573c-3.413-2.987-4.693-8.107-2.133-12.373l38.4-66.133c2.133-4.267 7.253-5.547 11.947-4.267l47.36 19.2c9.813-7.68 20.48-14.080 32.427-18.773l7.253-50.347c0.853-4.693 4.693-8.107 9.387-8.107h76.373c4.693 0 8.96 3.413 9.387 8.107l7.253 50.347c11.52 5.12 22.613 11.093 32 18.773l47.787-19.2c4.267-1.707 9.387 0 11.947 4.267l38.4 66.133c2.56 3.84 1.28 8.96-2.133 11.947zM752.213 156.587c-31.573 0-57.6 25.6-57.6 57.6s25.6 57.6 57.6 57.6 57.6-25.6 57.6-57.6-26.027-57.6-57.6-57.6z" />
<glyph unicode="&#xe94d;" glyph-name="mode_comment_black_24dp" d="M938.667 789.333c0 46.933-38.4 85.333-85.333 85.333h-682.667c-46.933 0-85.333-38.4-85.333-85.333v-512c0-46.933 38.4-85.333 85.333-85.333h597.333l170.667-170.667v768z" />
<glyph unicode="&#xe94e;" glyph-name="note_add_black_24dp" d="M622.507 849.493c-16.213 16.213-37.973 25.173-60.587 25.173h-305.92c-46.933 0-85.333-38.4-85.333-85.333v-682.667c0-46.933 37.973-85.333 84.907-85.333h512.427c46.933 0 85.333 38.4 85.333 85.333v476.587c0 22.613-8.96 44.373-25.173 60.16l-205.653 206.080zM640 277.333h-85.333v-85.333c0-23.467-19.2-42.667-42.667-42.667s-42.667 19.2-42.667 42.667v85.333h-85.333c-23.467 0-42.667 19.2-42.667 42.667s19.2 42.667 42.667 42.667h85.333v85.333c0 23.467 19.2 42.667 42.667 42.667s42.667-19.2 42.667-42.667v-85.333h85.333c23.467 0 42.667-19.2 42.667-42.667s-19.2-42.667-42.667-42.667zM554.667 618.667v192l234.667-234.667h-192c-23.467 0-42.667 19.2-42.667 42.667z" />
<glyph unicode="&#xe94f;" glyph-name="notification_important_black_24dp" d="M512-21.333c46.933 0 84.907 37.973 84.907 84.907h-169.813c0-46.933 37.973-84.907 84.907-84.907zM865.707 179.627l-55.040 55.040v256c0 142.933-100.693 262.4-234.667 291.413v49.92c0 35.413-28.587 64-64 64s-64-28.587-64-64v-49.92c-133.973-29.013-234.667-148.48-234.667-291.413v-256l-55.040-55.040c-26.88-26.88-8.107-72.96 29.867-72.96h647.253c38.4 0 57.173 46.080 30.293 72.96zM554.667 277.333h-85.333v85.333h85.333v-85.333zM554.667 490.667c0-23.467-19.2-42.667-42.667-42.667s-42.667 19.2-42.667 42.667v85.333c0 23.467 19.2 42.667 42.667 42.667s42.667-19.2 42.667-42.667v-85.333z" />
<glyph unicode="&#xe950;" glyph-name="priority_high_black_24dp" d="M597.333 149.333c0-47.128-38.205-85.333-85.333-85.333s-85.333 38.205-85.333 85.333c0 47.128 38.205 85.333 85.333 85.333s85.333-38.205 85.333-85.333zM512 832c-46.933 0-85.333-38.4-85.333-85.333v-341.333c0-46.933 38.4-85.333 85.333-85.333s85.333 38.4 85.333 85.333v341.333c0 46.933-38.4 85.333-85.333 85.333z" />
<glyph unicode="&#xe951;" glyph-name="privacy_tip_black_24dp" d="M178.773 769.28c-30.72-13.653-50.773-44.373-50.773-78.080v-200.533c0-236.8 163.84-458.24 384-512 220.16 53.76 384 275.2 384 512v200.533c0 33.707-20.053 64.427-50.773 78.080l-298.667 132.693c-22.187 9.813-47.36 9.813-69.12 0l-298.667-132.693zM512 661.333v0c23.467 0 42.667-19.2 42.667-42.667v0c0-23.467-19.2-42.667-42.667-42.667v0c-23.467 0-42.667 19.2-42.667 42.667v0c0 23.467 19.2 42.667 42.667 42.667zM512 490.667v0c23.467 0 42.667-19.2 42.667-42.667v-170.667c0-23.467-19.2-42.667-42.667-42.667v0c-23.467 0-42.667 19.2-42.667 42.667v170.667c0 23.467 19.2 42.667 42.667 42.667z" />
<glyph unicode="&#xe952;" glyph-name="qr_code_2_black_24dp" d="M640 64h-85.333v85.333h85.333v-85.333zM554.667 362.667h-85.333v-213.333h85.333v213.333zM896 448h-85.333v-170.667h85.333v170.667zM810.667 533.333h-85.333v-85.333h85.333v85.333zM298.667 448h-85.333v-85.333h85.333v85.333zM213.333 533.333h-85.333v-85.333h85.333v85.333zM512 746.667h85.333v85.333h-85.333v-85.333zM192 768v-128h128v128h-128zM341.333 576h-170.667c-23.467 0-42.667 19.2-42.667 42.667v170.667c0 23.467 19.2 42.667 42.667 42.667h170.667c23.467 0 42.667-19.2 42.667-42.667v-170.667c0-23.467-19.2-42.667-42.667-42.667zM192 256v-128h128v128h-128zM341.333 64h-170.667c-23.467 0-42.667 19.2-42.667 42.667v170.667c0 23.467 19.2 42.667 42.667 42.667h170.667c23.467 0 42.667-19.2 42.667-42.667v-170.667c0-23.467-19.2-42.667-42.667-42.667zM704 768v-128h128v128h-128zM853.333 576h-170.667c-23.467 0-42.667 19.2-42.667 42.667v170.667c0 23.467 19.2 42.667 42.667 42.667h170.667c23.467 0 42.667-19.2 42.667-42.667v-170.667c0-23.467-19.2-42.667-42.667-42.667zM810.667 149.333v128h-170.667v-85.333h85.333v-128h170.667v85.333h-85.333zM725.333 448h-170.667v-85.333h170.667v85.333zM554.667 533.333h-256v-85.333h85.333v-85.333h85.333v85.333h85.333v85.333zM597.333 576v85.333h-85.333v85.333h-85.333v-170.667h170.667zM288 736h-64v-64h64v64zM288 224h-64v-64h64v64zM800 736h-64v-64h64v64z" />
<glyph unicode="&#xe953;" glyph-name="radio_button_checked_black_24dp" d="M512 874.667c-235.52 0-426.667-191.147-426.667-426.667s191.147-426.667 426.667-426.667 426.667 191.147 426.667 426.667-191.147 426.667-426.667 426.667zM512 106.667c-188.587 0-341.333 152.747-341.333 341.333s152.747 341.333 341.333 341.333 341.333-152.747 341.333-341.333-152.747-341.333-341.333-341.333zM725.333 448c0-117.821-95.513-213.333-213.333-213.333s-213.333 95.513-213.333 213.333c0 117.821 95.513 213.333 213.333 213.333s213.333-95.513 213.333-213.333z" />
<glyph unicode="&#xe954;" glyph-name="radio_button_unchecked_black_24dp" d="M512 874.667c-235.52 0-426.667-191.147-426.667-426.667s191.147-426.667 426.667-426.667 426.667 191.147 426.667 426.667-191.147 426.667-426.667 426.667zM512 106.667c-188.587 0-341.333 152.747-341.333 341.333s152.747 341.333 341.333 341.333 341.333-152.747 341.333-341.333-152.747-341.333-341.333-341.333z" />
<glyph unicode="&#xe955;" glyph-name="settings_suggest_black_24dp" d="M769.707 619.093l-26.88 59.733-59.733 26.88c-16.64 7.68-16.64 31.147 0 38.827l59.733 26.88 26.88 59.733c7.68 16.64 31.147 16.64 38.827 0l26.88-59.733 59.733-26.88c16.64-7.68 16.64-31.147 0-38.827l-59.733-26.88-26.88-59.733c-7.253-16.64-31.147-16.64-38.827 0zM907.947 417.28l-13.653 30.72c-7.68 16.64-31.147 16.64-38.827 0l-13.653-30.72-31.147-13.653c-16.64-7.68-16.64-31.147 0-38.827l30.72-13.653 13.653-31.147c7.68-16.64 31.147-16.64 38.827 0l13.653 30.72 31.147 13.653c16.64 7.68 16.64 31.147 0 38.827l-30.72 14.080zM692.907 346.88l52.48-39.68c17.067-12.8 21.76-36.693 11.093-55.467l-69.12-119.467c-10.667-18.773-33.707-26.453-53.333-17.92l-61.013 25.6c-8.533-5.547-17.92-11.093-27.307-15.787l-8.107-65.707c-2.56-21.333-20.907-37.547-42.24-37.547h-137.813c-21.333 0-39.68 16.213-42.24 37.547l-8.107 65.707c-9.387 4.693-18.347 9.813-27.307 15.787l-61.013-25.6c-19.627-8.533-42.667-0.853-53.333 17.92l-69.12 119.467c-10.667 18.773-5.973 42.24 11.093 55.467l52.48 39.68c0 5.12 0 10.667 0 15.787s0 10.667 0.427 15.787l-52.48 39.68c-17.067 12.8-21.76 36.693-11.093 55.467l69.12 119.467c10.667 18.773 33.707 26.453 53.333 17.92l61.013-25.6c8.533 5.547 17.92 11.093 27.307 15.787l8.107 65.707c2.133 20.907 20.48 37.12 41.813 37.12h137.813c21.333 0 39.68-16.213 42.24-37.547l8.107-65.707c9.387-4.693 18.347-9.813 27.307-15.787l61.013 25.6c19.627 8.533 42.667 0.853 53.333-17.92l69.12-119.467c10.667-18.773 5.973-42.24-11.093-55.467l-52.48-39.68c0.427-5.12 0.427-10.24 0.427-15.787s0-10.24-0.427-15.36zM554.667 362.667c0 70.827-57.173 128-128 128s-128-57.173-128-128 57.173-128 128-128 128 57.173 128 128z" />
<glyph unicode="&#xe956;" glyph-name="star_black_24dp" d="M512 223.147l177.067-107.093c32.427-19.627 72.107 9.387 63.573 46.080l-46.933 201.387 156.587 135.68c28.587 24.747 13.227 71.68-24.32 74.667l-206.080 17.493-80.64 190.293c-14.507 34.56-64 34.56-78.507 0l-80.64-189.867-206.080-17.493c-37.547-2.987-52.907-49.92-24.32-74.667l156.587-135.68-46.933-201.387c-8.533-36.693 31.147-65.707 63.573-46.080l177.067 106.667z" />
<glyph unicode="&#xe957;" glyph-name="star_border_black_24dp" d="M838.4 574.293l-206.507 17.92-80.64 189.867c-14.507 34.56-64 34.56-78.507 0l-80.64-190.293-206.080-17.493c-37.547-2.987-52.907-49.92-24.32-74.667l156.587-135.68-46.933-201.387c-8.533-36.693 31.147-65.707 63.573-46.080l177.067 106.667 177.067-107.093c32.427-19.627 72.107 9.387 63.573 46.080l-46.933 201.813 156.587 135.68c28.587 24.747 13.653 71.68-23.893 74.667zM512 302.933l-160.427-96.853 42.667 182.613-141.653 122.88 186.88 16.213 72.533 171.947 72.96-172.373 186.88-16.213-141.653-122.88 42.667-182.613-160.853 97.28z" />
<glyph unicode="&#xe958;" glyph-name="star_border_purple500_black_24dp" d="M512 580.693l40.107-132.693h120.32l-96.853-69.12 39.68-128.427-103.253 78.507-103.253-78.507 39.68 128.427-96.853 69.12h120.32l40.107 132.693zM408.747 533.333h-190.293c-41.387 0-58.453-53.333-24.747-77.227l155.307-110.933-61.013-196.693c-12.373-39.68 33.707-71.68 66.56-46.507l157.44 119.467 157.44-119.893c32.853-25.173 78.933 6.827 66.56 46.507l-61.013 196.693 155.307 110.933c33.707 24.32 16.64 77.227-24.747 77.227h-190.293l-62.72 206.507c-12.373 40.533-69.547 40.533-81.493 0l-62.293-206.080z" />
<glyph unicode="&#xe959;" glyph-name="star_half_black_24dp" d="M838.4 574.293l-206.507 17.92-80.64 189.867c-14.507 34.56-64 34.56-78.507 0l-80.64-190.293-206.080-17.493c-37.547-2.987-52.907-49.92-24.32-74.667l156.587-135.68-46.933-201.387c-8.533-36.693 31.147-65.707 63.573-46.080l177.067 106.667 177.067-107.093c32.427-19.627 72.107 9.387 63.573 46.080l-46.933 201.813 156.587 135.68c28.587 24.747 13.653 71.68-23.893 74.667zM512 302.933v396.8l72.96-172.373 186.88-16.213-141.653-122.88 42.667-182.613-160.853 97.28z" />
<glyph unicode="&#xe95a;" glyph-name="star_outline_black_24dp" d="M838.4 574.293l-206.507 17.92-80.64 189.867c-14.507 34.56-64 34.56-78.507 0l-80.64-190.293-206.080-17.493c-37.547-2.987-52.907-49.92-24.32-74.667l156.587-135.68-46.933-201.387c-8.533-36.693 31.147-65.707 63.573-46.080l177.067 106.667 177.067-107.093c32.427-19.627 72.107 9.387 63.573 46.080l-46.933 201.813 156.587 135.68c28.587 24.747 13.653 71.68-23.893 74.667zM512 302.933l-160.427-96.853 42.667 182.613-141.653 122.88 186.88 16.213 72.533 171.947 72.96-172.373 186.88-16.213-141.653-122.88 42.667-182.613-160.853 97.28z" />
<glyph unicode="&#xe95b;" glyph-name="star_purple500_black_24dp" d="M512 580.693l40.107-132.693h120.32l-96.853-69.12 39.68-128.427-103.253 78.507-103.253-78.507 39.68 128.427-96.853 69.12h120.32l40.107 132.693zM408.747 533.333h-190.293c-41.387 0-58.453-53.333-24.747-77.227l155.307-110.933-61.013-196.693c-12.373-39.68 33.707-71.68 66.56-46.507l157.44 119.467 157.44-119.893c32.853-25.173 78.933 6.827 66.56 46.507l-61.013 196.693 155.307 110.933c33.707 24.32 16.64 77.227-24.747 77.227h-190.293l-62.72 206.507c-12.373 40.533-69.547 40.533-81.493 0l-62.293-206.080z" />
<glyph unicode="&#xe95c;" glyph-name="support_agent_black_24dp" d="M896 438.613c0 234.24-181.76 393.387-384 393.387-200.107 0-384-155.733-384-395.947-25.6-14.507-42.667-41.813-42.667-73.387v-85.333c0-46.933 38.4-85.333 85.333-85.333v0c23.467 0 42.667 19.2 42.667 42.667v205.227c0 163.413 125.867 306.347 289.28 311.040 168.96 5.12 308.053-130.56 308.053-298.667v-302.933h-298.667c-23.467 0-42.667-19.2-42.667-42.667v0c0-23.467 19.2-42.667 42.667-42.667h298.667c46.933 0 85.333 38.4 85.333 85.333v52.053c25.173 13.227 42.667 39.253 42.667 69.973v98.133c0 29.867-17.493 55.893-42.667 69.12zM426.667 405.333c0-23.564-19.103-42.667-42.667-42.667s-42.667 19.103-42.667 42.667c0 23.564 19.103 42.667 42.667 42.667s42.667-19.103 42.667-42.667zM682.667 405.333c0-23.564-19.103-42.667-42.667-42.667s-42.667 19.103-42.667 42.667c0 23.564 19.103 42.667 42.667 42.667s42.667-19.103 42.667-42.667zM768 489.387c-20.48 121.6-126.293 214.613-253.867 214.613-129.28 0-268.373-107.093-257.28-275.2 105.387 43.093 184.747 136.96 207.36 251.307 55.893-112.213 170.667-189.44 303.787-190.72z" />
<glyph unicode="&#xe95d;" glyph-name="sync_black_24dp" d="M512 789.333v76.373c0 19.2-23.040 28.587-36.267 14.933l-119.467-119.040c-8.533-8.533-8.533-21.76 0-30.293l119.040-119.040c13.653-13.227 36.693-3.84 36.693 15.36v76.373c141.227 0 256-114.773 256-256 0-33.707-6.4-66.56-18.773-96-6.4-15.36-1.707-32.853 9.813-44.373 21.76-21.76 58.453-14.080 69.973 14.507 15.787 38.827 24.32 81.493 24.32 125.867 0 188.587-152.747 341.333-341.333 341.333zM512 192c-141.227 0-256 114.773-256 256 0 33.707 6.4 66.56 18.773 96 6.4 15.36 1.707 32.853-9.813 44.373-21.76 21.76-58.453 14.080-69.973-14.507-15.787-38.827-24.32-81.493-24.32-125.867 0-188.587 152.747-341.333 341.333-341.333v-76.373c0-19.2 23.040-28.587 36.267-14.933l119.040 119.040c8.533 8.533 8.533 21.76 0 30.293l-119.040 119.040c-13.227 13.227-36.267 3.84-36.267-15.36v-76.373z" />
<glyph unicode="&#xe95e;" glyph-name="task_alt_black_24dp" d="M908.373 708.693l-426.667-426.667c-16.64-16.64-43.52-16.64-60.16 0l-120.747 120.747c-16.64 16.64-16.64 43.52 0 60.16v0c16.64 16.64 43.52 16.64 60.16 0l90.453-90.453 396.373 396.373c16.64 16.64 43.52 16.64 60.16 0v0c17.067-16.64 17.067-43.52 0.427-60.16zM672.853 843.093c-72.107 29.44-154.027 39.68-239.36 24.32-173.653-31.147-312.32-171.093-341.76-344.747-48.64-288 191.147-534.613 477.44-497.493 168.96 21.76 310.613 147.627 354.987 311.893 17.067 62.72 18.773 123.307 8.96 180.053-5.547 34.133-47.787 47.36-72.533 23.040v0c-9.813-9.813-14.080-24.32-11.52-37.973 9.387-56.747 5.12-117.333-22.187-181.76-49.493-115.627-157.013-200.533-282.027-212.053-217.6-20.053-398.080 164.267-371.2 383.147 18.347 151.040 139.947 273.92 290.56 294.827 73.813 10.24 143.787-3.84 203.52-34.56 16.64-8.533 36.693-5.547 49.92 7.68v0c20.48 20.48 15.36 55.040-10.24 68.267-11.52 5.12-23.040 10.667-34.56 15.36z" />
<glyph unicode="&#xe95f;" glyph-name="task_black_24dp" d="M828.16 643.84l-206.080 206.080c-15.787 15.787-37.547 24.747-60.16 24.747h-305.92c-46.933 0-84.907-38.4-84.907-85.333l-0.427-682.667c0-46.933 37.973-85.333 84.907-85.333h512.427c46.933 0 85.333 38.4 85.333 85.333v476.587c0 22.613-8.96 44.373-25.173 60.587zM436.48 222.293l-90.453 90.453c-16.64 16.64-16.64 43.52 0 60.16v0c16.64 16.64 43.52 16.64 60.16 0l60.16-60.16 151.040 151.040c16.64 16.64 43.52 16.64 60.16 0v0c16.64-16.64 16.64-43.52 0-60.16l-180.907-180.907c-16.213-17.067-43.52-17.067-60.16-0.427zM597.333 576c-23.467 0-42.667 19.2-42.667 42.667v192l234.667-234.667h-192z" />
<glyph unicode="&#xe960;" glyph-name="toggle_off_black_24dp" d="M725.333 661.333h-426.667c-117.76 0-213.333-95.573-213.333-213.333s95.573-213.333 213.333-213.333h426.667c117.76 0 213.333 95.573 213.333 213.333s-95.573 213.333-213.333 213.333zM298.667 320c-70.827 0-128 57.173-128 128s57.173 128 128 128 128-57.173 128-128-57.173-128-128-128z" />
<glyph unicode="&#xe961;" glyph-name="toggle_on_black_24dp" d="M725.333 661.333h-426.667c-117.76 0-213.333-95.573-213.333-213.333s95.573-213.333 213.333-213.333h426.667c117.76 0 213.333 95.573 213.333 213.333s-95.573 213.333-213.333 213.333zM725.333 320c-70.827 0-128 57.173-128 128s57.173 128 128 128 128-57.173 128-128-57.173-128-128-128z" />
<glyph unicode="&#xe962;" glyph-name="view_week_black_24dp" d="M227.413 106.667h-56.747c-46.933 0-85.333 38.4-85.333 85.333v512c0 46.933 38.4 85.333 85.333 85.333h56.747c46.933 0 85.333-38.4 85.333-85.333v-512c0-46.933-37.973-85.333-85.333-85.333zM938.667 192v512c0 46.933-38.4 85.333-85.333 85.333h-56.747c-46.933 0-85.333-38.4-85.333-85.333v-512c0-46.933 38.4-85.333 85.333-85.333h56.747c47.36 0 85.333 38.4 85.333 85.333zM625.92 192v512c0 46.933-38.4 85.333-85.333 85.333h-56.747c-46.933 0-85.333-38.4-85.333-85.333v-512c0-46.933 38.4-85.333 85.333-85.333h56.747c46.933 0 85.333 38.4 85.333 85.333z" />
<glyph unicode="&#xe963;" glyph-name="warning_amber_black_24dp" d="M512 704.427l321.28-555.093h-642.56l321.28 555.093zM116.907 192c-32.853-56.747 8.107-128 73.813-128h642.56c65.707 0 106.667 71.253 73.813 128l-321.28 555.093c-32.853 56.747-114.773 56.747-147.627 0l-321.28-555.093zM469.333 490.667v-85.333c0-23.467 19.2-42.667 42.667-42.667s42.667 19.2 42.667 42.667v85.333c0 23.467-19.2 42.667-42.667 42.667s-42.667-19.2-42.667-42.667zM469.333 277.333h85.333v-85.333h-85.333z" />
<glyph unicode="&#xe964;" glyph-name="warning_black_24dp" d="M190.72 64h642.56c65.707 0 106.667 71.253 73.813 128l-321.28 555.093c-32.853 56.747-114.773 56.747-147.627 0l-321.28-555.093c-32.853-56.747 8.107-128 73.813-128zM512 362.667c-23.467 0-42.667 19.2-42.667 42.667v85.333c0 23.467 19.2 42.667 42.667 42.667s42.667-19.2 42.667-42.667v-85.333c0-23.467-19.2-42.667-42.667-42.667zM554.667 192h-85.333v85.333h85.333v-85.333z" />
<glyph unicode="&#xe965;" glyph-name="work_off_black_24dp" d="M175.36 851.627c-16.64 16.64-43.52 16.64-60.16 0s-16.64-43.52 0-60.16l87.040-87.467h-31.573c-47.36 0-84.907-37.973-84.907-85.333l-0.427-469.333c0-47.36 37.973-85.333 85.333-85.333h671.573l55.040-55.040c16.64-16.64 43.52-16.64 60.16 0s16.64 43.52 0 60.16l-782.080 782.507zM426.667 789.333h170.667v-85.333h-153.6l494.933-494.933v409.6c0 47.36-37.973 85.333-85.333 85.333h-170.667v85.333c0 47.36-37.973 85.333-85.333 85.333h-170.667c-42.24 0-76.8-29.867-83.627-69.973l83.627-83.627v68.267z" />
</font></defs></svg>
 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 /* OTOBO is a web-based ticketing system for service organisations.

Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/

This program is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/

/**
 * @package     Skin "Default"
 * @section     Input Fields
 */

@media screen,projection,tv,handheld {

/**
 * @subsection  General
 */

div.InputField_Container {
    position: static;
    display: inline-block;
}

div.InputField_InputContainer {
    position: relative;
    display: inline-block;
    line-height: 11px;
}

.InputField_Search::-ms-clear {
    display: none;
    width : 0;
    height: 0;
}

.InputField_Search,
.InputField_Autocomplete {
/* Rother OSS
    min-width: 190px; */
    min-width: 300px;
/* EO Rother OSS */
}

.InputField_Search.Small {
    min-width: 130px;
}

.InputField_Search[readonly]:focus {
    border-color: var(--colBGDark);
}

.InputField_Search[readonly].Error:focus {
    border-color: var(--colTextErr);
}

.SidebarColumn .WidgetSimple .InputField_Search,
.SidebarColumn .WidgetSimple .InputField_Autocomplete {
    min-width: 80px;
    box-sizing: border-box;
}

.SidebarColumn .WidgetSimple .InputField_Container,
.SidebarColumn .WidgetSimple .InputField_Container .InputField_InputContainer,
.SidebarColumn .WidgetSimple select.Modernize {
    width: 100%;
}

.WidgetSettingsForm .InputField_Search,
.WidgetSettingsForm .InputField_Autocomplete {
    min-width: 0px;
}

.oooACLHidden {
    display: none !important;
}

.MultiValue_Template {
    display: none !important;
}

.Row_DynamicField {
    display: grid;
}

@media only screen and (min-width: 1025px) {
    fieldset.TableLike > .Field > .Modernize#TypeID,
    fieldset.TableLike > .Field > .Modernize#Dest,
    fieldset.TableLike > .Field > .Modernize#NewQueueID,
    fieldset.TableLike > .Field > .Modernize#ServiceID,
    fieldset.TableLike > .Field > .Modernize#SLAID,
    fieldset.TableLike > .Field > .Modernize#NewUserID,
    fieldset.TableLike > .Field > .Modernize#NewOwnerID,
    fieldset.TableLike > .Field > .Modernize#NewResponsibleID,
    fieldset.TableLike > .Field > .Modernize#StandardTemplateID,
    fieldset.TableLike > .Field > .Modernize#NextStateID,
    fieldset.TableLike > .Field > .Modernize#NewStateID,
    fieldset.TableLike > .Field > .Modernize#PriorityID,
    fieldset.TableLike > .Field > .Modernize#NewPriorityID,
    fieldset.TableLike > .Row > .Field > select.Modernize {
        min-width: 300px;
    }

    fieldset.TableLike > .Field > input.W50pc,
    fieldset.TableLike > .Row > .Field > input.W50pc {
        max-width: 310px;
        box-sizing: border-box;
    }

    fieldset.TableLike .Row > .FieldCell > .Field > select.Modernize,
    fieldset.TableLike .Row > .FieldCell > .Field > input.W75pc,
    fieldset.TableLike .Row > .FieldCell > .Field > input.W50pc,
    fieldset.TableLike .Row > .FieldCell > .Field > input[type="text"],
    fieldset.TableLike .FieldCell > .Field > div.InputField_Container > div.InputField_InputContainer > .InputField_Search,
    fieldset.TableLike .FieldCell > .Field > div.InputField_Container > div.InputField_InputContainer > .InputField_Autocomplete {
        min-width: 300px;
    }

    fieldset.TableLike > .Row:not(.MultiColumn) > .FieldCell > .Field > input.W50pc {
        max-width: 50%;
        box-sizing: border-box;
    }

    fieldset.TableLike > .Field > input.W75pc,
    fieldset.TableLike > .Row > .Field > input.W75pc {
        max-width: 620px;
        box-sizing: border-box;
    }

    fieldset.TableLike > .Field > input#Subject {
        width: 75%;
        max-width: 620px;
        box-sizing: border-box;
    }

    fieldset.TableLike > .Field > div.CustomerContainer,
    fieldset.TableLike > .Field > div.CcCustomerContainer,
    fieldset.TableLike > .Field > div.BccCustomerContainer {
        width: calc( 75% - 7px );
        max-width: 607px;
    }

}

#Header div.InputField_Container {
    color: var(--colTextDark);
}

#ToolBar li.Extended form div.InputField_Container * {
	float: none;
}

#ToolBar div.InputField_Container li {
    height: auto;
    margin: inherit;
    width: auto;
}

#ToolBar div.InputField_Container a {
    display: inline-block;
    height: auto;
    text-indent: 0;
    width: auto;
}

#ToolBar .InputField_Search,
#ToolBar .InputField_Autocomplete {
    min-width: 65px;
}

.InputField_Search[disabled] {
    color: #aaa;
}

div.InputField_InputContainer .InputField_Search {
    margin: 0;
    border-radius: 4px;
}

#ContextSettingsDialog div.InputField_InputContainer .InputField_Search {
    min-width: 0px;
}

fieldset.TableLike > .Row.MultiColumn > .FieldCell > .Field > select.Modernize,
fieldset.TableLike > .Row.MultiColumn > .FieldCell > .Field > input.W75pc,
fieldset.TableLike > .Row.MultiColumn > .FieldCell > .Field > input.W50pc,
fieldset.TableLike > .Row.MultiColumn > .FieldCell .InputField_InputContainer > input {
    min-width: 0 !important;
    width: calc( 100% - 7px );
}

.DynamicFieldDB {
    width: calc(100% - 12px) !important;
    box-sizing: border-box;
}

fieldset.TableLike > .Row.MultiColumn > .FieldCell .InputField_Container,
fieldset.TableLike > .Row.MultiColumn > .FieldCell .InputField_InputContainer {
    padding-left: 0;
    padding-right: 0;
    width: 100% !important;
}

/*.FieldCell .InputField_Search {
    width: 100% !important;
}*/

/*.MultiColumn > .FieldCell > .Field > div.InputField_Container > div.InputField_InputContainer > .InputField_Search,
.MultiColumn > .FieldCell > .Field > div.InputField_Container > div.InputField_InputContainer > .InputField_Autocomplete {
    min-width: 100%;
    width: 100% !important;
}*/

.FieldCell {
    white-space: nowrap;
}

.FieldCell div.oooTitle {
    white-space: normal;
}

/*div.Row.Row_DynamicField div.SingleColumn > label,
div.Row.Row_DynamicField div.SingleColumn > div.MultiValueItem > label,
div.Row.Row_DynamicField div.MultiColumn > label,
div.Row.Row_DynamicField div.MultiColumn > div.MultiValueItem > label {
    width: auto;
    margin-right: 5px;
    float: none;
    text-align: left;
    font-size: 0.9em;
    overflow-wrap: break-word;
    display: block;
    line-height: 1.9em;
    min-height: 17px;
    padding-top: 0.3em;
    padding-bottom: 1px;
    text-shadow: 0 1px 0 #FAFAFA;
}*/

.AddRemoveValueRow {
    display: inline-block;
    padding-left: 8px;
}

.AddValueRow,
.RemoveValueRow {
    cursor: pointer;
}

fieldset.DynamicFieldSet {
    box-sizing: border-box;
    width: 100%
}

/* needed for multivalue sets due to current difference in outer structure compared to single value sets */
.MultiValue > .FieldCell > .Field > .DynamicFieldSet {
    width: 100%;
}

.MultiValue .DFSetOuterField ~ .AddRemoveValueRow {
    vertical-align: top;
    padding-top: 16px;
}

a.InputField_Action {
    position: absolute;
    display: block;
    color: var(--colTextDark);
    top: 5px;
}

a.InputField_Action:hover {
    color: var(--colHighlight);
}

div.InputField_Selection {
    display: none;
    position: absolute;
    top: 4px;
    height: 17px;
    line-height: 11px;
    text-shadow: none;
}

div.InputField_Selection div {
    display: inline-block;
    font-size: 11px;
}

div.InputField_Selection div.Text {
    background: var(--colBGMedium);
    padding: 2px 4px;
}

div.InputField_Selection div.Remove {
    background: var(--colBGDark);
    color: #fff;
    cursor: pointer;
}

.AlreadyDisabled div.InputField_Selection div.Text {
    background: var(--colBGLight);
    cursor: default;
}

.AlreadyDisabled div.InputField_Selection div.Remove {
    visibility: hidden;
    display: none;
}

div.InputField_Selection div.Remove a {
    color: #fff;
    padding: 2px 4px;
    display: block;
    border-bottom: none;
}

div.InputField_More {
    position: absolute;
    white-space: nowrap;
    top: 6px;
}

div.InputField_ListContainer {
    position: absolute;
    z-index: 6100;
    display: none;
    text-shadow: none;
}

div.InputField_TreeContainer {
    background-color: #fff;
    border: 1px solid var(--colBGDark);
    border-top: none;
    overflow-y: auto;
    box-sizing: content-box;
    line-height: 18px;
}

.ExpandToTop div.InputField_TreeContainer {
    border-top: 1px solid #ccc;
    border-bottom: none;
}

div.InputField_ToolbarContainer {
    background-color: var(--colBGLight);
    border: 1px solid var(--colBGMedium);
    border-top: none;
    line-height: 21px;
    box-sizing: content-box;
    min-height: 21px;
}

div.InputField_ToolbarContainer ul {
    width: 100%;
    display: table;
}

div.InputField_ToolbarContainer ul li {
    display: table-cell;
    text-align: center;
}

div.InputField_ToolbarContainer ul li:after {
    color: #bbb;
    content: "|";
    float: right; 
    cursor: default;
}

div.InputField_ToolbarContainer ul li:last-child:after {
    display: none;
}

.RTL div.InputField_ToolbarContainer ul li:last-child:after {
    display: inline-block;
}

.RTL div.InputField_ToolbarContainer ul li:first-child:after {
    display: none;
}

div.InputField_ToolbarContainer ul li a {
    color: var(--colTextDark);
    display: inline-block;
    margin: 2px 5px;
    font-size: 11px;
    line-height: 15px;
}

div.InputField_ToolbarContainer i {
    color: var(--colTextDark);
}

div.InputField_ToolbarContainer ul li a:hover {
    border-bottom: 2px solid var(--colHighlight);
    margin-bottom: 0;
}

.InputField_Confirm,
.InputField_Filters.Active {
    font-weight: bold;
}

.InputField_FiltersList {
    background: #fff;
    white-space: nowrap;
    border-top: 1px solid var(--colBGDark);
    z-index: 1500;
    line-height: 1.5em;
    width: 100%;
    font-size: 11px;
}

.InputField_FiltersList span {
    margin-right: 5px;
    cursor: default;
}

.InputField_FiltersList input[disabled] + span {
    font-style: italic;
    color: var(--colTextLight);
}

/**
 * @subsection  jsTree theme
 */
.jstree-InputField {
    font-size: 11px;
    border: none;
    box-shadow: none;
    height: 100%;
    margin: 0;
    padding: 0;
}

.jstree-InputField .jstree-node,
.jstree-InputField .jstree-children,
.jstree-InputField .jstree-container-ul {
    display: block;
    margin: 0;
    padding: 0;
    list-style-type: none;
    list-style-image: none;
    text-align: left;
}

.RTL .jstree-InputField .jstree-node,
.RTL .jstree-InputField .jstree-children,
.RTL .jstree-InputField .jstree-container-ul {
    text-align: right;
}

.jstree-InputField .jstree-node {
    white-space: nowrap;
}

.jstree-InputField .jstree-node.jstree-hidden {
    display: none;
}

.jstree-InputField .jstree-anchor {
    display: inline-block;
    color: var(--colTextDark);
    white-space: nowrap;
    padding: 0 4px 0 1px;
    margin: 0;
    vertical-align: top;
}

.jstree-InputField .jstree-anchor:focus {
    outline: 0;
    background: transparent !important;
}

.jstree-InputField .jstree-anchor,
.jstree-InputField .jstree-anchor:link,
.jstree-InputField .jstree-anchor:visited,
.jstree-InputField .jstree-anchor:hover,
.jstree-InputField .jstree-anchor:active {
    text-decoration: none;
    color: inherit;
}

.jstree-InputField .jstree-icon {
    display: inline-block;
    text-decoration: none;
    margin: 0;
    padding: 0;
    vertical-align: top;
    text-align: center;
}

.jstree-InputField .jstree-icon:empty {
    display: inline-block;
    text-decoration: none;
    margin: 0;
    padding: 0;
    vertical-align: top;
    text-align: center;
}

.jstree-InputField .jstree-ocl {
    cursor: pointer;
}

.jstree-InputField .jstree-leaf > .jstree-ocl {
    cursor: default;
}

.jstree-InputField .jstree .jstree-open > .jstree-children {
    display: block;
}

.jstree-InputField .jstree .jstree-closed > .jstree-children,
.jstree-InputField .jstree .jstree-leaf > .jstree-children {
    display: none;
}

.jstree-InputField .jstree-anchor > .jstree-themeicon {
    margin-right: 2px;
}

.jstree-InputField .jstree-no-icons .jstree-themeicon,
.jstree-InputField .jstree-anchor > .jstree-themeicon-hidden {
    display: none;
}

.jstree-InputField .jstree-rtl .jstree-anchor {
    padding: 0 1px 0 4px;
}

.jstree-InputField .jstree-rtl .jstree-anchor > .jstree-themeicon {
    margin-left: 2px;
    margin-right: 0;
}

.jstree-InputField .jstree-rtl .jstree-node {
    margin-left: 0;
}

.jstree-InputField .jstree-rtl .jstree-container-ul > .jstree-node {
    margin-right: 0;
}

.jstree-InputField .jstree-hovered {
    background-color: transparent !important;
}

.jstree-InputField .Disabled > .jstree-anchor {
    color: var(--colTextLight) !important;
    font-style: italic;
    cursor: default;
}

.jstree-InputField .jstree-open,
.jstree-InputField .jstree-closed {
    cursor: pointer;
}

.jstree-InputField .jstree-wholerow-ul {
    position: relative;
    display: inline-block;
    min-width: 100%;
}

.jstree-InputField .jstree-wholerow-ul .jstree-leaf > .jstree-ocl {
    cursor: pointer;
}

.jstree-InputField .jstree-wholerow-ul .jstree-anchor,
.jstree-InputField .jstree-wholerow-ul .jstree-icon {
    position: relative;
}

.jstree-InputField .jstree-wholerow-ul .jstree-wholerow {
    width: 100%;
    cursor: pointer;
    position: absolute;
    left: 0;
    -webkit-user-select: none;
    -moz-user-select: none;
    -ms-user-select: none;
    user-select: none;
}

.jstree-InputField .jstree-wholerow-ul .jstree-wholerow-clicked {
    background-color: var(--colBGMedium);
}

.jstree-InputField .jstree-wholerow-ul .jstree-wholerow:hover,
.jstree-InputField .jstree-wholerow-ul .jstree-wholerow-hovered,
.jstree-InputField .jstree-focused > .jstree-wholerow {
    background-color: var(--colHoverLight);
}

.jstree-InputField .jstree-wholerow-ul .jstree-wholerow-clicked:hover,
.jstree-InputField .jstree-wholerow-ul .jstree-wholerow-clicked.jstree-wholerow-hovered,
.jstree-InputField .jstree-focused > .jstree-wholerow-clicked {
    background-color: var(--colHoverDark);
}

.jstree-InputField .Disabled > .jstree-wholerow:hover,
.jstree-InputField .Disabled > .jstree-wholerow-hovered {
    background-color: var(--colBGDark);
    cursor: default;
}

.jstree-InputField .Disabled.jstree-open > .jstree-anchor,
.jstree-InputField .Disabled.jstree-closed > .jstree-anchor {
    cursor: pointer !important;
}

.jstree-InputField .jstree-clicked {
    background: transparent !important;
    border: none !important;
    padding: 0 4px 0 1px !important;
}

.jstree-InputField.jstree-rtl .jstree-node {
    background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAACAQMAAAB49I5GAAAABlBMVEUAAAAdHRvEkCwcAAAAAXRSTlMAQObYZgAAAAxJREFUCNdjAAMOBgAAGAAJMwQHdQAAAABJRU5ErkJggg==");
    background-position: 100% 1px;
    background-repeat: repeat-y;
}

.jstree-InputField.jstree-rtl .jstree-last {
    background: transparent;
}

.jstree-InputField.jstree-rtl .jstree-open > .jstree-ocl {
    background-position: -135px -39px;
}

.jstree-InputField.jstree-rtl .jstree-closed > .jstree-ocl {
    background-position: -103px -39px;
}

.jstree-InputField.jstree-rtl .jstree-leaf > .jstree-ocl {
    background-position: -71px -39px;
}

.jstree-InputField.jstree-rtl > .jstree-no-dots .jstree-node,
.jstree-InputField.jstree-rtl > .jstree-no-dots .jstree-leaf > .jstree-ocl {
    background: transparent;
}

.jstree-InputField.jstree-rtl > .jstree-no-dots .jstree-open > .jstree-ocl {
    background-position: -39px -39px;
}
.jstree-InputField.jstree-rtl > .jstree-no-dots .jstree-closed > .jstree-ocl {
    background-position: -7px -39px;
}

.jstree-InputField .jstree-themeicon-custom {
    background-color: transparent;
    background-image: none;
    background-position: 0 0;
}

.jstree-InputField.jstree-rtl .jstree-node {
    background-image: url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABIAAAACAQMAAABv1h6PAAAABlBMVEUAAAAdHRvEkCwcAAAAAXRSTlMAQObYZgAAAAxJREFUCNdjAAMHBgAAiABBI4gz9AAAAABJRU5ErkJggg==');
}

.jstree-InputField.jstree-rtl .jstree-last {
    background: transparent;
}

.jstree-InputField .jstree-search {
    font-style: italic;
}

.jstree-InputField .jstree-no-match .jstree-ocl {
    display: none;
}

.jstree-InputField .jstree-no-match {
    margin-left: 2px !important;
}

.jstree-InputField.jstree-rtl .jstree-no-match {
    margin-right: 2px !important;
}

/**
 * @subsection  jsTree theme - Tree variant
 */
.jstree-InputField-Tree .jstree-node {
    min-height: 18px;
    line-height: 18px;
    margin-left: 18px;
    min-width: 18px;
}

.RTL .jstree-InputField-Tree .jstree-node {
    margin-right: 18px;
    margin-left: 0;
}

.jstree-InputField-Tree > .jstree-container-ul > .jstree-node,
.RTL .jstree-InputField-Tree > .jstree-container-ul > .jstree-node {
    margin-left: 0;
    margin-right: 0;
}

.jstree-InputField-Tree .jstree-anchor {
    height: 18px;
    line-height: 18px;
}

.jstree-InputField-Tree .jstree-icon {
    width: 18px;
    height: 18px;
    line-height: 18px;
}

.jstree-InputField-Tree .jstree-icon:empty {
    width: 18px;
    height: 18px;
    line-height: 18px;
}

.jstree-InputField-Tree.jstree-rtl .jstree-node {
    margin-right: 18px;
}

.jstree-InputField-Tree .jstree-wholerow {
    height: 18px;
}

.jstree-InputField-Tree .jstree-node,
.jstree-InputField-Tree .jstree-icon {
    background-image: url('../img/inputfield_tree.png');
}

.jstree-InputField-Tree .jstree-node {
    background-position: -295px -7px;
    background-repeat: repeat-y;
}

.jstree-InputField-Tree .jstree-last {
    background: transparent;
}

.jstree-InputField-Tree .jstree-open > .jstree-ocl {
    background-position: -135px -7px;
}

.RTL .jstree-InputField-Tree .jstree-open > .jstree-ocl {
    background-position: -135px -39px;
}

.jstree-InputField-Tree .jstree-closed > .jstree-ocl {
    background-position: -103px -7px;
}

.RTL .jstree-InputField-Tree .jstree-closed > .jstree-ocl {
    background-position: -103px -39px;
}

.jstree-InputField-Tree .jstree-leaf > .jstree-ocl {
    background-position: -71px -7px;
}

.RTL .jstree-InputField-Tree .jstree-leaf > .jstree-ocl {
    background-position: -71px -39px;
}

.jstree-InputField-Tree .jstree-themeicon {
    background-position: -263px -7px;
}

.RTL .jstree-InputField-Tree .jstree-themeicon {
    background-position: -263px -39px;
}

.jstree-InputField-Tree > .jstree-no-dots .jstree-node,
.jstree-InputField-Tree > .jstree-no-dots .jstree-leaf > .jstree-ocl {
    background: transparent;
}

.jstree-InputField-Tree > .jstree-no-dots .jstree-open > .jstree-ocl {
    background-position: -39px -7px;
}

.RTL .jstree-InputField-Tree > .jstree-no-dots .jstree-open > .jstree-ocl {
    background-position: -39px -39px;
}

.jstree-InputField-Tree > .jstree-no-dots .jstree-closed > .jstree-ocl {
    background-position: -7px -7px;
}

.RTL .jstree-InputField-Tree > .jstree-no-dots .jstree-closed > .jstree-ocl {
    background-position: -7px -39px;
}

/**
 * @subsection  jsTree theme - No Tree variant
 */
.jstree-InputField-NoTree .jstree-node {
    min-height: 18px;
    line-height: 18px;
    margin-left: 2px;
    min-width: 18px;
}

.jstree-InputField-NoTree .jstree-anchor {
    height: 18px;
    line-height: 18px;
}

.jstree-InputField-NoTree .jstree-icon {
    display: none;
}

.jstree-InputField-NoTree.jstree-rtl .jstree-node {
    margin-right: 2px;
}

.jstree-InputField-NoTree .jstree-wholerow {
    height: 18px;
}

} /* end @media */
 // --
// 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 - e44c18aea9abc125fddf9ceeed204db4fab290e0 - var/httpd/htdocs/js/Core.UI.Dialog.js
// --
// 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/>.
// --

"use strict";

var Core = Core || {};
Core.UI = Core.UI || {};

/**
 * @namespace Core.UI.Dialog
 * @memberof Core.UI
 * @author
 * @description
 *      Contains the code for the different dialogs.
 */
Core.UI.Dialog = (function (TargetNS) {
    /**
     * @private
     * @name DialogCounter
     * @memberof Core.UI.Dialog
     * @member {Number}
     * @description
     *      Number of used/opened dialogs on a page. Used to restore the correct HTML backup after dialog is closed.
     */
    var DialogCounter = 1;

    /*
     * check dependencies first
     */
    if (!Core.Debug.CheckDependency('Core.UI.Dialog', '$([]).draggable', 'jQuery UI draggable')) {
        return false;
    }
    if (!Core.Debug.CheckDependency('Core.UI.Dialog', 'Core.Config', 'Core.Config')) {
        return false;
    }
    if (!Core.Debug.CheckDependency('Core.UI.Dialog', 'Core.UI.InputFields', 'Core.UI.InputFields')) {
        return false;
    }

    /**
     * @private
     * @name AdjustScrollableHeight
     * @memberof Core.UI.Dialog
     * @function
     * @param {Boolean} AllowAutoGrow - If AllowAutoGrow is set, auto-resizing should be possible.
     * @description
     *      Adjusts the scrollable inner container of the dialog after every resizing.
     */
    function AdjustScrollableHeight(AllowAutoGrow) {
        // Check window height and adjust the scrollable height of InnerContent
        // Calculation:
        // Window height
        // - top margin of dialog twice (for top and bottom) - only use this for big dialog windows
        // - some static pixels for Header and Footer of dialog
        var ContentScrollHeight = 0,
            WindowHeight = $(window).height(),
            WindowScrollTop = $(window).scrollTop(),
            DialogTopMargin = $('.Dialog:visible').offset().top,
            DialogHeight = $('.Dialog:visible').height();

        // if dialog height is more than 300px recalculate width of InnerContent to make it scrollable
        // if dialog is smaller than 300px this is not necessary
        // if AllowAutoGrow is set, auto-resizing should be possible
        // if in a mobile environment and a small screen, use as much window height as possible
        if ($('.Dialog:visible').hasClass('Fullsize')) {
            ContentScrollHeight = WindowHeight - 80;
        }
        else if (AllowAutoGrow || DialogHeight > 300) {
            ContentScrollHeight = WindowHeight - ((DialogTopMargin - WindowScrollTop) * 2) - 100;
        }
        else {
            ContentScrollHeight = 200;
        }
        $('.Dialog:visible .Content .InnerContent').css('max-height', ContentScrollHeight);
    }

    /**
     * @private
     * @name FocusFirstElement
     * @memberof Core.UI.Dialog
     * @function
     * @description
     *      Focuses the first element within the dialog.
     */
    function FocusFirstElement() {
        var $FirstElement = $('div.Dialog:visible .Content')
                .find('a:visible, input:visible, textarea:visible, select:visible, button:visible')
                .filter(':first'),
            $FocusField;

        if (!$FirstElement || !$FirstElement.length) {
            return;
        }

        // If first element is modernized input field, prepend a semi-hidden text field and set focus on it instead.
        //   This will prevent automatic expansion of the input field, but still move tab index to the dialog and allow
        //   for keyboard navigation in it. See bug#12681 for more information.
        if ($FirstElement.hasClass('InputField_Search')) {
            $FocusField = $('<input/>')
                .addClass('FocusField')
                .insertBefore($FirstElement);
            $FocusField.focus();
        }
        else {
            $FirstElement.focus();
        }
    }

    /**
     * @private
     * @name InitKeyEvent
     * @memberof Core.UI.Dialog
     * @function
     * @param {Boolean} CloseOnEscape - If set to true, the escape key is checked for closing the dialog.
     * @description
     *      Initializes the key event logger for the dialog.
     *      Must be unbinded when closing the dialog.
     */
    function InitKeyEvent(CloseOnEscape) {
// Rother OSS / ServiceCatalog
        // var $Dialog = $('div.Dialog:visible');
        var $Dialog = function() {
            return $('div.Dialog:visible');
        };
// EO ServiceCatalog
        /*
         * Opera can't prevent the default action of special keys on keydown. That's why we need a special keypress event here,
         * to prevent the default action for the special keys.
         * See http://www.quirksmode.org/dom/events/keys.html for details
         */
        $(document).off('keypress.Dialog').on('keypress.Dialog', function (Event) {
            if ($.browser.opera && (Event.keyCode === 9 || (Event.keyCode === 27 && CloseOnEscape))) {
                Event.preventDefault();
                Event.stopPropagation();
                return false;
            }
        }).off('keydown.Dialog').on('keydown.Dialog', function (Event) {
            var $Tabbables, $First, $Last;

            // Tab pressed
            if (Event.keyCode === 9) {
                // :tabbable probably comes from jquery UI
// Rother OSS / ServiceCatalog
                // $Tabbables = $('a:visible, input:visible, textarea:visible, select:visible, button:visible', $Dialog);
                $Tabbables = $('a:visible, input:visible, textarea:visible, select:visible, button:visible', $Dialog());
// EO ServiceCatalog
                $First = $Tabbables.filter(':first');
                $Last = $Tabbables.filter(':last');

                if (Event.target === $Last[0] && !Event.shiftKey) {
                    $First.focus(1);
                    Event.preventDefault();
                    Event.stopPropagation();
                    return false;
                }
                else if (Event.target === $First[0] && Event.shiftKey) {
                    $Last.focus(1);
                    Event.preventDefault();
                    Event.stopPropagation();
                    return false;
                }
            }
            // Escape pressed and CloseOnEscape is true
            else if (Event.keyCode === 27 && CloseOnEscape) {
// Rother OSS / ServiceCatalog
                TargetNS.CloseDialog($Dialog());
// EO ServiceCatalog
                Event.preventDefault();
                Event.stopPropagation();
                return false;
            }
        });
    }

    /**
     * @private
     * @name DefaultSubmitFunction
     * @memberof Core.UI.Dialog
     * @function
     * @description
     *      The default submit function in the dialog.
     */
    function DefaultSubmitFunction() {
        $('.Dialog:visible form').submit();
    }

    /**
     * @private
     * @name DefaultCloseFunction
     * @memberof Core.UI.Dialog
     * @function
     * @description
     *      The default function to close the dialog.
     */
    function DefaultCloseFunction() {
        TargetNS.CloseDialog($('.Dialog:visible'));
    }

    /**
     * @name ShowDialog
     * @memberof Core.UI.Dialog
     * @function
     * @param {Object} Params - The different config options.
     * @param {Boolean} Params.Modal - Shows a dark background overlay behind the dialog (default: false)
     * @param {String} Params.Type - Alert|Search (default: undefined) Defines a special type of dialog.
     * @param {String} Params.Title - Defines the title of the dialog window (default: undefined).
     * @param {String} Params.Headline - Defines a special headline within the dialog window (default: undefined). Only used for Type Alert.
     * @param {String} Params.Text - The text which is outputtet in the dialog window (default: undefined). Only used for Type Alert.
     * @param {String} Params.HTML - Used for content dialog windows. Contains a complete HTML snippet or an jQuery object with containing HTML (default: undefined).
     * @param {Number} Params.PositionTop - Defines the top position of the dialog window (default: undefined).
     * @param {Number} Params.PositionBottom - Defines the bottom position of the dialog window (default: undefined).
     * @param {Number|String} Params.PositionLeft - Defines the left position of the dialog window. 'Center' centers the window (default: undefined).
     * @param {Number} Params.PositionRight - Defines the right position of the dialog window (default: undefined).
     * @param {Boolean} Params.CloseOnClickOutside - If true, clicking outside the dialog closes the dialog (default: false).
     * @param {Boolean} Params.CloseOnEscape - If true, pressing escape key closes the dialog (default: false).
     * @param {Boolean} Params.AllowAutoGrow - If true, the InnerContent of the dialog can resize until the max window height is reached, if false (default), InnerContent of small dialogs does not resize over 200px.
     * @param {Boolean} Params.HideHeader - Hide the header by setting this to true
     * @param {Boolean} Params.HideFooter - Hide the footer by setting this to true
     * @param {Object} Params.Buttons - Array of Hashes with the following properties (buttons are placed in a div "footer" of the dialog):
     * @param {String} Params.Buttons.Label - Text of the button.
     * @param {String} Params.Buttons.Type - 'Submit'|'Close' (default: none) Special type of the button - invokes a standard function.
     * @param {String} Params.Buttons.Class - Optional class parameters for the button element.
     * @param {Function} Params.Buttons.Function - The function which is executed on click (optional).
// Rother OSS / ServiceCatalog
     * @param {Boolean} Params.Stacked - If true, then a new dialog appears on top of existing ones (default: false).
// EO ServiceCatalog
     * @description
     *      The main dialog function used for all different types of dialogs.
     */
    TargetNS.ShowDialog = function(Params) {

        var $Dialog, $Content, $ButtonFooter, HTMLBackup, DialogCopy, DialogCopySelector,
            DialogHTML,
            FullsizeMode = false,
            CustomerInterface = Core.Config.Get('SessionName') === Core.Config.Get('CustomerPanelSessionName');

// Rother OSS / ServiceCatalog
//         DialogHTML = '<div class="Dialog">';
        DialogHTML = '<div class="Dialog"' + (Params.Stacked ? ' data-stacked="stacked"' : '') + '>';
// EO ServiceCatalog

        if (!Params.HideHeader) {
            var CloseIcon = CustomerInterface ? 'ooofo ooofo-close' : 'fa fa-times';
            DialogHTML += '<div class="Header"><a class="Close" title="' + Core.Language.Translate('Close this dialog') + '" href="#"><i class="' + CloseIcon + '"></i></a></div>';
        }
        DialogHTML += '<div class="Content"></div>';
        if (!Params.HideFooter) {
            DialogHTML += '<div class="Footer"></div>';
        }
        DialogHTML += '</div>';

        /**
         * @private
         * @name HandleClosingAction
         * @memberof Core.UI.Dialog.ShowDialog
         * @function
         * @description
         *      If no callback function for the close is given (via the Button definition),
         *      the dialog is just closed. Otherwise the defined Close button is triggered,
         *      which invokes the callback and the closing of the dialog.
         */
        function HandleClosingAction() {
            var $CloseButton = $('.Dialog:visible button.Close');

            // publish close event
            Core.App.Publish('Event.UI.Dialog.CloseDialog.Close', [$Dialog]);

            // Hide any possibly existing tooltips.
            if (Core.Form && Core.Form.ErrorTooltips) {
                Core.Form.ErrorTooltips.HideTooltip();
            }

            if ($CloseButton.length) {
                $CloseButton.trigger('click');
            }
            else {
                DefaultCloseFunction();
            }
        }

        /**
         * @private
         * @name CalculateDialogPosition
         * @memberof Core.UI.Dialog.ShowDialog
         * @function
         * @returns {String} The position of the dialog.
         * @param {String|Number} Position - The position of the dialog.
         * @param {String} Type - Can be 'top' or 'bottom'.
         * @description
         *      Calculates the correct position of the dialog, given by the Position.
         */
        function CalculateDialogPosition(Position, Type) {
            var ScrollTop = $(window).scrollTop(),
                WindowHeight = $(window).height();

            if ( CustomerInterface ) {
                // element is positioned "fixed"
                ScrollTop = 0;
            }

            Type = Type || 'top';
            // convert Position to a string so that numbers can be passed too
            //  (later string operations are executed on that object)
            Position = Position.toString();

            // position is in percent
            if (Position.match(/%/)) {
                Position = parseInt(Position.replace(/%/, ''), 10);
                if (Type === 'top') {
                    Position = parseInt(WindowHeight * (Position / 100), 10) + ScrollTop;
                }
                else if (Type === 'bottom') {
                    Position = WindowHeight + ScrollTop - parseInt(WindowHeight * (Position / 100), 10);
                }
            }
            // handle as px
            else {
                Position = parseInt(Position.replace(/px/, ''), 10);
                if (Type === 'top') {
                    Position = Position + ScrollTop;
                }
                else if (Type === 'bottom') {
                    Position = WindowHeight + ScrollTop - Position;
                }
            }

            return (Position + 'px');
        }

        Core.App.Publish('Event.UI.Dialog.ShowDialog.BeforeOpen');

        // Close all opened dialogs
// Rother OSS / ServiceCatalog
//         if ($('.Dialog:visible').length) {
        if ($('.Dialog:visible').length && !Params.Stacked) {
// EO ServiceCatalog
            TargetNS.CloseDialog($('.Dialog:visible'));
        }

        // If Dialog is a modal dialog, initialize overlay
        if (Params.Modal) {
            $('<div id="Overlay" tabindex="-1">').appendTo('body');
            $('body').css({
                'overflow': 'hidden'
            });
            //$('#Overlay').height($(document).height()).css('top', 0);

            // If the underlying page is perhaps to small, wie extend the page to window height for the dialog
            $('body').css('min-height', $(window).height());
        }

        // Build Dialog HTML
        $Dialog = $(DialogHTML);

        // Add responsive functionality
        if (Core.App.Responsive.IsSmallerOrEqual(Core.App.Responsive.GetScreenSize(), 'ScreenL')) {
            FullsizeMode = true;
            $Dialog.addClass('Fullsize');
        }

        if (Params.Modal) {
            $Dialog.addClass('Modal');
        }

        // If Param HTML is provided, get the HTML data
        // Data can be a HTML string or an jQuery object with containing HTML data
        if (Params.HTML) {
            // If the data is a string, this is created dynamically or was delivered via AJAX.
            // But if the data is a jQueryObject, that means, that the prepared HTML code for the dialog
            // was originally put as part of the tt into the HTML page
            // For compatibility reasons (no double IDs etc.) we have to cut out the dialog HTML and
            // only use it for the dialog itself.
            // After the dialog is closed again we have to revert this cut-out, because otherwise we
            // could not open the dialog again (because the HTML would be missing).
            // But we cannot use the Dialog HTML to put it back in the page, because this HTML could be changed
            // in the dialog. So we have to save the data somewhere which was cut out and write it back later.
            // Be careful: There can be more than one dialog, we have to save the data dependent on the dialog

            // Get HTML with JS function innerHTML, because jQuery html() strips out the script blocks
            if (typeof Params.HTML !== 'string' && isJQueryObject(Params.HTML)) {
                // First get the data structure, which is (perhaps) already saved
                // If the data does not exists Core.Data.Get returns an empty hash
                DialogCopy = Core.Data.Get($('body'), 'DialogCopy');
                DialogCopySelector = Core.Data.Get($('body'), 'DialogCopySelector');
                HTMLBackup = (Params.HTML)[0].innerHTML;
                // Add the new HTML data to the data structure and save it to the document
                DialogCopy[DialogCounter] = HTMLBackup;
                DialogCopySelector[DialogCounter] = Params.HTML;
                Core.Data.Set($('body'), 'DialogCopy', DialogCopy);
                Core.Data.Set($('body'), 'DialogSelector', DialogCopySelector);
                // Additionally, we save the selector as data on the dialog itself for later restoring
                // Remove the original dialog template content from the page
                Params.HTML.empty();
                // and use the variable as string (!!) with the content which was cut out
                Params.HTML = HTMLBackup;
            }
        }

        // Type 'Alert'
        if (Params.Type === 'Alert') {
            $Dialog.addClass('Alert');
            $Dialog.attr("role", "alertdialog");
            $Content = $Dialog.find('.Content').append('<div class="InnerContent"></div>').find('.InnerContent');
            $Content.append('<i class="fa fa-warning"></i>');
            if (Params.Headline) {
                $Content.append('<h2>' + Params.Headline + '</h2>');
            }
            if (Params.Text) {
                $Content.append('<p>' + Params.Text + '</p>');
            }
            Params.Buttons = [{
                Label: 'OK',
                Type: 'Close',
                Function: Params.OnClose
            }];
            $Content.append('<div class="Center Spacing"><button type="button" id="DialogButton1" class="CallForAction Close oooS"><span>' + Core.Language.Translate('OK') + '</span></button></div>');
        }
        // Define different other types here...
        else if (Params.Type === 'Search') {
            $Dialog.addClass('Search');
            $Dialog.attr("role", "dialog");
            $Content = $Dialog.find('.Content');
            if (Params.HTML) {
                $Content.append(Params.HTML);
            }
        }
        // If no type is defined, default type is used
        else {
            $Dialog.attr("role", "dialog");
            $Content = $Dialog.find('.Content');
            // buttons are defined only in default type
            if (Params.Buttons) {
                $Content.append('<div class="InnerContent"></div>').find('.InnerContent').append(Params.HTML);
                $ButtonFooter = $('<div class="ContentFooter Center"></div>');
                $.each(Params.Buttons, function (Index, Value) {
                    var Classes = 'CallForAction';
                    if (Value.Type === 'Close') {
                        Classes += ' Close';
                    }
                    if (Value.Class) {
                        Classes += ' ' + Value.Class;
                    }
                    $ButtonFooter.append('<button id="DialogButton' + (Index - 0 + 1) + '" class="' + Classes + '" type="button"><span>' + Value.Label + '</span></button> ');
                });
                $ButtonFooter.appendTo($Content);
            }
            else {
                if (Params.HTML) {
                    $Content.append(Params.HTML);
                }
            }
        }

        // If Title is defined, add dialog title
        if (Params.Title) {
            if ( CustomerInterface ) {
                $Dialog.children('div.Header').append('<h2>' + Params.Title + '</h2>');
            } else {
                $Dialog.children('div.Header').append('<h1>' + Params.Title + '</h1>');
            }
        }

        // Add Dialog to page
        $Dialog.appendTo('body');

        // Check if "ContentFooter" is used in Content
        if ($Dialog.find('.Content .ContentFooter').length) {
            // change default Footer
            $Dialog.find('.Footer').addClass('ContentFooter');
        }

        // Now add the dialog number to the dialog data to restore the HTML later
        Core.Data.Set($Dialog, 'DialogCounter', DialogCounter);
        // Increase the dialog number for the next possible dialog
        DialogCounter++;

        // Set position for Dialog
        if (Params.Type === 'Alert') {
            if ( CustomerInterface ) {
                $Dialog.css({
                    top: $(window).height() * 0.2,
                    left: Math.round(($(window).width() - $Dialog.width()) / 2)
                });
            }
            else {
                $Dialog.css({
                    top: $(window).scrollTop() + ($(window).height() * 0.3),
                    left: Math.round(($(window).width() - $Dialog.width()) / 2)
                });
            }
        }

        if (typeof Params.PositionTop !== 'undefined') {
            $Dialog.css('top', CalculateDialogPosition(Params.PositionTop, 'top'));
        }
        if (typeof Params.PositionLeft !== 'undefined') {
            if (Params.PositionLeft === 'Center') {
                $Dialog.css('left', Math.round(($(window).width() - $Dialog.width()) / 2));
            }
            else {
                $Dialog.css('left', Params.PositionLeft);
            }
        }
        if (typeof Params.PositionBottom !== 'undefined') {
            $Dialog.css('bottom', CalculateDialogPosition(Params.PositionBottom, 'bottom'));
        }
        if (typeof Params.PositionRight !== 'undefined') {
            $Dialog.css('right', Params.PositionRight);
        }

        // Check window height and adjust the scrollable height of InnerContent
        AdjustScrollableHeight(Params.AllowAutoGrow);

        // Adjust dialog position on mobile devices
        if ( FullsizeMode && !CustomerInterface ) {
            $Dialog.css('top', $(window).scrollTop());
        }

        // Add event-handling, not allowed on mobile devices
        if ( !FullsizeMode && !CustomerInterface ) {
            $Dialog.draggable({
                containment: 'body',
                handle: '.Header',
                start: function() {
                    // Fire PubSub event for dragstart
                    // (to handle more dependencies in their own namespaces)
                    Core.App.Publish('Event.UI.Dialog.ShowDialog.DragStart', $Dialog);

                    // Hide any possibly existing tooltips as they will not be moved
                    //  with this dialog.
                    if (Core.Form && Core.Form.ErrorTooltips) {
                        Core.Form.ErrorTooltips.HideTooltip();
                    }
                },
                stop: function() {
                    Core.App.Publish('Event.UI.Dialog.ShowDialog.DragStop', $Dialog);
                }
            });
        }

        // Add button events
        if (Params.Buttons) {
            $.each(Params.Buttons, function (Index, Value) {
                $('#DialogButton' + (Index - 0 + 1)).click(function () {
                    if (Value.Type === 'Submit') {
                        if ($.isFunction(Value.Function)) {
                            if (Value.Function()) {
                                DefaultSubmitFunction();
                            }
                        }
                        else {
                            DefaultSubmitFunction();
                        }
                    }
                    else if (Value.Type === 'Close') {
                        if ($.isFunction(Value.Function)) {
                            if (Value.Function()) {
                                DefaultCloseFunction();
                            }
                        }
                        else {
                            DefaultCloseFunction();
                        }
                    }
                    else {
                        if ($.isFunction(Value.Function)) {
                            Value.Function();
                        }
                    }
                });
            });
        }

        // Add event-handling for Close-Buttons and -Links
        $Dialog.find('.Header a.Close').click(function () {
            HandleClosingAction();
            return false;
        });

        // Add CloseOnClickOutside functionality
        if (Params.CloseOnClickOutside) {
            $(document).off('click.Dialog').on('click.Dialog', function (event) {
                // If target element is removed before this event triggers, the enclosing div.Dialog can't be found anymore
                // We check, if we can find a parent HTML element to be sure, that the element is not removed
                if (
                    $(event.target).parents('html').length
                    && $(event.target).closest('div.Dialog').length === 0

                    // Case autocomplete dropdown in modal dialogs
                    // NOTE: currently only occurs when using dynamic field reference search fields in ticket search or config item search
                    && !$(event.target).hasClass('ui-menu-item-wrapper')
                ) {
                    HandleClosingAction();
                }
            });
        }

        // Add resize event handler for calculating the scroll height
        $(window).off('resize.Dialog').on('resize.Dialog', function () {
            AdjustScrollableHeight(Params.AllowAutoGrow);
        });

        Core.App.Subscribe('Event.App.Responsive.SmallerOrEqualScreenL', function () {
            // Dialog should be fullsize, if on smaller screens
            $Dialog.addClass('Fullsize');
        });

        Core.App.Subscribe('Event.App.Responsive.ScreenXL', function () {
            $Dialog.removeClass('Fullsize');
        });

        // Init KeyEvent-Logger
        InitKeyEvent(Params.CloseOnEscape);

        Core.UI.InputFields.Activate($Dialog);

        // Focus first focusable element
        FocusFirstElement();
    };

    /**
     * @name ShowContentDialog
     * @memberof Core.UI.Dialog
     * @function
     * @param {String} HTML - The content HTML which should be shown.
     * @param {String} Title - The title of the dialog.
     * @param {Number|String} PositionTop - The top position the dialog is positioned initially.
     * @param {Numer|String} PositionLeft - The left position the dialog is positioned initially.
     * @param {Boolean} Modal - If defined and set to true, an overlay is shown for a modal dialog.
     * @param {Array} Buttons - The button array.
     * @param {Boolean} AllowAutoGrow - If true, the InnerContent of the dialog can resize until the max window height is reached, if false (default), InnerContent of small dialogs does not resize over 200px.
     * @description
     *      Shows a default dialog.
     */
    TargetNS.ShowContentDialog = function (HTML, Title, PositionTop, PositionLeft, Modal, Buttons, AllowAutoGrow) {
        TargetNS.ShowDialog({
            HTML: HTML,
            Title: Title,
            Modal: Modal,
            CloseOnClickOutside: true,
            CloseOnEscape: true,
            PositionTop: PositionTop,
            PositionLeft: PositionLeft,
            Buttons: Buttons,
            AllowAutoGrow: AllowAutoGrow
        });
    };

    /**
     * @name ShowWaitingDialog
     * @memberof Core.UI.Dialog
     * @function
     * @param {String} Title - The title of the dialog.
     * @param {String} Text - The text of the dialog.
     * @description
     *      Shows a waiting dialog (with spinner icon) and customizable title and text
     */
    TargetNS.ShowWaitingDialog = function (Title, Text) {

        var DialogTemplate = Core.Template.Render('Dialog/Waiting', {
            Text: Text
        });

        TargetNS.ShowDialog({
            HTML: DialogTemplate,
            Title: Title,
            Modal: true,
            CloseOnClickOutside: false,
            CloseOnEscape: false,
            PositionTop: '20%',
            PositionLeft: 'Center',
            AllowAutoGrow: true,
            HideHeader: true,
            HideFooter: true
        });
    };

    /**
     * @name MakeDialogWait
     * @memberof Core.UI.Dialog
     * @function
     * @description
     *      Shows a spinner overlay on the currently visible modal dialog. Is meant for showing the user that something is about
     *      to happen, e.g. if changing a field within a dialog causes a page reload.
     */
    TargetNS.MakeDialogWait = function () {
        $('.Dialog:visible .InnerContent').prepend('<div class="Waiting"><i class="fa fa-spinner fa-spin"></i></div>').find('.Waiting').fadeIn();
    };

    /**
     * @name ShowAlert
     * @memberof Core.UI.Dialog
     * @function
     * @param {String} Headline - The bold headline text.
     * @param {String} Text - The description.
     * @param {Function} CloseFunction - The special function which is started on closing the dialog
     *                                   (optional, if used also the removing of the dialog itself must be handled).
     * @description
     *      Shows an alert dialog.
     */
    TargetNS.ShowAlert = function (Headline, Text, CloseFunction) {
        TargetNS.ShowDialog({
            Type: 'Alert',
            Modal: true,
            Title: Headline,
            Text: Text,
            OnClose: CloseFunction
        });
    };

    /**
     * @name CloseDialog
     * @memberof Core.UI.Dialog
     * @function
     * @param {jQueryObject} Object - The jQuery object that defines the dialog or any child element of it, which should be closed.
     * @description
     *      Closes all dialogs specified.
     */
    TargetNS.CloseDialog = function (Object) {
        var $Dialog, $DialogSelector, DialogCopy, DialogSelectorData, InternalDialogCounter, BackupHTML;
        $Dialog = $(Object).closest('.Dialog:visible');

        // Get the original dialog number for the content template
        InternalDialogCounter = Core.Data.Get($Dialog, 'DialogCounter');

        // publish close event
        Core.App.Publish('Event.UI.Dialog.CloseDialog.Close', [$Dialog]);

// Rother OSS / ServiceCatalog
//         $Dialog.remove();
//         $('#Overlay').remove();
//         $('body').css({
//             'overflow': 'auto'
//         });
//         $(document).unbind('keydown.Dialog').unbind('keypress.Dialog').unbind('click.Dialog');
//         $(window).unbind('resize.Dialog');
//         $('body').css('min-height', 'auto');
//
//         // Revert orignal html
//         if (InternalDialogCounter) {
//             DialogCopy = Core.Data.Get($('body'), 'DialogCopy');
//             DialogSelectorData = Core.Data.Get($('body'), 'DialogSelector');
//             // Get saved HTML
//             if (typeof DialogCopy !== 'undefined') {
//                 BackupHTML = DialogCopy[InternalDialogCounter];
//                 $DialogSelector = DialogSelectorData[InternalDialogCounter];
//
//                 // If HTML could be restored, write it back into the page
//                 if (BackupHTML && BackupHTML.length) {
//                     $DialogSelector.append(BackupHTML);
//                 }
//
//                 // delete this variable from the object
//                 delete DialogCopy[InternalDialogCounter];
//                 delete DialogSelectorData[InternalDialogCounter];
//             }
//
//             // write the new DialogCopy back
//             Core.Data.Set($('body'), 'DialogCopy', DialogCopy);
//         }
        if ($Dialog.length > 1 && $Dialog[$Dialog.length - 1].dataset.stacked) {
            $($Dialog[$Dialog.length - 1]).remove();
        } else {
            $Dialog.remove();
            $('#Overlay').remove();
            $('body').css({
                'overflow': 'auto'
            });
            $(document).unbind('keydown.Dialog').unbind('keypress.Dialog').unbind('click.Dialog');
            $(window).unbind('resize.Dialog');
            $('body').css('min-height', 'auto');

            // Revert orignal html
            if (InternalDialogCounter) {
                DialogCopy = Core.Data.Get($('body'), 'DialogCopy');
                DialogSelectorData = Core.Data.Get($('body'), 'DialogSelector');
                // Get saved HTML
                if (typeof DialogCopy !== 'undefined') {
                    BackupHTML = DialogCopy[InternalDialogCounter];
                    $DialogSelector = DialogSelectorData[InternalDialogCounter];

                    // If HTML could be restored, write it back into the page
                    if (BackupHTML && BackupHTML.length) {
                        $DialogSelector.append(BackupHTML);
                    }

                    // delete this variable from the object
                    delete DialogCopy[InternalDialogCounter];
                    delete DialogSelectorData[InternalDialogCounter];
                }

                // write the new DialogCopy back
                Core.Data.Set($('body'), 'DialogCopy', DialogCopy);
            }
        }
// EO ServiceCatalog
    };

    return TargetNS;
}(Core.UI.Dialog || {}));
 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 // --
// OTOBO is a web-based ticketing system for service organisations.
// --
// Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
// Copyright (C) 2019-2025 Rother OSS GmbH, https://otobo.io/
// --
// $origin: otobo - e44c18aea9abc125fddf9ceeed204db4fab290e0 - var/httpd/htdocs/js/Core.Agent.Admin.Service.js
// --
// 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/>.
// --

"use strict";

var Core = Core || {};
Core.Agent = Core.Agent || {};
Core.Agent.Admin = Core.Agent.Admin || {};

/**
 * @namespace Core.Agent.Admin.Service
 * @memberof Core.Agent.Admin
 * @author
 * @description
 *      This namespace contains the special function for AdminService module.
 */
 Core.Agent.Admin.Service = (function (TargetNS) {

    /*
    * @name Init
    * @memberof Core.Agent.Admin.Service
    * @function
    * @description
    *      This function initializes table filter.
    */
    TargetNS.Init = function () {
        Core.UI.Table.InitTableFilter($('#FilterServices'), $('#Services'));

        // init checkbox to include invalid elements
        $('input#IncludeInvalid').off('change').on('change', function () {
            var URL = Core.Config.Get("Baselink") + 'Action=' + Core.Config.Get("Action") + ';IncludeInvalid=' + ( $(this).is(':checked') ? 1 : 0 );
            window.location.href = URL;
        });

// Service Catalog
        // bind click function to add button
        $('.LanguageAdd').off('change.Service').on('change.Service', function () {
            TargetNS.AddLanguage($(this).val(), $('.LanguageAdd option:selected').text());
            return false;
        });

        // bind click function to remove button
        $('.LanguageRemove').off('click.Service').on('click.Service', function () {

            if (window.confirm(Core.Language.Translate('Do you really want to delete this service description language?'))) {
                TargetNS.RemoveLanguage($(this));
            }
            return false;
        });
// EO Service Catalog
    };

    
// Service Catalog
   /**
     * @name AddLanguage
     * @memberof Core.Agent.Admin.Service
     * @function
     * @param {string} LanguageID - short name of the language like es_MX.
     * @param {string} Language - full name of the language like Spanish (Mexico).
     * @returns {Bool} Returns false to prevent event bubbling.
     * @description
     *      This function add a new service description language.
     */
   TargetNS.AddLanguage = function(LanguageID, Language){

        var $Clone = $('.Template').clone();

        if (Language === '-'){
            return false;
        }

        // remove unnecessary classes
        $Clone.removeClass('Hidden Template');

        // add title
        $Clone.find('.Title').html(Language);

        // update remove link
        $Clone.find('#Template_Language_Remove').attr('name', LanguageID + '_Language_Remove');
        $Clone.find('#Template_Language_Remove').attr('id', LanguageID + '_Language_Remove');

        // set hidden language field
        $Clone.find('.LanguageID').attr('name', 'LanguageID');
        $Clone.find('.LanguageID').val(LanguageID);

        // update subject label
        $Clone.find('#Template_Label_DescriptionShort').attr('for', LanguageID + '_DescriptionShort');
        $Clone.find('#Template_Label_DescriptionShort').attr('id', LanguageID + '_Label_DescriptionShort');

        // update subject field
        $Clone.find('#Template_DescriptionShort').attr('name', LanguageID + '_DescriptionShort');
        $Clone.find('#Template_DescriptionShort').addClass('Validate_Required');
        $Clone.find('#Template_DescriptionShort').attr('id', LanguageID + '_DescriptionShort');
        $Clone.find('#Template_DescriptionShortError').attr('id', LanguageID + '_DescriptionShortError');

        // update body label
        $Clone.find('#Template_Label_DescriptionLong').attr('for', LanguageID + '_DescriptionLong');
        $Clone.find('#Template_Label_DescriptionLong').attr('id', LanguageID + '_Label_DescriptionLong');

        // update body field
        $Clone.find('#Template_DescriptionLong').attr('name', LanguageID + '_DescriptionLong');
        $Clone.find('#Template_DescriptionLong').addClass('RichText');
        $Clone.find('#Template_DescriptionLong').attr('id', LanguageID + '_DescriptionLong');

        // append to container
        $('.ServiceLanguageContainer').append($Clone);

        // initialize the rich text editor if set
        if (parseInt(Core.Config.Get('RichTextSet'), 10) === 1) {
            Core.UI.RichTextEditor.InitAllEditors();
        }

        // bind click function to remove button
        $('.LanguageRemove').off('click.Service').on('click.Service', function () {

            if (window.confirm(Core.Language.Translate('Do you really want to delete this service description language?'))) {
                TargetNS.RemoveLanguage($(this));
            }
            return false;
        });

        TargetNS.LanguageSelectionRebuild();

        Core.UI.InitWidgetActionToggle();

        return false;
    };

    /**
     * @name RemoveLanguage
     * @memberof Core.Agent.Admin.Service
     * @function
     * @param {jQueryObject} Object - JQuery object used to remove the language block
     * @description
     *      This function removes a service description language.
     */
    TargetNS.RemoveLanguage = function (Object) {
        Object.closest('.ServiceLanguage').remove();
        TargetNS.LanguageSelectionRebuild();
    };

    /**
     * @name LanguageSelectionRebuild
     * @memberof Core.Agent.Admin.Service
     * @function
     * @returns {Boolean} Returns true.
     * @description
     *      This function rebuilds language selection, only show available languages.
     */
    TargetNS.LanguageSelectionRebuild = function () {

        // get original selection with all possible fields and clone it
        var $Languages = $('#LanguageOrig option').clone();

        $('#Language').empty();

        // strip all already used attributes
        $Languages.each(function () {
            if (!$('.ServiceLanguageContainer label#' + $(this).val() + '_Label_DescriptionShort').length) {
                $('#Language').append($(this));
            }
        });

        $('#Language').trigger('redraw.InputField');

        // bind click function to add button
        $('.LanguageAdd').off('change.Service').on('change.Service', function () {
            TargetNS.AddLanguage($(this).val(), $('.LanguageAdd option:selected').text());
            return false;
        });

        return true;
    };    
// EO Service Catalog

    Core.Init.RegisterNamespace(TargetNS, 'APP_MODULE');

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

package var::packagesetup::ServiceCatalog;

use strict;
use warnings;

use Kernel::Output::Template::Provider;

our @ObjectDependencies = (
    'Kernel::Config',
    'Kernel::System::DB',
    'Kernel::System::DynamicField',
    'Kernel::System::DynamicFieldValue',
    'Kernel::System::Log',
    'Kernel::System::SysConfig',
);

=head1 NAME

var::packagesetup::ServiceCatalog - code to execute during package installation

=head1 DESCRIPTION

All functions

=head1 PUBLIC INTERFACE

=head2 new()

create an object

    use Kernel::System::ObjectManager;
    local $Kernel::OM = Kernel::System::ObjectManager->new();
    my $CodeObject = $Kernel::OM->Get('var::packagesetup::Survey');

=cut

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

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

    # Force a reload of ZZZAuto.pm and ZZZAAuto.pm to get the fresh configuration values.
    for my $Module ( sort keys %INC ) {
        if ( $Module =~ m/ZZZAA?uto\.pm$/ ) {
            delete $INC{$Module};
        }
    }

    # always discard the config object before package code is executed,
    # to make sure that the config object will be created newly, so that it
    # will use the recently written new config from the package
    $Kernel::OM->ObjectsDiscard(
        Objects => ['Kernel::Config'],
    );

    return $Self;
}

=head2 CodeInstall()

run the code install part

    my $Result = $CodeObject->CodeInstall();

=cut

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

    return 1;
}

=head2 CodeReinstall()

run the code reinstall part

    my $Result = $CodeObject->CodeReinstall();

=cut

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

    return 1;
}

=head2 CodeUpgrade()

run the code upgrade part

    my $Result = $CodeObject->CodeUpgrade();

=cut

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

    return 1;
}

=head2 CodeUpgradeFromLowerThan_11_0_3()

This function is only executed if the installed module version is smaller than 11.0.3.

    my $Result = $CodeObject->CodeUpgradeFromLowerThan_11_0_3();

=cut

sub CodeUpgradeFromLowerThan_11_0_3 {    ## no critic qw(OTOBO::RequireCamelCase)
    my ( $Self, %Param ) = @_;

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

    my $Language    = $ConfigObject->Get('DefaultLanguage') || 'en';
    my $ContentType = $ConfigObject->Get('Frontend::RichText') ? 'text/html' : 'text/plain';

    # this should only be executed if we come from 11.0.1 or a 10.1 version below 10.1.15
    my ($PreviouslyMigrated) = $DBObject->SelectRowArray(
        SQL   => 'SELECT id FROM service_description',
        Limit => 1,
    );

    return 1 if $PreviouslyMigrated;

    my $Success = $DBObject->Do(
        SQL => "INSERT INTO service_description (service_id, description_short, description_long, content_type, language)
                SELECT id, description_short, description_long, '$ContentType', '$Language' FROM service WHERE description_short <> '' ORDER BY id ASC"
    );

    if ($Success) {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'notice',
            Message  => 'Service catalog descriptions migrated successfully to the Service description table!'
        );
    }
    else {
        $Kernel::OM->Get('Kernel::System::Log')->Log(
            Priority => 'error',
            Message  => 'There was a problem migrating service catalog descriptions from Service table. Please review error log.'
        );
        return;
    }

    return 1;
}

=head2 CodeUninstall()

run the code uninstall part

    my $Result = $CodeObject->CodeUninstall();

=cut

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

    # remove Dynamic Fields and its values
    $Self->_DynamicFieldsDelete();

    return 1;
}

=head2 _DynamicFieldsDelete()

delete all existing dynamic fields for ServiceCatalog

    my $Result = $CodeObject->_DynamicFieldsDelete();

=cut

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

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

    # get the list of all dynamic fields (valid and invalid ones)
    my $DynamicFieldList = $DynamicFieldObject->DynamicFieldListGet(
        Valid      => 0,
        ObjectType => ['Service'],
    );

    # delete the dynamic fields
    DYNAMICFIELD:
    for my $DynamicField ( @{$DynamicFieldList} ) {

        # delete all field values
        my $ValuesDeleteSuccess = $DynamicFieldValueObject->AllValuesDelete(
            FieldID => $DynamicField->{ID},
            UserID  => 1,
        );

        # values could be deleted
        if ($ValuesDeleteSuccess) {

            # delete field
            my $Success = $DynamicFieldObject->DynamicFieldDelete(
                ID     => $DynamicField->{ID},
                UserID => 1,
            );

            # check error
            if ( !$Success ) {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => "Could not delete dynamic field '$DynamicField->{Name}'!",
                );
            }
        }

        # values could not be deleted
        else {
            $Kernel::OM->Get('Kernel::System::Log')->Log(
                Priority => 'error',
                Message  => "Could not delete values for dynamic field '$DynamicField->{Name}'!",
            );
        }
    }

    return 1;
}

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