ServiceImportExport 1.0.3 c.a.p.e. IT GmbH http://www.cape-it.de/ GNU AFFERO GENERAL PUBLIC LICENSE Version 3, November 2007 CR: set required ImportExport to version 3.0.1, removed html-version of pod documentation, added custom SLAPreferences to SLA import export mappings, removed \"export with labels\" (now included in ImportExport-framework. Bugfix: removed uncommenntation of some code. CR: added custom ServicePreferences to service import export mappings, moved usage information to pod-file in <OTRS_HOME>/doc/en; Bugfix: fixed bug installation if GeneralCatalog is installed but not ITSMCore. CR: first official release for OTRS 3.0.x; added file USAGE_serviceimportexport for documentation purpose. CR: changes for use with OTRS 3.0.x, added some error handlings in package setup method. Provides ImportExportBackend for Service, SLA and Service2CustomerUsers. Stellt ImportExport-Backend fuer Service, SLA und Service2Kundennutzer-eintraege zur Verfuegung. 3.0.x Welcome: You are about to install the OTRS module ServiceImportExport. Required OTRS packages: <ul> <li>ImportExport 3.0.1 or higher</li> </ul> c.a.p.e. IT ...easy. The package has been installed. Your import-/export configuration has been changed. Please see file OTRS_HOME/USAGE_serviceimportexport for further documentation. ImportExport my $FunctionName = 'CodeInstall'; my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content}; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}) ) { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method $FunctionName() on $CodeModule.pm." ); } } else { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method new() on $CodeModule.pm." ); } } my $FunctionName = 'CodeUpgrade'; my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content}; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}) ) { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method $FunctionName() on $CodeModule.pm." ); } } else { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method new() on $CodeModule.pm." ); } } my $FunctionName = 'CodeUninstall'; my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content}; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}) ) { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method $FunctionName() on $CodeModule.pm." ); } } else { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method new() on $CodeModule.pm." ); } } my $FunctionName = 'CodeReinstall'; my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content}; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}) ) { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method $FunctionName() on $CodeModule.pm." ); } } else { $Self->{LogObject}->Log( Priority => 'error', Message => "Could not call method new() on $CodeModule.pm." ); } } 2011-11-29 11:47:35 cvs.intra.cape-it.de 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 # --
# Kernel/System/ImportExport/ObjectBackend/Service.pm
#
#- import/export backend for service definitions
#
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# --
# $Id: Service.pm,v 1.11 2011-11-29 10:28:57 tto Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --
package Kernel::System::ImportExport::ObjectBackend::Service;
use strict;
use warnings;

use Kernel::System::Queue;
use Kernel::System::Service;
use Kernel::System::Type;
use Kernel::System::Valid;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.11 $) [1];

=head1 NAME

Kernel::System::ImportExport::ObjectBackend::CustomerUser - import/export backend for CustomerUser

=head1 SYNOPSIS

All functions to import and export CustomerUser entries

=over 4

=cut

=item new()

create an object

    use Kernel::Config;
    use Kernel::System::DB;
    use Kernel::System::Log;
    use Kernel::System::Main;
    use Kernel::System::ImportExport::ObjectBackend::CustomerUser;

    my $ConfigObject = Kernel::Config->new();
    my $LogObject = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
    );
    my $MainObject = Kernel::System::Main->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
    );
    my $BackendObject = Kernel::System::ImportExport::ObjectBackend::CustomerUser->new(
        ConfigObject       => $ConfigObject,
        LogObject          => $LogObject,
        DBObject           => $DBObject,
        MainObject         => $MainObject,
        ImportExportObject => $ImportExportObject,
    );

=cut

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

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

    #check required objects...
    for my $Object (
        qw(ConfigObject LogObject DBObject MainObject ImportExportObject EncodeObject)
        )
    {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }
    if ( !$Self->{ServiceObject} ) {
        $Self->{ServiceObject} = Kernel::System::Service->new( %{$Self} );
    }
    if ( !$Self->{ValidObject} ) {
        $Self->{ValidObject} = Kernel::System::Valid->new( %{$Self} );
    }

    if ( !$Self->{QueueObject} ) {
        $Self->{QueueObject} = Kernel::System::Queue->new( %{$Self} );
    }

    if ( !$Self->{TypeObject} ) {
        $Self->{TypeObject} = Kernel::System::Type->new( %{$Self} );
    }

    if ( $Self->{MainObject}->Require('Kernel::System::GeneralCatalog') ) {
        $Self->{GeneralCatalogObject} = Kernel::System::GeneralCatalog->new( %{$Self} );
        if ( $Self->{GeneralCatalogObject} ) {

            # get service type list
            $Self->{ServiceTypeList} = $Self->{GeneralCatalogObject}->ItemList(
                Class => 'ITSM::Service::Type',
            );
            my %TmpHash = reverse( %{ $Self->{ServiceTypeList} } );
            $Self->{ReverseServiceTypeList} = \%TmpHash;

            # get criticality list
            $Self->{CriticalityList} = $Self->{GeneralCatalogObject}->ItemList(
                Class => 'ITSM::Core::Criticality',
            );
            my %TmpHash2 = reverse( %{ $Self->{CriticalityList} } );
            $Self->{ReverseCriticalityList} = \%TmpHash2;
        }
    }
    return $Self;
}

=item ObjectAttributesGet()

get the object attributes of an object as array/hash reference

    my $Attributes = $ObjectBackend->ObjectAttributesGet(
        UserID => 1,
    );

=cut

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

    # check needed object
    if ( !$Param{UserID} ) {
        $Self->{LogObject}
            ->Log( Priority => 'error', Message => 'Need UserID!' );
        return;
    }
    my %Validlist  = $Self->{ValidObject}->ValidList();
    my $Attributes = [
        {
            Key   => 'DefaultValid',
            Name  => 'Default Validity',
            Input => {
                Type         => 'Selection',
                Data         => \%Validlist,
                Required     => 1,
                Translation  => 1,
                PossibleNone => 0,
                ValueDefault => 1,
            },
        },
    ];
    if ( $Self->{ServiceTypeList} ) {
        my $ServiceTypeDefault = {
            Key   => 'DefaultServiceTypeID',
            Name  => 'Default Service Type',
            Input => {
                Type         => 'Selection',
                Data         => $Self->{ServiceTypeList},
                Required     => 1,
                Translation  => 0,
                PossibleNone => 0,
            },
        };
        push( @{$Attributes}, $ServiceTypeDefault );
    }
    if ( $Self->{CriticalityList} ) {
        my $CriticalityDefault = {
            Key   => 'DefaultCriticalityID',
            Name  => 'Default Criticality',
            Input => {
                Type         => 'Selection',
                Data         => $Self->{CriticalityList},
                Required     => 1,
                Translation  => 0,
                PossibleNone => 0,
            },
        };
        push( @{$Attributes}, $CriticalityDefault );
    }
    return $Attributes;
}

=item MappingObjectAttributesGet()

get the mapping attributes of an object as array/hash reference

    my $Attributes = $ObjectBackend->MappingObjectAttributesGet(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # get object data
    my $ObjectData = $Self->{ImportExportObject}->ObjectDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );
    my $ElementList = [
        {
            Key   => 'ServiceID',
            Value => 'Service ID',
        },
        {
            Key   => 'Name',
            Value => 'Full Service Name',
        },
        {
            Key   => 'NameShort',
            Value => 'Short Service Name',
        },
        {
            Key   => 'Valid',
            Value => 'Validity',
        },
        {
            Key   => 'Comment',
            Value => 'Comment',
        },
    ];

    #---------------------------------------------------------------------------
    # get preferences...
    my %Preferences = ();
    if ( $Self->{ConfigObject}->Get('ServicePreferences') ) {
        %Preferences = %{ $Self->{ConfigObject}->Get('ServicePreferences') };
    }
    for my $Item ( sort keys %Preferences ) {
        if (
            $Preferences{$Item}->{SelectionSource}
            && $Preferences{$Item}->{PrefKey} =~ /^(.+)ID$/
            )
        {
            my $NamePart = $1;
            push(
                @{$ElementList},
                { Key => $NamePart, Value => $Preferences{$Item}->{Label} }
            );
        }

        if ( $Preferences{$Item}->{PrefKey} =~ /^(.+)ID$/ ) {
            my $NamePart = $1;
            push(
                @{$ElementList},
                {
                    Key   => $Preferences{$Item}->{PrefKey},
                    Value => $Preferences{$Item}->{Label} . " (ID)"
                }
            );
        }
        else {
            push(
                @{$ElementList},
                { Key => $Preferences{$Item}->{PrefKey}, Value => $Preferences{$Item}->{Label} }
            );
        }

    }

    #---------------------------------------------------------------------------
    # using ciritcality/servicetype-list as indicator for ITSM-installation...
    if ( $Self->{CriticalityList} && $Self->{ServiceTypeList} ) {
        my $ElementListITSM = [
            {
                Key   => 'Type',
                Value => 'Service Type (ITSM only)',
            },
            {
                Key   => 'Criticality',
                Value => 'Criticality (ITSM only)',
            },
            {
                Key   => 'CurInciState',
                Value => 'Current Incident State (ITSM only)',
            },
            {
                Key   => 'CurInciStateType',
                Value => 'Current Incident State Type (ITSM only)',
            },
        ];
        my @TmpArray = ( @{$ElementList}, @{$ElementListITSM} );
        $ElementList = \@TmpArray;
    }
    my $Attributes = [
        {
            Key   => 'Key',
            Name  => 'Key',
            Input => {
                Type         => 'Selection',
                Data         => $ElementList,
                Required     => 1,
                Translation  => 1,
                PossibleNone => 1,
            },
        },
        {
            Key   => 'Identifier',
            Name  => 'Identifier',
            Input => { Type => 'Checkbox', },
        },
    ];
}

=item SearchAttributesGet()

get the search object attributes of an object as array/hash reference

    my $AttributeList = $ObjectBackend->SearchAttributesGet(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }
    my $AttributeList = [
        {
            Key   => 'ServiceName',
            Name  => 'Service Name',
            Input => {
                Type      => 'Text',
                Size      => 80,
                MaxLength => 255,
            },
        },
    ];
    return $AttributeList;
}

=item ExportDataGet()

get export data as 2D-array-hash reference

    my $ExportData = $ObjectBackend->ExportDataGet(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # get object data
    my $ObjectData = $Self->{ImportExportObject}->ObjectDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check object data
    if ( !$ObjectData || ref $ObjectData ne 'HASH' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No object data found for the template id $Param{TemplateID}",
        );
        return;
    }

    # get the mapping list
    my $MappingList = $Self->{ImportExportObject}->MappingList(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check the mapping list
    if ( !$MappingList || ref $MappingList ne 'ARRAY' || !@{$MappingList} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No valid mapping list found for the template id $Param{TemplateID}",
        );
        return;
    }

    # create the mapping object list
    my @MappingObjectList;
    for my $MappingID ( @{$MappingList} ) {

        # get mapping object data
        my $MappingObjectData =
            $Self->{ImportExportObject}->MappingObjectDataGet(
            MappingID => $MappingID,
            UserID    => $Param{UserID},
            );

        # check mapping object data
        if ( !$MappingObjectData || ref $MappingObjectData ne 'HASH' ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "No valid mapping list found for the template id $Param{TemplateID}",
            );
            return;
        }
        push( @MappingObjectList, $MappingObjectData );
    }

    # get search data
    my $SearchData = $Self->{ImportExportObject}->SearchDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );
    if ( $SearchData && ref($SearchData) ne 'HASH' ) {
        $SearchData = 0;
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message =>
                "Service2CustomerUser: search data is not a hash ref - ignoring search limitation.",
        );
    }
    my @ServiceList = $Self->{ServiceObject}->ServiceSearch(
        Name  => $SearchData->{ServiceName} || '',
        Limit => $SearchData->{Limit}       || '0',
        UserID => 1,

        # no further restriction yet...
        #TypeIDs        => 2,
        #CriticalityIDs => 1,
    );

    # export data...
    my @ExportData;

    # get preferences configuration...
    my %Preferences = ();
    if ( $Self->{ConfigObject}->Get('ServicePreferences') ) {
        my %PrefConfig = %{ $Self->{ConfigObject}->Get('ServicePreferences') };
        for my $CurrKey ( keys(%PrefConfig) ) {
            my %CurrPrefs = ();
            $CurrPrefs{Label}               = $PrefConfig{$CurrKey}->{Label};
            $CurrPrefs{SelectionSource}     = $PrefConfig{$CurrKey}->{SelectionSource};
            $CurrPrefs{GeneralCatalogClass} = $PrefConfig{$CurrKey}->{GeneralCatalogClass};
            $Preferences{ $PrefConfig{$CurrKey}->{PrefKey} } = \%CurrPrefs;
        }
    }


    for my $ServiceID (@ServiceList) {
        my %ServiceData = $Self->{ServiceObject}->ServiceGet(
            ServiceID => $ServiceID,
            UserID    => 1,            # no permission restriction for this export
        );

        #export valid string instead of ID...
        $ServiceData{Valid} = $Self->{ValidObject}->ValidLookup(
            ValidID => $ServiceData{ValidID},
        );

        PREFERENCECHECK:
        for my $CurrKey ( keys(%ServiceData) ) {

            # check if this is a preference...
            next PREFERENCECHECK if ( !$Preferences{$CurrKey} );

            # check if this is an ID-attribute...
            next PREFERENCECHECK if ( $CurrKey !~ /^(.+)ID$/ );
            my $NamePart = $1;

            # skip if an attribute with a similar name but no "ID" suffix exists...
            next PREFERENCECHECK if ( $ServiceData{$NamePart} );

            # check for source of preference...
            my %SelectionList = ();
            if (
                $Preferences{$CurrKey}->{SelectionSource}
                && $Preferences{$CurrKey}->{SelectionSource} eq 'QueueList'
                )
            {
                %SelectionList = $Self->{QueueObject}->QueueList();
            }
            elsif (
                $Preferences{$CurrKey}->{SelectionSource}
                && $Preferences{$CurrKey}->{SelectionSource} eq 'TypeList'
                )
            {
                %SelectionList = $Self->{TypeObject}->TypeList();
            }
            elsif (
                ( $Preferences{$CurrKey}->{SelectionSource} )
                &&
                ( $Preferences{$CurrKey}->{SelectionSource} eq 'GeneralCatalog' )
                &&
                ( $Preferences{$CurrKey}->{GeneralCatalogClass} ) &&
                $Self->{GeneralCatalogObject}
                )
            {
                my $ItemListRef = $Self->{GeneralCatalogObject}->ItemList(
                    Class => $Preferences{$CurrKey}->{GeneralCatalogClass},
                );
                if ( $ItemListRef && ref($ItemListRef) eq 'HASH' ) {
                    %SelectionList = %{$ItemListRef};
                }
            }

            # create non-ID value for export...
            $ServiceData{$NamePart} = $SelectionList{ $ServiceData{$CurrKey} }
                || $ServiceData{$CurrKey};

        }

        my @CurrRow = qw{};
        for my $MappingObject (@MappingObjectList) {
            my $Key = $MappingObject->{Key};
            if ( $MappingObject->{Key} && $ServiceData{ $MappingObject->{Key} } ) {
                push( @CurrRow, $ServiceData{ $MappingObject->{Key} } );
            }
            else {
                push( @CurrRow, '-' );
            }
        }
        push @ExportData, \@CurrRow;
    }
    return \@ExportData;
}

=item ImportDataSave()

import one row of the import data

    my $ConfigItemID = $ObjectBackend->ImportDataSave(
        TemplateID    => 123,
        ImportDataRow => $ArrayRef,
        UserID        => 1,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(TemplateID ImportDataRow UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # check import data row
    if ( ref $Param{ImportDataRow} ne 'ARRAY' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'ImportDataRow must be an array reference',
        );
        return;
    }

    # get object data
    my $ObjectData = $Self->{ImportExportObject}->ObjectDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check object data
    if ( !$ObjectData || ref $ObjectData ne 'HASH' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No object data found for the template id $Param{TemplateID}",
        );
        return;
    }

    # get the mapping list
    my $MappingList = $Self->{ImportExportObject}->MappingList(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check the mapping list
    if ( !$MappingList || ref $MappingList ne 'ARRAY' || !@{$MappingList} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No valid mapping list found for the template id $Param{TemplateID}",
        );
        return;
    }

    # create the mapping object list
    my @MappingObjectList;
    my %Identifier;
    my $Counter              = 0;
    my %NewServiceData       = qw{};
    my $ServiceIdentifierKey = "";

    #--------------------------------------------------------------------------
    #BUILD MAPPING TABLE...
    for my $MappingID ( @{$MappingList} ) {

        # get mapping object data
        my $MappingObjectData =
            $Self->{ImportExportObject}->MappingObjectDataGet(
            MappingID => $MappingID,
            UserID    => $Param{UserID},
            );

        # check mapping object data
        if ( !$MappingObjectData || ref $MappingObjectData ne 'HASH' ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "No valid mapping list found for template id $Param{TemplateID}",
            );
            return;
        }
        push( @MappingObjectList, $MappingObjectData );
        if (
            $MappingObjectData->{Identifier}
            && $Identifier{ $MappingObjectData->{Key} }
            )
        {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Can't import this entity. "
                    . "'$MappingObjectData->{Key}' has been used multiple "
                    . "times as identifier (line $Param{Counter}).!",
            );
            return;
        }
        elsif ( $MappingObjectData->{Identifier} ) {
            $Identifier{ $MappingObjectData->{Key} } =
                $Param{ImportDataRow}->[$Counter];
            $ServiceIdentifierKey = $MappingObjectData->{Key};
        }
        $NewServiceData{ $MappingObjectData->{Key} } =
            $Param{ImportDataRow}->[$Counter];

        #EO special treatment
        $Counter++;
    }

    #--------------------------------------------------------------------------
    # DO THE IMPORT...
    #(0) Preprocess data...
    if ( !$NewServiceData{FullName} ) {
        $NewServiceData{FullName} = $NewServiceData{Name};
    }

    # lookup Valid-ID...
    if ( !$NewServiceData{ValidID} && $NewServiceData{Valid} ) {
        $NewServiceData{ValidID} = $Self->{ValidObject}->ValidLookup(
            Valid => $NewServiceData{Valid}
        );
    }

    # default validity...
    if ( !$NewServiceData{ValidID} ) {
        $NewServiceData{ValidID} = $ObjectData->{DefaultValid} || 1;
    }

    # lookup criticality-ID...
    if (
        $Self->{ReverseCriticalityList}
        && $NewServiceData{Criticality}
        && $Self->{ReverseCriticalityList}->{ $NewServiceData{Criticality} }
        )
    {
        $NewServiceData{CriticalityID} =
            $Self->{ReverseCriticalityList}->{ $NewServiceData{Criticality} };
    }
    if ( !$NewServiceData{CriticalityID} ) {
        $NewServiceData{CriticalityID} = $ObjectData->{DefaultCriticalityID};
    }

    # lookup type-ID...
    if (
        $Self->{ReverseServiceTypeList}
        && $NewServiceData{Type}
        && $Self->{ReverseServiceTypeList}->{ $NewServiceData{Type} }
        )
    {
        $NewServiceData{TypeID} = $Self->{ReverseServiceTypeList}->{ $NewServiceData{Type} };
    }
    if ( !$NewServiceData{TypeID} ) {
        $NewServiceData{TypeID} = $ObjectData->{DefaultServiceTypeID};
    }
    if ( $NewServiceData{Name} && $NewServiceData{Name} =~ /::/ ) {
        my @NamePartsArr = split( "::", $NewServiceData{Name} );
        $NewServiceData{Name}     = pop(@NamePartsArr);
        $NewServiceData{ParentID} = $Self->{ServiceObject}->ServiceLookup(
            Name => join( "::", @NamePartsArr ),
        );
    }

    #---------------------------------------------------------------------------
    # prepare preferences...

    # get preferences configuration...
    my %Preferences = ();
    if ( $Self->{ConfigObject}->Get('ServicePreferences') ) {
        my %PrefConfig = %{ $Self->{ConfigObject}->Get('ServicePreferences') };
        for my $CurrKey ( keys(%PrefConfig) ) {
            my %CurrPrefs = ();
            $CurrPrefs{Label}               = $PrefConfig{$CurrKey}->{Label};
            $CurrPrefs{SelectionSource}     = $PrefConfig{$CurrKey}->{SelectionSource};
            $CurrPrefs{GeneralCatalogClass} = $PrefConfig{$CurrKey}->{GeneralCatalogClass};
            $Preferences{ $PrefConfig{$CurrKey}->{PrefKey} } = \%CurrPrefs;
        }
    }

    PREFERENCECHECK:
    for my $CurrKey ( keys(%NewServiceData) ) {
        my $CurrUsedKey = "";
        my $NamePart    = $CurrKey;
        if ( $CurrKey =~ /^(.+)ID$/ ) {
            $NamePart    = $1;
            $CurrUsedKey = $CurrKey;
        }
        else {
            $CurrUsedKey = $CurrKey . "ID";
        }

        # skip if no preference with same name but suffix "ID" exists...
        next PREFERENCECHECK if ( !$Preferences{$CurrUsedKey} );

        # skip if no SelectionSource specified..
        next PREFERENCECHECK if ( !$Preferences{$CurrUsedKey}->{SelectionSource} );

        # check for source of preference...
        my %SelectionList = ();
        if ( $Preferences{$CurrUsedKey}->{SelectionSource} eq 'QueueList' ) {
            %SelectionList = $Self->{QueueObject}->QueueList();
        }
        elsif ( $Preferences{$CurrUsedKey}->{SelectionSource} eq 'TypeList' ) {
            %SelectionList = $Self->{TypeObject}->TypeList();
        }
        elsif (
            ( $Preferences{$CurrUsedKey}->{SelectionSource} eq 'GeneralCatalog' )
            &&
            ( $Preferences{$CurrUsedKey}->{GeneralCatalogClass} ) &&
            $Self->{GeneralCatalogObject}
            )
        {
            my $ItemListRef = $Self->{GeneralCatalogObject}->ItemList(
                Class => $Preferences{$CurrUsedKey}->{GeneralCatalogClass},
            );
            if ( $ItemListRef && ref($ItemListRef) eq 'HASH' ) {
                %SelectionList = %{$ItemListRef};
            }
        }
        my %ReverseSelectionList = reverse(%SelectionList);

        # if only xxxID is given, set xxx...
        if (
            $NewServiceData{$CurrUsedKey}
            && ( !$NewServiceData{$NamePart} || $NamePart eq $CurrUsedKey )
            )
        {
            $NewServiceData{$NamePart} = $SelectionList{ $NewServiceData{$CurrUsedKey} };
        }

        # if xxxID AND xxx are given require uniqeness...
        elsif ( $NewServiceData{$CurrUsedKey} && $NewServiceData{$NamePart} ) {
            my $CompareValue = $SelectionList{ $NewServiceData{$CurrUsedKey} };
            if ( $CompareValue ne $NewServiceData{$NamePart} ) {
                $Self->{LogObject}->Log(
                    Priority => 'error',
                    Message  => "Can't import this entity. "
                        . "Ambigous definition of attribute values "
                        . " ($NamePart <$NewServiceData{$NamePart}> does not"
                        . "match $CurrUsedKey <$NewServiceData{$CurrUsedKey}>)!",
                );
                return;
            }
        }

        # if only xxx is given and ID can be found - get the ID...
        elsif ( !$NewServiceData{$CurrUsedKey}
            && $NewServiceData{$NamePart}
            && $ReverseSelectionList{ $NewServiceData{$NamePart} } )
        {
            $NewServiceData{$CurrUsedKey} = $ReverseSelectionList{ $NewServiceData{$NamePart} };
        }

        # if only xxx is given and no ID can be found - reject import...
        elsif ( !$NewServiceData{$CurrUsedKey}
            && $NewServiceData{$NamePart}
            && !$ReverseSelectionList{ $NewServiceData{$NamePart} } )
        {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Can't import this entity. "
                    . "Bad definition of attribute value "
                    . " ($NamePart <$NewServiceData{$NamePart}> does not"
                    . "match any existing value in selection)!",
            );
            return;
        }

    }

    #---------------------------------------------------------------------------
    #(1) search service...
    my %ServiceData = ();
    my $NewService  = 1;
    my $ServiceID   = $NewServiceData{$ServiceIdentifierKey} || 0;
    if (
        !$ServiceIdentifierKey
        || $ServiceIdentifierKey eq 'Name'
        || !$NewServiceData{$ServiceIdentifierKey}
        )
    {
        if ( $NewServiceData{FullName} ) {
            $ServiceID = $Self->{ServiceObject}->ServiceLookup(
                Name => $NewServiceData{FullName},
            );
        }
    }
    if ($ServiceID) {
        %ServiceData = $Self->{ServiceObject}->ServiceGet(
            ServiceID => $ServiceID,
            UserID    => 1,
        );
    }
    if ( scalar( keys(%ServiceData) ) ) {
        $NewService = 0;
    }
    for my $Key ( keys(%NewServiceData) ) {
        next if ( !$NewServiceData{$Key} );
        $ServiceData{$Key} = $NewServiceData{$Key};
    }

    #(2) if service DOES NOT exists => create new...
    my $Result = 0;
    if ( $NewService && $ServiceData{Name} && $ServiceData{ValidID} ) {
        $ServiceID = $Self->{ServiceObject}->ServiceAdd(
            %ServiceData,
            UserID => $Param{UserID},
        );
        if ( !$ServiceID ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => 'ImportDataSave: adding service <'
                    . $ServiceData{Name}
                    . '> failed (line $Param{Counter}).',
            );
        }
    }

    #(3) if service DOES exists => update...
    if ( !$NewService && $ServiceData{Name} && $ServiceData{ValidID} ) {
        $Result = $Self->{ServiceObject}->ServiceUpdate(
            %ServiceData,
            UserID => $Param{UserID},
        );
        if ( !$Result ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => 'ImportDataSave: updating service <'
                    . $ServiceData{Name}
                    . '> (ID '
                    . $ServiceData{ServiceID}
                    . ') failed (line $Param{Counter}).',
            );
        }
    }

    #(4) set preferences...
    if ($ServiceID) {
        for my $CurrKey ( keys(%Preferences) ) {
            next if ( !$NewServiceData{$CurrKey} );
            $Self->{ServiceObject}->ServicePreferencesSet(
                ServiceID => $ServiceID,
                Key       => $CurrKey,
                Value     => $NewServiceData{$CurrKey},
                UserID    => $Param{UserID},
            );
        }
    }

    #
    #--------------------------------------------------------------------------
    return $Result;
}
1;

=back

=head1 TERMS AND CONDITIONS

This software is a derivative part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION

$Revision: 1.11 $ $Date: 2011-11-29 10:28:57 $

=cut
 # --
# Kernel/System/ImportExport/ObjectBackend/Service2CustomerUser.pm
#
#- import/export backend for Service2CustomerUser-mapping
#
# Copyright (C) 2006-2010 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# --
# $Id: Service2CustomerUser.pm,v 1.8 2010-07-30 17:47:12 tto Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

package Kernel::System::ImportExport::ObjectBackend::Service2CustomerUser;

use strict;
use warnings;
use Kernel::System::CustomerUser;
use Kernel::System::Service;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.8 $) [1];

=head1 NAME

Kernel::System::ImportExport::ObjectBackend::CustomerUser - import/export backend for CustomerUser

=head1 SYNOPSIS

All functions to import and export CustomerUser entries

=over 4

=cut

=item new()

create an object

    use Kernel::Config;
    use Kernel::System::DB;
    use Kernel::System::Log;
    use Kernel::System::Main;
    use Kernel::System::ImportExport::ObjectBackend::CustomerUser;

    my $ConfigObject = Kernel::Config->new();
    my $LogObject = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
    );
    my $MainObject = Kernel::System::Main->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
    );
    my $BackendObject = Kernel::System::ImportExport::ObjectBackend::CustomerUser->new(
        ConfigObject       => $ConfigObject,
        LogObject          => $LogObject,
        DBObject           => $DBObject,
        MainObject         => $MainObject,
        ImportExportObject => $ImportExportObject,
    );

=cut

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

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

    #check required objects...
    for my $Object (
        qw(ConfigObject LogObject DBObject MainObject ImportExportObject EncodeObject)
        )
    {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }

    if ( !$Self->{CustomerUserObject} ) {
        $Self->{CustomerUserObject} =
            Kernel::System::CustomerUser->new( %{$Self} );
    }

    if ( !$Self->{ServiceObject} ) {
        $Self->{ServiceObject} =
            Kernel::System::Service->new( %{$Self} );
    }

    return $Self;
}

=item ObjectAttributesGet()

get the object attributes of an object as array/hash reference

    my $Attributes = $ObjectBackend->ObjectAttributesGet(
        UserID => 1,
    );

=cut

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

    # check needed object
    if ( !$Param{UserID} ) {
        $Self->{LogObject}
            ->Log( Priority => 'error', Message => 'Need UserID!' );
        return;
    }

    my $Attributes = [
        {
            Key   => 'LabelExport',
            Name  => 'Export with labels',
            Input => {
                Type => 'Selection',
                Data => {
                    '0' => 'No',
                    '1' => 'Yes',
                },
                Required     => 0,
                Translation  => 1,
                PossibleNone => 0,
                ValueDefault => 0,
            },
        },
    ];

    return $Attributes;
}

=item MappingObjectAttributesGet()

get the mapping attributes of an object as array/hash reference

    my $Attributes = $ObjectBackend->MappingObjectAttributesGet(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # get object data
    my $ObjectData = $Self->{ImportExportObject}->ObjectDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    my $ElementList = [
        {
            Key   => 'CustomerUserLogin',
            Value => 'Customer User Login',
        },
        {
            Key   => 'ServiceName',
            Value => 'Service Name',
        },
        {
            Key   => 'ServiceID',
            Value => 'Service ID',
        },
        {
            Key   => 'AssignmentActive',
            Value => 'Validity of service assignment for CU',
        },

    ];

    my $Attributes = [
        {
            Key   => 'Key',
            Name  => 'Key',
            Input => {
                Type         => 'Selection',
                Data         => $ElementList,
                Required     => 1,
                Translation  => 0,
                PossibleNone => 1,
            },
        },

        # currently, there are no additional attributes
        #        {
        #            Key   => 'Identifier',
        #            Name  => 'Identifier',
        #            Input => { Type => 'Checkbox', },
        #        },
    ];

    return $Attributes;
}

=item SearchAttributesGet()

get the search object attributes of an object as array/hash reference

    my $AttributeList = $ObjectBackend->SearchAttributesGet(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    my $AttributeList = [
        {
            Key   => 'CustomerUserLogin',
            Name  => 'Customer User Login',
            Input => {
                Type      => 'Text',
                Size      => 80,
                MaxLength => 255,
            },
        },
        {
            Key   => 'ServiceName',
            Name  => 'Service Name',
            Input => {
                Type      => 'Text',
                Size      => 80,
                MaxLength => 255,
            },
        },
    ];

    return $AttributeList;
}

=item ExportDataGet()

get export data as 2D-array-hash reference

    my $ExportData = $ObjectBackend->ExportDataGet(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # get object data
    my $ObjectData = $Self->{ImportExportObject}->ObjectDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check object data
    if ( !$ObjectData || ref $ObjectData ne 'HASH' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No object data found for the template id $Param{TemplateID}",
        );
        return;
    }

    # get the mapping list
    my $MappingList = $Self->{ImportExportObject}->MappingList(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check the mapping list
    if ( !$MappingList || ref $MappingList ne 'ARRAY' || !@{$MappingList} ) {

        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No valid mapping list found for the template id $Param{TemplateID}",
        );
        return;
    }

    # create the mapping object list
    my @MappingObjectList;
    for my $MappingID ( @{$MappingList} ) {

        # get mapping object data
        my $MappingObjectData =
            $Self->{ImportExportObject}->MappingObjectDataGet(
            MappingID => $MappingID,
            UserID    => $Param{UserID},
            );

        # check mapping object data
        if ( !$MappingObjectData || ref $MappingObjectData ne 'HASH' ) {

            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "No valid mapping list found for the template id $Param{TemplateID}",
            );
            return;
        }

        push( @MappingObjectList, $MappingObjectData );
    }

    # get search data
    my $SearchData = $Self->{ImportExportObject}->SearchDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    if ( $SearchData && ref($SearchData) ne 'HASH' ) {
        $SearchData = 0;
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message =>
                "Service2CustomerUser: search data is not a hash ref - ignoring search limitation.",
        );
    }

    if ( $SearchData && $SearchData->{ServiceName} && $SearchData->{ServiceName} =~ /\*/ ) {
        $SearchData->{ServiceName} =~ s/\*/.*/g;
    }
    if (
        $SearchData
        && $SearchData->{CustomerUserLogin}
        && $SearchData->{CustomerUserLogin} =~ /\*/
        )
    {
        $SearchData->{CustomerUserLogin} =~ s/\*/.*/g;
    }

    #search all services...
    my %ServiceData = $Self->{ServiceObject}->ServiceList(
        Valid  => 0,
        UserID => 1,
    );

    # export data...
    my @ExportData;

    # export headline/labels ...
    if ( $ObjectData->{LabelExport} ) {
        my @CurrRow = qw{};
        for my $MappingObject (@MappingObjectList) {
            push( @CurrRow, $MappingObject->{Key} || '-' );
        }
        push @ExportData, \@CurrRow;
    }

    for my $ServiceID ( keys(%ServiceData) ) {

        #check for ServiceName export filter...
        if ( $SearchData && $SearchData->{ServiceName} ) {
            if ( $SearchData->{ServiceName} =~ /\*/ ) {
                next if ( $ServiceData{$ServiceID} !~ /$SearchData->{ServiceName}/ );
            }
            else {
                next if ( $ServiceData{$ServiceID} ne $SearchData->{ServiceName} );
            }
        }

        #search all customers set for current service...
        my %CustomerServiceHash = $Self->{ServiceObject}->CustomerUserServiceMemberList(
            ServiceID       => $ServiceID,
            Result          => 'HASH',
            DefaultServices => 0,
        );

        for my $CurrentCUL ( keys(%CustomerServiceHash) ) {
            my @CurrRow = qw{};

            #check for CustomerUserLogin export filter...
            if ( $SearchData && $SearchData->{CustomerUserLogin} ) {
                if ( $SearchData->{CustomerUserLogin} =~ /\*/ ) {
                    next if ( $CurrentCUL !~ /$SearchData->{CustomerUserLogin}/ );
                }
                else {
                    next if ( $CurrentCUL ne $SearchData->{ServiceName} );
                }
            }

            for my $MappingObject (@MappingObjectList) {
                my $Key = $MappingObject->{Key};

                if ( $MappingObject->{Key} && $MappingObject->{Key} eq 'CustomerUserLogin' ) {
                    push( @CurrRow, $CurrentCUL );
                }
                elsif ( $MappingObject->{Key} && $MappingObject->{Key} eq 'ServiceName' ) {
                    push( @CurrRow, $ServiceData{$ServiceID} || '' );
                }
                elsif ( $MappingObject->{Key} && $MappingObject->{Key} eq 'ServiceID' ) {
                    push( @CurrRow, $ServiceID || '' );
                }
                elsif ( $MappingObject->{Key} && $MappingObject->{Key} eq 'AssignmentActive' ) {
                    push( @CurrRow, 'valid' );
                }
                else {
                    push( @CurrRow, '-' );
                }
            }

            push @ExportData, \@CurrRow;

        }

    }

    return \@ExportData;
}

=item ImportDataSave()

import one row of the import data

    my $ConfigItemID = $ObjectBackend->ImportDataSave(
        TemplateID    => 123,
        ImportDataRow => $ArrayRef,
        UserID        => 1,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(TemplateID ImportDataRow UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # check import data row
    if ( ref $Param{ImportDataRow} ne 'ARRAY' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'ImportDataRow must be an array reference',
        );
        return;
    }

    # get object data
    my $ObjectData = $Self->{ImportExportObject}->ObjectDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check object data
    if ( !$ObjectData || ref $ObjectData ne 'HASH' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No object data found for the template id $Param{TemplateID}",
        );
        return;
    }

    # get the mapping list
    my $MappingList = $Self->{ImportExportObject}->MappingList(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check the mapping list
    if ( !$MappingList || ref $MappingList ne 'ARRAY' || !@{$MappingList} ) {

        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No valid mapping list found for the template id $Param{TemplateID}",
        );
        return;
    }

    # create the mapping object list
    my @MappingObjectList;
    my %Identifier;
    my $Counter         = 0;
    my %ImportData      = qw{};
    my $CustomerUserKey = "";

    #--------------------------------------------------------------------------
    #BUILD MAPPING TABLE...
    for my $MappingID ( @{$MappingList} ) {

        # get mapping object data
        my $MappingObjectData =
            $Self->{ImportExportObject}->MappingObjectDataGet(
            MappingID => $MappingID,
            UserID    => $Param{UserID},
            );

        # check mapping object data
        if ( !$MappingObjectData || ref $MappingObjectData ne 'HASH' ) {

            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "No valid mapping list found for template id $Param{TemplateID}",
            );
            return;
        }

        push( @MappingObjectList, $MappingObjectData );

        $ImportData{ $MappingObjectData->{Key} } =
            $Param{ImportDataRow}->[$Counter];

        $Counter++;

    }

    #--------------------------------------------------------------------------
    #DO THE IMPORT...

    #(1) search service...
    if ( $ImportData{ServiceName} ) {
        my $CurrentSID = $Self->{ServiceObject}->ServiceLookup(
            Name => $ImportData{ServiceName},
        ) || 0;

        if ( !$ImportData{ServiceID} ) {
            $ImportData{ServiceID} = $CurrentSID;
        }
        if ( !$CurrentSID || $ImportData{ServiceID} != $CurrentSID ) {

            #service name does not exist or does not fit to ServiceID - drop line...
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Service2CustomerUser: service <"
                    . $ImportData{ServiceName}
                    . "> does not exist or does not match given ServiceID <"
                    . ( $ImportData{ServiceID} || '' )
                    . ">.",
            );
        }
    }

    #(2) search customer user...
    if ( $ImportData{CustomerUserLogin} && $ImportData{CustomerUserLogin} !~ /DEFAULT/ ) {
        my %CustomerUserData = $Self->{CustomerUserObject}->CustomerUserDataGet(
            User => $ImportData{CustomerUserLogin}
        );
        if ( !%CustomerUserData ) {

            #customer user login does not exist - drop line...
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Service2CustomerUser: customer login <"
                    . "$ImportData{CustomerUserLogin}> does not exist.",
            );
        }
    }

    #(3) normalize AssignmentActive value...
    if ( $ImportData{AssignmentActive} && $ImportData{AssignmentActive} =~ /invalid/ ) {
        $ImportData{AssignmentActive} = 0;
    }
    else {
        $ImportData{AssignmentActive} = 1;
    }

    #(4) dis/enable customer user - service mapping...
    if ( $ImportData{CustomerUserLogin} !~ /DEFAULT/ ) {
        $Self->{ServiceObject}->CustomerUserServiceMemberAdd(
            CustomerUserLogin => $ImportData{CustomerUserLogin},
            ServiceID         => $ImportData{ServiceID},
            Active            => $ImportData{AssignmentActive} || 0,
            UserID            => $Param{UserID},
        );
    }
    else {
        $Self->{ServiceObject}->CustomerUserServiceMemberAdd(
            CustomerUserLogin => '<DEFAULT>',
            ServiceID         => $ImportData{ServiceID},
            Active            => $ImportData{AssignmentActive} || 0,
            UserID            => $Param{UserID},
        );
    }

    #
    #--------------------------------------------------------------------------

    return 1;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is a derivative part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION

$Revision: 1.8 $ $Date: 2010-07-30 17:47:12 $

=cut

 # --
# Kernel/System/ImportExport/ObjectBackend/SLA.pm
#
#- import/export backend for SLA definitions
#
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# --
# $Id: SLA.pm,v 1.10 2011-11-29 10:28:57 tto Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

package Kernel::System::ImportExport::ObjectBackend::SLA;

use strict;
use warnings;
use Kernel::System::Service;
use Kernel::System::SLA;
use Kernel::System::Valid;

use vars qw($VERSION);
$VERSION = qw($Revision: 1.10 $) [1];

=head1 NAME

Kernel::System::ImportExport::ObjectBackend::CustomerUser - import/export backend for CustomerUser

=head1 SYNOPSIS

All functions to import and export CustomerUser entries

=over 4

=cut

=item new()

create an object

    use Kernel::Config;
    use Kernel::System::DB;
    use Kernel::System::Log;
    use Kernel::System::Main;
    use Kernel::System::ImportExport::ObjectBackend::CustomerUser;

    my $ConfigObject = Kernel::Config->new();
    my $LogObject = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
    );
    my $MainObject = Kernel::System::Main->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
    );
    my $BackendObject = Kernel::System::ImportExport::ObjectBackend::CustomerUser->new(
        ConfigObject       => $ConfigObject,
        LogObject          => $LogObject,
        DBObject           => $DBObject,
        MainObject         => $MainObject,
        ImportExportObject => $ImportExportObject,
    );

=cut

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

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

    #check required objects...
    for my $Object (
        qw(ConfigObject LogObject DBObject MainObject ImportExportObject EncodeObject)
        )
    {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }

    if ( !$Self->{ValidObject} ) {
        $Self->{ValidObject} = Kernel::System::Valid->new( %{$Self} );
    }

    if ( !$Self->{ServiceObject} ) {
        $Self->{ServiceObject} =
            Kernel::System::Service->new( %{$Self} );
    }

    if ( !$Self->{SLAObject} ) {
        $Self->{SLAObject} =
            Kernel::System::SLA->new( %{$Self} );
    }

    my $CalendarIndex    = 1;
    my %CalendarNameList = qw{};
    while ( $Self->{ConfigObject}->Get( "TimeZone::Calendar" . $CalendarIndex . "Name" ) ) {
        $CalendarNameList{$CalendarIndex} =
            $Self->{ConfigObject}->Get( "TimeZone::Calendar" . $CalendarIndex . "Name" );
        $CalendarIndex++;
    }
    my %TmpHash = reverse(%CalendarNameList);
    $Self->{CalendarNameList}        = \%CalendarNameList;
    $Self->{ReverseCalendarNameList} = \%TmpHash;

    if ( $Self->{MainObject}->Require('Kernel::System::GeneralCatalog') ) {
        $Self->{GeneralCatalogObject} = Kernel::System::GeneralCatalog->new( %{$Self} );
        if ( $Self->{GeneralCatalogObject} ) {

            # get SLA type list
            $Self->{SLATypeList} = $Self->{GeneralCatalogObject}->ItemList(
                Class => 'ITSM::SLA::Type',
            );
            my %TmpHash = reverse( %{ $Self->{SLATypeList} } );
            $Self->{ReverseSLATypeList} = \%TmpHash;
        }
    }

    return $Self;
}

=item ObjectAttributesGet()

get the object attributes of an object as array/hash reference

    my $Attributes = $ObjectBackend->ObjectAttributesGet(
        UserID => 1,
    );

=cut

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

    # check needed object
    if ( !$Param{UserID} ) {
        $Self->{LogObject}
            ->Log( Priority => 'error', Message => 'Need UserID!' );
        return;
    }
    my %Validlist = $Self->{ValidObject}->ValidList();

    my $Attributes = [
        {
            Key   => 'DefaultValid',
            Name  => 'Default Validity',
            Input => {
                Type         => 'Selection',
                Data         => \%Validlist,
                Required     => 1,
                Translation  => 1,
                PossibleNone => 0,
                ValueDefault => 1,
            },
        },
        {
            Key   => 'NumberOfAssignableServices',
            Name  => 'Max. number of assigned services columns',
            Input => {
                Type         => 'Text',
                Required     => 1,
                Size         => 3,
                MaxLength    => 3,
                ValueDefault => '50',
            },
        },

    ];

    #use the availability of SLATypeList to display ITSM-relevant config...
    if ( $Self->{SLATypeList} ) {
        my $SLATypeDefault = {
            Key   => 'DefaultSLATypeID',
            Name  => 'Default SLA Type',
            Input => {
                Type         => 'Selection',
                Data         => $Self->{SLATypeList},
                Required     => 1,
                Translation  => 1,
                PossibleNone => 0,
            },
        };
        push( @{$Attributes}, $SLATypeDefault );

        my $MinTimeBetweenIncidentsDefault = {
            Key   => 'DefaultMinTimeBetweenIncidents',
            Name  => 'Default Minimum Time Between Incidents',
            Input => {
                Type      => 'Text',
                Required  => 0,
                Size      => 10,
                MaxLength => 10,
            },
        };
        push( @{$Attributes}, $MinTimeBetweenIncidentsDefault );

    }

    return $Attributes;
}

=item MappingObjectAttributesGet()

get the mapping attributes of an object as array/hash reference

    my $Attributes = $ObjectBackend->MappingObjectAttributesGet(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # get object data
    my $ObjectData = $Self->{ImportExportObject}->ObjectDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    my $ElementList = [
        {
            Key   => 'SLAID',
            Value => 'SLA ID',
        },
        {
            Key   => 'Name',
            Value => 'SLA Name',
        },
        {
            Key   => 'Calendar',
            Value => 'Calendar Name',
        },
        {
            Key   => 'Valid',
            Value => 'Validity',
        },
        {
            Key   => 'Comment',
            Value => 'Comment',
        },
        {
            Key   => 'FirstResponseTime',
            Value => 'FirstResponseTime (business minutes)',
        },
        {
            Key   => 'FirstResponseNotify',
            Value => 'FirstResponseNotify (percent)',
        },
        {
            Key   => 'UpdateTime',
            Value => 'UpdateTime (business minutes)',
        },
        {
            Key   => 'UpdateNotify',
            Value => 'UpdateNotify (percent)',
        },
        {
            Key   => 'SolutionTime',
            Value => 'SolutionTime (business minutes)',
        },
        {
            Key   => 'SolutionNotify',
            Value => 'SolutionNotify (percent)',
        }
    ];

    #---------------------------------------------------------------------------
    # get preferences...
    my %Preferences = ();
    if ( $Self->{ConfigObject}->Get('SLAPreferences') ) {
        %Preferences = %{ $Self->{ConfigObject}->Get('SLAPreferences') };
    }
    for my $Item ( sort keys %Preferences ) {
        if (
            $Preferences{$Item}->{SelectionSource}
            && $Preferences{$Item}->{PrefKey} =~ /^(.+)ID$/
            )
        {
            my $NamePart = $1;
            push(
                @{$ElementList},
                { Key => $NamePart, Value => $Preferences{$Item}->{Label} }
            );
        }

        if ( $Preferences{$Item}->{PrefKey} =~ /^(.+)ID$/ ) {
            my $NamePart = $1;
            push(
                @{$ElementList},
                {
                    Key   => $Preferences{$Item}->{PrefKey},
                    Value => $Preferences{$Item}->{Label} . " (ID)"
                }
            );
        }
        else {
            push(
                @{$ElementList},
                { Key => $Preferences{$Item}->{PrefKey}, Value => $Preferences{$Item}->{Label} }
            );
        }

    }

    # using SLATypeList as indicator for ITSM-installation...
    if ( $Self->{SLATypeList} ) {
        my $ElementListITSM = [
            {
                Key   => 'Type',
                Value => 'SLA Type (ITSM only)',
            },
            {
                Key   => 'MinTimeBetweenIncidents',
                Value => 'Min. Time Between Incidents (ITSM only)',
            },
        ];
        my @TmpArray = ( @{$ElementList}, @{$ElementListITSM} );
        $ElementList = \@TmpArray;
    }

    # columns for assigned services...
    my $NumberOfAssignableServices = $ObjectData->{NumberOfAssignableServices} || 0;
    my $CurrIndex = 0;
    while ( $CurrIndex < $NumberOfAssignableServices ) {

        push(
            @{$ElementList},
            {
                Key   => 'AssignedService' . sprintf( "%03d", $CurrIndex ),
                Value => 'AssignedService' . sprintf( "%03d", $CurrIndex ),
            }
        );

        $CurrIndex++;
    }

    my $Attributes = [
        {
            Key   => 'Key',
            Name  => 'Key',
            Input => {
                Type         => 'Selection',
                Data         => $ElementList,
                Required     => 1,
                Translation  => 1,
                PossibleNone => 1,
            },
        },
        {
            Key   => 'Identifier',
            Name  => 'Identifier',
            Input => { Type => 'Checkbox', },
        },
    ];

    return $Attributes;
}

=item SearchAttributesGet()

get the search object attributes of an object as array/hash reference

    my $AttributeList = $ObjectBackend->SearchAttributesGet(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    my $AttributeList = [
        {
            Key   => 'Name',
            Name  => 'SLA Name',
            Input => {
                Type      => 'Text',
                Size      => 80,
                MaxLength => 255,
            },
        },
    ];

    return $AttributeList;
}

=item ExportDataGet()

get export data as 2D-array-hash reference

    my $ExportData = $ObjectBackend->ExportDataGet(
        TemplateID => 123,
        UserID     => 1,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(TemplateID UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # get object data
    my $ObjectData = $Self->{ImportExportObject}->ObjectDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check object data
    if ( !$ObjectData || ref $ObjectData ne 'HASH' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No object data found for the template id $Param{TemplateID}",
        );
        return;
    }

    # get the mapping list
    my $MappingList = $Self->{ImportExportObject}->MappingList(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check the mapping list
    if ( !$MappingList || ref $MappingList ne 'ARRAY' || !@{$MappingList} ) {

        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No valid mapping list found for the template id $Param{TemplateID}",
        );
        return;
    }

    # get search data
    my $SearchData = $Self->{ImportExportObject}->SearchDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    if ( $SearchData && ref($SearchData) ne 'HASH' ) {
        $SearchData = 0;
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message =>
                "SLA: search data is not a hash ref - ignoring search limitation.",
        );
    }

    if ( $SearchData && $SearchData->{Name} && $SearchData->{Name} =~ /\*/ ) {
        $SearchData->{Name} =~ s/\*/.*/g;
    }

    # create the mapping object list
    my @MappingObjectList;
    for my $MappingID ( @{$MappingList} ) {

        # get mapping object data
        my $MappingObjectData =
            $Self->{ImportExportObject}->MappingObjectDataGet(
            MappingID => $MappingID,
            UserID    => $Param{UserID},
            );

        # check mapping object data
        if ( !$MappingObjectData || ref $MappingObjectData ne 'HASH' ) {

            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "No valid mapping list found for the template id $Param{TemplateID}",
            );
            return;
        }

        push( @MappingObjectList, $MappingObjectData );
    }

    # export data...
    my @ExportData;

    # get preferences configuration...
    my %Preferences = ();
    if ( $Self->{ConfigObject}->Get('SLAPreferences') ) {
        my %PrefConfig = %{ $Self->{ConfigObject}->Get('SLAPreferences') };
        for my $CurrKey ( keys(%PrefConfig) ) {
            my %CurrPrefs = ();
            $CurrPrefs{Label}               = $PrefConfig{$CurrKey}->{Label};
            $CurrPrefs{SelectionSource}     = $PrefConfig{$CurrKey}->{SelectionSource};
            $CurrPrefs{GeneralCatalogClass} = $PrefConfig{$CurrKey}->{GeneralCatalogClass};
            $Preferences{ $PrefConfig{$CurrKey}->{PrefKey} } = \%CurrPrefs;
        }
    }

    # search the SLAs...
    my %SLAList = $Self->{SLAObject}->SLAList(
        Valid  => 0,
        UserID => 1,
    );

    for my $CurrSLAID ( keys(%SLAList) ) {

        #check for name (SLA) export filter...
        if ( $SearchData && $SearchData->{Name} ) {
            if ( $SearchData->{Name} =~ /\*/ ) {
                next if ( $SLAList{$CurrSLAID} !~ /$SearchData->{Name}/ );
            }
            else {
                next if ( $SLAList{$CurrSLAID} ne $SearchData->{Name} );
            }
        }

        my %SLAData = $Self->{SLAObject}->SLAGet(
            SLAID  => $CurrSLAID,
            UserID => 1,            # no permission restriction for this export
        );

        #export valid string instead of ID...
        $SLAData{Valid} = $Self->{ValidObject}->ValidLookup(
            ValidID => $SLAData{ValidID},
        );

        PREFERENCECHECK:
        for my $CurrKey ( keys(%SLAData) ) {

            # check if this is a preference...
            next PREFERENCECHECK if ( !$Preferences{$CurrKey} );

            # check if this is an ID-attribute...
            next PREFERENCECHECK if ( $CurrKey !~ /^(.+)ID$/ );
            my $NamePart = $1;

            # skip if an attribute with a similar name but no "ID" suffix exists...
            next PREFERENCECHECK if ( $SLAData{$NamePart} );

            # check for source of preference...
            my %SelectionList = ();
            if (
                $Preferences{$CurrKey}->{SelectionSource}
                && $Preferences{$CurrKey}->{SelectionSource} eq 'QueueList'
                )
            {
                %SelectionList = $Self->{QueueObject}->QueueList();
            }
            elsif (
                $Preferences{$CurrKey}->{SelectionSource}
                && $Preferences{$CurrKey}->{SelectionSource} eq 'TypeList'
                )
            {
                %SelectionList = $Self->{TypeObject}->TypeList();
            }
            elsif (
                ( $Preferences{$CurrKey}->{SelectionSource} )
                &&
                ( $Preferences{$CurrKey}->{SelectionSource} eq 'GeneralCatalog' )
                &&
                ( $Preferences{$CurrKey}->{GeneralCatalogClass} ) &&
                $Self->{GeneralCatalogObject}
                )
            {
                my $ItemListRef = $Self->{GeneralCatalogObject}->ItemList(
                    Class => $Preferences{$CurrKey}->{GeneralCatalogClass},
                );
                if ( $ItemListRef && ref($ItemListRef) eq 'HASH' ) {
                    %SelectionList = %{$ItemListRef};
                }
            }

            # create non-ID value for export...
            $SLAData{$NamePart} = $SelectionList{ $SLAData{$CurrKey} }
                || $SLAData{$CurrKey};

        }

        # prepared AssignedServices...
        if ( $SLAData{ServiceIDs} && ref( $SLAData{ServiceIDs} ) eq 'ARRAY' ) {
            my @ServiceIDList = sort @{ $SLAData{ServiceIDs} };
            my $CurrIndex     = 0;
            for my $CurrServiceID (@ServiceIDList) {
                my $CurrKeyName = 'AssignedService' . sprintf( "%03d", $CurrIndex );
                my $CurrService = $Self->{ServiceObject}->ServiceLookup(
                    ServiceID => $CurrServiceID,
                );
                $SLAData{$CurrKeyName} = $CurrService;
                $CurrIndex++;
            }

        }

        # prepare calendar name
        if ( $SLAData{Calendar} && $Self->{CalendarNameList}->{ $SLAData{Calendar} } ) {
            $SLAData{Calendar} = $Self->{CalendarNameList}->{ $SLAData{Calendar} };
        }

        # create export row...
        my @CurrRow = qw{};
        for my $MappingObject (@MappingObjectList) {
            if ( $MappingObject->{Key} && $SLAData{ $MappingObject->{Key} } ) {
                push( @CurrRow, $SLAData{ $MappingObject->{Key} } );
            }
            else {
                push( @CurrRow, '-' );
            }
        }
        push @ExportData, \@CurrRow;

    }

    return \@ExportData;
}

=item ImportDataSave()

import one row of the import data

    my $ConfigItemID = $ObjectBackend->ImportDataSave(
        TemplateID    => 123,
        ImportDataRow => $ArrayRef,
        UserID        => 1,
    );

=cut

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

    # check needed stuff
    for my $Argument (qw(TemplateID ImportDataRow UserID)) {
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

    # check import data row
    if ( ref $Param{ImportDataRow} ne 'ARRAY' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'ImportDataRow must be an array reference',
        );
        return;
    }

    # get object data
    my $ObjectData = $Self->{ImportExportObject}->ObjectDataGet(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check object data
    if ( !$ObjectData || ref $ObjectData ne 'HASH' ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No object data found for the template id $Param{TemplateID}",
        );
        return;
    }

    # get the mapping list
    my $MappingList = $Self->{ImportExportObject}->MappingList(
        TemplateID => $Param{TemplateID},
        UserID     => $Param{UserID},
    );

    # check the mapping list
    if ( !$MappingList || ref $MappingList ne 'ARRAY' || !@{$MappingList} ) {

        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No valid mapping list found for the template id $Param{TemplateID}",
        );
        return;
    }

    # create the mapping object list
    my @MappingObjectList;
    my %Identifier;
    my $Counter          = 0;
    my %NewSLAData       = qw{};
    my $SLAIdentifierKey = "";

    #--------------------------------------------------------------------------
    #BUILD MAPPING TABLE...
    for my $MappingID ( @{$MappingList} ) {

        # get mapping object data
        my $MappingObjectData =
            $Self->{ImportExportObject}->MappingObjectDataGet(
            MappingID => $MappingID,
            UserID    => $Param{UserID},
            );

        # check mapping object data
        if ( !$MappingObjectData || ref $MappingObjectData ne 'HASH' ) {

            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "No valid mapping list found for template id $Param{TemplateID}",
            );
            return;
        }

        push( @MappingObjectList, $MappingObjectData );

        if (
            $MappingObjectData->{Identifier}
            && $Identifier{ $MappingObjectData->{Key} }
            )
        {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Can't import this entity. "
                    . "'$MappingObjectData->{Key}' has been used multiple "
                    . "times as identifier.!",
            );
        }
        elsif ( $MappingObjectData->{Identifier} ) {
            $Identifier{ $MappingObjectData->{Key} } =
                $Param{ImportDataRow}->[$Counter];
            $SLAIdentifierKey = $MappingObjectData->{Key};
        }

        $NewSLAData{ $MappingObjectData->{Key} } =
            $Param{ImportDataRow}->[$Counter];

        $Counter++;
    }

    #--------------------------------------------------------------------------
    #DO THE IMPORT...
    #(0) Preprocess data...

    # prepare calendar name...
    if ( $NewSLAData{Calendar} && $Self->{ReverseCalendarNameList}->{ $NewSLAData{Calendar} } ) {
        $NewSLAData{Calendar} = $Self->{ReverseCalendarNameList}->{ $NewSLAData{Calendar} };
    }

    # lookup Valid-ID...
    if ( !$NewSLAData{ValidID} && $NewSLAData{Valid} ) {
        $NewSLAData{ValidID} = $Self->{ValidObject}->ValidLookup(
            Valid => $NewSLAData{Valid}
        );
    }
    if ( !$NewSLAData{ValidID} ) {
        $NewSLAData{ValidID} = $ObjectData->{DefaultValid} || 1;
    }

    # lookup type-ID...
    if (
        $Self->{ReverseSLATypeList}
        && $NewSLAData{Type}
        && $Self->{ReverseSLATypeList}->{ $NewSLAData{Type} }
        )
    {
        $NewSLAData{TypeID} = $Self->{ReverseSLATypeList}->{ $NewSLAData{Type} };
    }
    if ( !$NewSLAData{TypeID} ) {
        $NewSLAData{TypeID} = $ObjectData->{DefaultSLATypeID};
    }

    # lookup assigned ServiceIDs
    my $NumberOfAssignableServices = $ObjectData->{NumberOfAssignableServices} || 0;
    my $CurrIndex                  = 0;
    my @NewServiceIDs              = qw{};
    while ( $CurrIndex < $NumberOfAssignableServices ) {
        my $CurrKeyName = 'AssignedService' . sprintf( "%03d", $CurrIndex );

        if ( $NewSLAData{$CurrKeyName} && $NewSLAData{$CurrKeyName} ne '-' ) {
            my $CurrServiceID = $Self->{ServiceObject}->ServiceLookup(
                Name => $NewSLAData{$CurrKeyName},
            );
            if ($CurrServiceID) {
                push( @NewServiceIDs, $CurrServiceID );
            }
        }

        $CurrIndex++;
    }

    #---------------------------------------------------------------------------
    # prepare preferences...

    # get preferences configuration...
    my %Preferences = ();
    if ( $Self->{ConfigObject}->Get('SLAPreferences') ) {
        my %PrefConfig = %{ $Self->{ConfigObject}->Get('SLAPreferences') };
        for my $CurrKey ( keys(%PrefConfig) ) {
            my %CurrPrefs = ();
            $CurrPrefs{Label}               = $PrefConfig{$CurrKey}->{Label};
            $CurrPrefs{SelectionSource}     = $PrefConfig{$CurrKey}->{SelectionSource};
            $CurrPrefs{GeneralCatalogClass} = $PrefConfig{$CurrKey}->{GeneralCatalogClass};
            $Preferences{ $PrefConfig{$CurrKey}->{PrefKey} } = \%CurrPrefs;
        }
    }

    PREFERENCECHECK:
    for my $CurrKey ( keys(%NewSLAData) ) {
        my $CurrUsedKey = "";
        my $NamePart    = $CurrKey;
        if ( $CurrKey =~ /^(.+)ID$/ ) {
            $NamePart    = $1;
            $CurrUsedKey = $CurrKey;
        }
        else {
            $CurrUsedKey = $CurrKey . "ID";
        }

        # skip if no preference with same name but suffix "ID" exists...
        next PREFERENCECHECK if ( !$Preferences{$CurrUsedKey} );

        # skip if no SelectionSource specified..
        next PREFERENCECHECK if ( !$Preferences{$CurrUsedKey}->{SelectionSource} );

        # check for source of preference...
        my %SelectionList = ();
        if ( $Preferences{$CurrUsedKey}->{SelectionSource} eq 'QueueList' ) {
            %SelectionList = $Self->{QueueObject}->QueueList();
        }
        elsif ( $Preferences{$CurrUsedKey}->{SelectionSource} eq 'TypeList' ) {
            %SelectionList = $Self->{TypeObject}->TypeList();
        }
        elsif (
            ( $Preferences{$CurrUsedKey}->{SelectionSource} eq 'GeneralCatalog' )
            &&
            ( $Preferences{$CurrUsedKey}->{GeneralCatalogClass} ) &&
            $Self->{GeneralCatalogObject}
            )
        {
            my $ItemListRef = $Self->{GeneralCatalogObject}->ItemList(
                Class => $Preferences{$CurrUsedKey}->{GeneralCatalogClass},
            );
            if ( $ItemListRef && ref($ItemListRef) eq 'HASH' ) {
                %SelectionList = %{$ItemListRef};
            }
        }
        my %ReverseSelectionList = reverse(%SelectionList);

        # if only xxxID is given, set xxx...
        if (
            $NewSLAData{$CurrUsedKey}
            && ( !$NewSLAData{$NamePart} || $NamePart eq $CurrUsedKey )
            )
        {
            $NewSLAData{$NamePart} = $SelectionList{ $NewSLAData{$CurrUsedKey} };
        }

        # if xxxID AND xxx are given require uniqeness...
        elsif ( $NewSLAData{$CurrUsedKey} && $NewSLAData{$NamePart} ) {
            my $CompareValue = $SelectionList{ $NewSLAData{$CurrUsedKey} };
            if ( $CompareValue ne $NewSLAData{$NamePart} ) {
                $Self->{LogObject}->Log(
                    Priority => 'error',
                    Message  => "Can't import this entity. "
                        . "Ambigous definition of attribute values "
                        . " ($NamePart <$NewSLAData{$NamePart}> does not"
                        . "match $CurrUsedKey <$NewSLAData{$CurrUsedKey}>)!",
                );
                return;
            }
        }

        # if only xxx is given and ID can be found - get the ID...
        elsif (
            !$NewSLAData{$CurrUsedKey}
            && $NewSLAData{$NamePart}
            && $ReverseSelectionList{ $NewSLAData{$NamePart} }
            )
        {
            $NewSLAData{$CurrUsedKey} = $ReverseSelectionList{ $NewSLAData{$NamePart} };
        }

        # if only xxx is given and no ID can be found - reject import...
        elsif (
            !$NewSLAData{$CurrUsedKey}
            && $NewSLAData{$NamePart}
            && !$ReverseSelectionList{ $NewSLAData{$NamePart} }
            )
        {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Can't import this entity. "
                    . "Bad definition of attribute value "
                    . " ($NamePart <$NewSLAData{$NamePart}> does not"
                    . "match any existing value in selection)!",
            );
            return;
        }

    }

    #---------------------------------------------------------------------------
    #(1) search SLA...
    my %SLAData = ();
    my $NewSLA  = 1;
    my $SLAID   = $NewSLAData{$SLAIdentifierKey} || 0;

    if (
        ( !$SLAIdentifierKey || $SLAIdentifierKey eq 'Name' || !$NewSLAData{$SLAIdentifierKey} )
        && $NewSLAData{Name}
        )
    {
        $SLAID = $Self->{SLAObject}->SLALookup(
            Name => $NewSLAData{Name},
        );
    }

    if ( $SLAID && $SLAID =~ /\d+/ ) {
        %SLAData = $Self->{SLAObject}->SLAGet(
            SLAID  => $SLAID,
            UserID => 1,
        );
    }
    elsif ($SLAID) {
        $Self->{LogObject}->Log(
            Priority => 'notice',
            Message  => 'ImportDataSave: SLAID <' . $SLAID . '> is not a number '
                . '(maybe label or headline).',
        );
        return 0;
    }

    if ( scalar( keys(%SLAData) ) ) {
        $NewSLA = 0;
    }

    for my $Key ( keys(%NewSLAData) ) {
        next if ( !$NewSLAData{$Key} );
        $SLAData{$Key} = $NewSLAData{$Key};
    }

    for my $CurrKey (
        qw( FirstResponseTime FirstResponseNotify UpdateTime
        UpdateNotify SolutionTime SolutionNotify MinTimeBetweenIncidents)
        )
    {
        if ( $SLAData{$CurrKey} && $SLAData{$CurrKey} eq '-' ) {
            delete( $SLAData{$CurrKey} );
        }
    }

    $SLAData{ServiceIDs} = \@NewServiceIDs;

    #(2) if SLA DOES NOT exists => create new...
    my $Result = 0;
    if ($NewSLA) {
        $Result = $Self->{SLAObject}->SLAAdd(
            %SLAData,
            UserID => $Param{UserID},
        );

        if ( !$Result ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => 'ImportDataSave: adding SLA <'
                    . $SLAData{Name}
                    . '> failed.',
            );
        }
    }

    #(3) if SLA DOES exists => update...
    if ( !$NewSLA ) {
        $Result = $Self->{SLAObject}->SLAUpdate(
            %SLAData,
            UserID => $Param{UserID},
        );

        if ( !$Result ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => 'ImportDataSave: updating SLA <'
                    . $SLAData{Name}
                    . '> (ID '
                    . $SLAData{SLAID}
                    . ') failed.',
            );
        }

    }

    #(4) set preferences...
    if ($SLAID) {
        for my $CurrKey ( keys(%Preferences) ) {
            next if ( !$NewSLAData{$CurrKey} );
            $Self->{SLAObject}->SLAPreferencesSet(
                SLAID  => $SLAID,
                Key    => $CurrKey,
                Value  => $NewSLAData{$CurrKey},
                UserID => $Param{UserID},
            );
        }
    }
    return $Result;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is a derivative part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION

$Revision: 1.10 $ $Date: 2011-11-29 10:28:57 $

=cut

 IyAtLQojIEtlcm5lbC9MYW5ndWFnZS9kZV9TZXJ2aWNlSW1wb3J0RXhwb3J0IC0gcHJvdmlkZXMgZ2VybWFuIGxhbmd1YWdlCiMgdHJhbnNsYXRpb24gZm9yIFNlcnZpY2VJbXBvcnRFeHBvcnQgbW9kdWxlCiMgQ29weXJpZ2h0IChDKSAyMDA2LTIwMTEgYy5hLnAuZS4gSVQgR21iSCwgaHR0cDovL3d3dy5jYXBlLWl0LmRlCiMKIwojIC0tCiMgJElkOiBkZV9TZXJ2aWNlSW1wb3J0RXhwb3J0LnBtLHYgMS4zIDIwMTEtMDMtMDggMTE6MTU6NTYgdHRvIEV4cCAkCiMgLS0KIyBUaGlzIHNvZnR3YXJlIGNvbWVzIHdpdGggQUJTT0xVVEVMWSBOTyBXQVJSQU5UWS4gRm9yIGRldGFpbHMsIHNlZQojIHRoZSBlbmNsb3NlZCBmaWxlIENPUFlJTkcgZm9yIGxpY2Vuc2UgaW5mb3JtYXRpb24gKEFHUEwpLiBJZiB5b3UKIyBkaWQgbm90IHJlY2VpdmUgdGhpcyBmaWxlLCBzZWUgaHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL2FncGwudHh0LgojIC0tCnBhY2thZ2UgS2VybmVsOjpMYW5ndWFnZTo6ZGVfU2VydmljZUltcG9ydEV4cG9ydDsKCnVzZSBzdHJpY3Q7CnVzZSB3YXJuaW5nczsKCnVzZSB2YXJzIHF3KCRWRVJTSU9OKTsKJFZFUlNJT04gPSAnJFJldmlzaW9uOiAxLjMgJCc7CiRWRVJTSU9OID1+IHMvXlwkLio6XFcoLiopXFcuKz8kLyQxLzsKCiMgLS0Kc3ViIERhdGEgewogICAgbXkgJFNlbGYgPSBzaGlmdDsKCiAgICBteSAkTGFuZyA9ICRTZWxmLT57VHJhbnNsYXRpb259OwoKICAgIHJldHVybiBpZiByZWYgJExhbmcgbmUgJ0hBU0gnOwoKICAgICMgJCRTVEFSVCQkCgogICAgIyB0cmFuc2xhdGlvbnMgbWlzc2luZyBpbiBJbXBvcnRFeHBvcnQuLi4KICAgICRMYW5nLT57J0NvbHVtbiBTZXBlcmF0b3InfSAgICAgICAgICAgPSAnU3BhbHRlbnRyZW5uZXInOwogICAgJExhbmctPnsnQ2hhcnNldCd9ICAgICAgICAgICAgICAgICAgICA9ICdaZWljaGVuc2F0eic7CiAgICAkTGFuZy0+eydSZXN0cmljdCBleHBvcnQgcGVyIHNlYXJjaCd9ID0gJ0V4cG9ydCBtaXR0ZWxzIFN1Y2hlIGVpbnNjaHLkbmtlbic7CgogICAgIyBzZXJ2aWNlMmN1c3RvbWVydXNlciBleC0vaW1wb3J0Li4uCiAgICAkTGFuZy0+eydTZXJ2aWNlIGF2YWlsYWJsZSBmb3IgQ1UnfSA9ICdTZXJ2aWNlIGb8ciBLdW5kZW5udXR6ZXIgdmVyZvxnYmFyJzsKICAgICRMYW5nLT57J0N1c3RvbWVyIFVzZXIgTG9naW4nfSAgICAgID0gJ0t1bmRlbm51dHplcmxvZ2luJzsKICAgICRMYW5nLT57J1ZhbGlkaXR5IG9mIHNlcnZpY2UgYXNzaWdubWVudCBmb3IgQ1UnfSA9CiAgICAgICAgJ0f8bHRpZ2tlaXQgZGVyIFNlcnZpY2V6dW9yZG51bmcgenUgS3VuZGVubnV0emVyJzsKCiAgICAjIHNlcnZpY2UgZXgtL2ltcG9ydC4uLgogICAgJExhbmctPnsnRnVsbCBTZXJ2aWNlIE5hbWUnfSAgICAgICAgICAgICAgICAgID0gJ1ZvbGxzdORuZGlnZXIgU2VydmljZW5hbWUnOwogICAgJExhbmctPnsnU2hvcnQgU2VydmljZSBOYW1lJ30gICAgICAgICAgICAgICAgID0gJ0t1cnpzZXJ2aWNlbmFtZSc7CiAgICAkTGFuZy0+eydTZXJ2aWNlIFR5cGUgKElUU00gb25seSknfSAgICAgICAgICAgPSAnU2VydmljZXR5cCAobnVyIElUU00pJzsKICAgICRMYW5nLT57J0NyaXRpY2FsaXR5IChJVFNNIG9ubHkpJ30gICAgICAgICAgICA9ICdLcml0aWthbGl05HQgKG51ciBJVFNNKSc7CiAgICAkTGFuZy0+eydDdXJyZW50IEluY2lkZW50IFN0YXRlIChJVFNNIG9ubHkpJ30gPSAnQWt0LiBTdPZydW5nc3N0YXR1cyAobnVyIElUU00pJzsKICAgICRMYW5nLT57J0N1cnJlbnQgSW5jaWRlbnQgU3RhdGUgVHlwZSAoSVRTTSBvbmx5KSd9CiAgICAgICAgPSAnQWt0LiBTdPZydW5nc3N0YXR1c3R5cCAobnVyIElUU00pJzsKICAgICRMYW5nLT57J0RlZmF1bHQgU2VydmljZSBUeXBlJ30gPSAnU3RhbmRhcmQtU2VydmljZXR5cCc7CiAgICAkTGFuZy0+eydWYWxpZGl0eSd9ICAgICAgICAgICAgID0gJ0f8bHRpZ2tlaXQnOwogICAgJExhbmctPnsnRGVmYXVsdCBWYWxpZGl0eSd9ICAgICA9ICdTdGFuZGFyZC1H/Gx0aWdrZWl0JzsKICAgICRMYW5nLT57J0RlZmF1bHQgQ3JpdGljYWxpdHknfSAgPSAnU3RhbmRhcmQtS3JpdGlrYWxpdOR0JzsKCiAgICAjIFNMQSBleC0vaW1wb3J0Li4uCiAgICAkTGFuZy0+eydEZWZhdWx0IFNMQSBUeXBlJ30gICAgICAgICAgICAgICAgICAgICAgID0gJ1N0YW5kYXJkLVNMQS1UeXAnOwogICAgJExhbmctPnsnRGVmYXVsdCBNaW5pbXVtIFRpbWUgQmV0d2VlbiBJbmNpZGVudHMnfSA9ICdTdGFuZGFyZCBNaW5pbXVtemVpdCB6d2lzY2hlbiBTdPZydW5nZW4nOwogICAgJExhbmctPnsnTWF4LiBudW1iZXIgb2YgY29sdW1ucyB3aGljaCBtYXkgY29udGFpbiBhc3NpZ25lZCBzZXJ2aWNlcyd9CiAgICAgICAgPSAnTWF4LiBBbnphaGwgdm9uIFNwYWx0ZW4gZGllIHp1Z2V3aWVzZW5lIFNlcnZpY2VzIGVudGhhbHRlbiBr9m5uZW4nOwogICAgJExhbmctPnsnTWF4LiBudW1iZXIgb2YgYXNzaWduZWQgc2VydmljZXMgY29sdW1ucyd9ID0gJ01heC4gU3BhbHRlbmFuemFobCB6dWdldy4gU2VydmljZXMnOwoKICAgICRMYW5nLT57J1NMQSBUeXBlIChJVFNNIG9ubHkpJ30gPSAnU0xBIFR5cCAobnVyIElUU00pJzsKICAgICRMYW5nLT57J01pbi4gVGltZSBCZXR3ZWVuIEluY2lkZW50cyAoSVRTTSBvbmx5KSd9CiAgICAgICAgPSAnU3RhbmRhcmQgTWluaW11bXplaXQgendpc2NoZW4gU3T2cnVuZ2VuIChudXIgSVRTTSknOwogICAgJExhbmctPnsnU29sdXRpb25Ob3RpZnkgKHBlcmNlbnQpJ30gICAgICAgID0gJ1NvbHV0aW9uTm90aWZ5IChQcm96ZW50KSc7CiAgICAkTGFuZy0+eydTb2x1dGlvblRpbWUgKGJ1c2luZXNzIG1pbnV0ZXMpJ30gPSAnU29sdXRpb25UaW1lIChHZXNjaORmdHNtaW51dGVuKSc7CiAgICAkTGFuZy0+eydVcGRhdGVOb3RpZnkgKHBlcmNlbnQpJ30gICAgICAgICAgPSAnVXBkYXRlTm90aWZ5IChQcm96ZW50KSc7CiAgICAkTGFuZy0+eydVcGRhdGVUaW1lIChidXNpbmVzcyBtaW51dGVzKSd9ICAgPSAnVXBkYXRlVGltZSAoR2VzY2jkZnRzbWludXRlbiknOwogICAgJExhbmctPnsnRmlyc3RSZXNwb25zZU5vdGlmeSAocGVyY2VudCknfSAgID0gJ0ZpcnN0UmVzcG9uc2VOb3RpZnkgKFByb3plbnQpJzsKICAgICRMYW5nLT57J0ZpcnN0UmVzcG9uc2VUaW1lIChidXNpbmVzcyBtaW51dGVzKSd9CiAgICAgICAgPSAnRmlyc3RSZXNwb25zZVRpbWUgKEdlc2No5GZ0c21pbnV0ZW4pJzsKICAgICRMYW5nLT57J0NhbGVuZGFyIE5hbWUnfSA9ICdLYWxlbmRlcm5hbWUnOwoKICAgICRMYW5nLT57J0V4cG9ydCB3aXRoIGxhYmVscyd9ID0gJ01pdCBCZXNjaHJpZnR1bmcgZXhwb3J0aWVyZW4nOwogICAgJExhbmctPnsnJ30gICAgICAgICAgICAgICAgICAgPSAnJzsKCiAgICByZXR1cm4gMDsKCiAgICAjICQkU1RPUCQkCn0KCiMgLS0KMTsK # --
# ServiceImportExport.pm - code run during package de-/installation
# Copyright (C) 2006-2011 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by:
#   Torsten(dot)Thau(at)cape-it.de
#   Martin(dot)Balzarek(at)cape-it.de
#
# --
# $Id: ServiceImportExport.pm,v 1.14 2011-11-29 10:28:57 tto Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (GPL). If you
# did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.
# --

package var::packagesetup::ServiceImportExport;

use strict;
use warnings;

use Kernel::Config;
use Kernel::System::SysConfig;
use Kernel::System::Log;
use Kernel::System::DB;
use Kernel::System::Main;
use Kernel::System::Encode;
use Kernel::System::ImportExport;
use Kernel::System::Service;
use Kernel::System::SLA;
use Kernel::System::Valid;
use Kernel::System::CSV;
use Kernel::System::ImportExport::ObjectBackend::SLA;
use Kernel::System::ImportExport::ObjectBackend::Service;
use Kernel::System::ImportExport::ObjectBackend::Service2CustomerUser;

use vars qw(@ISA $VERSION);
$VERSION = qw($Revision: 1.14 $) [1];

=head1 NAME

OTRS_CiCS.pm - code to excecute during package installation

=head1 SYNOPSIS

All functions

=head1 PUBLIC INTERFACE

=over 4

=cut

=item new()

create an object

    use Kernel::Config;
    use Kernel::System::Log;
    use Kernel::System::Main;
    use Kernel::System::Time;
    use Kernel::System::DB;
    use Kernel::System::XML;

    my $ConfigObject = Kernel::Config->new();
    my $LogObject    = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
    );
    my $MainObject = Kernel::System::Main->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
    );
    my $TimeObject = Kernel::System::Time->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
    );
    my $XMLObject = Kernel::System::XML->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        DBObject     => $DBObject,
        MainObject   => $MainObject,
    );
    my $CodeObject = var::packagesetup::OTRS-CiCS-ITSM.pm->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
        TimeObject   => $TimeObject,
        DBObject     => $DBObject,
        XMLObject    => $XMLObject,
    );

=cut

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

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

    #check required params...
    for my $Object (
        qw(ConfigObject LogObject MainObject TimeObject DBObject EncodeObject XMLObject)
        )
    {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }

    $Self->{ConfigItemObject}   = Kernel::System::SysConfig->new( %{$Self} );
    $Self->{ConfigObject}       = Kernel::Config->new();
    $Self->{LogObject}          = Kernel::System::Log->new( %{$Self} );
    $Self->{MainObject}         = Kernel::System::Main->new( %{$Self} );
    $Self->{EncodeObject}       = Kernel::System::Encode->new( %{$Self} );
    $Self->{DBObject}           = Kernel::System::DB->new( %{$Self} );
    $Self->{ImportExportObject} = Kernel::System::ImportExport->new( %{$Self} );
    $Self->{ValidObject}        = Kernel::System::Valid->new( %{$Self} );
    $Self->{ObjectBackendObject} =
        Kernel::System::ImportExport::ObjectBackend::SLA->new( %{$Self} );
    $Self->{ObjectBackendObject} =
        Kernel::System::ImportExport::ObjectBackend::Service->new( %{$Self} );
    $Self->{ObjectBackendObject} =
        Kernel::System::ImportExport::ObjectBackend::Service2CustomerUser->new( %{$Self} );

    return $Self;
}

=item CodeInstall()

run the code install part

    my $Result = $CodeObject->CodeInstall();

=cut

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

    $Self->_CreateMappings();

    return 1;
}

=item CodeReinstall()

run the code reinstall part

    my $Result = $CodeObject->CodeReinstall();

=cut

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

    $Self->_CreateMappings();

    return 1;
}

=item CodeUpgrade()

run the code upgrade part

    my $Result = $CodeObject->CodeUpgrade();

=cut

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

    return 1;
}

=item CodeUninstall()

run the code uninstall part

    my $Result = $CodeObject->CodeUninstall();

=cut

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

    $Self->_RemoveRelatedMappings();

    return 1;
}

sub _RemoveRelatedMappings () {

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

    my $TemplateList;
    my @TemplateObjects = ( 'Service', 'SLA', 'Service2CustomerUser' );
    my @TemplateObjectsSum;
    foreach my $TemplateObject (@TemplateObjects) {
        $TemplateList = $Self->{ImportExportObject}->TemplateList(
            Object => $TemplateObject,
            Format => 'CSV',
            UserID => 1,
        );
        @TemplateObjectsSum = ( @TemplateObjectsSum, @{$TemplateList} );
    }

    # delete the templates
    if ( ref($TemplateList) eq 'ARRAY' && @{$TemplateList} ) {
        $Self->{ImportExportObject}->TemplateDelete(
            TemplateID => \@TemplateObjectsSum,
            UserID     => 1,
        );
    }

    return 1;
}

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

    my $ImportExportMappingHash = undef;

    #---------------------------------------------------------------------------
    # SLA ...
    my %SLAPreferences     = ();
    my %SLAMappingPrefs    = ();
    my @SLAPreferencesKeys = qw{};
    my @MappingKeysSLA     = (
        'Name',              'Calendar',
        'Valid',             'Comment',
        'FirstResponseTime', 'FirstResponseNotify',
        'UpdateTime',        'UpdateNotify',
        'SolutionTime',      'SolutionNotify',
        'Type',              'MinTimeBetweenIncidents'
    );

    if ( $Self->{ConfigObject}->Get('SLAPreferences') ) {
        %SLAPreferences = %{ $Self->{ConfigObject}->Get('SLAPreferences') };
    }
    for my $Item ( sort keys %SLAPreferences ) {
        if (
            $SLAPreferences{$Item}->{SelectionSource}
            && $SLAPreferences{$Item}->{PrefKey} =~ /^(.+)ID$/
            )
        {
            my $NamePart = $1;
            $SLAMappingPrefs{$NamePart} = 1;
        }
        $SLAMappingPrefs{ $SLAPreferences{$Item}->{PrefKey} } = 1;
    }

    if ( keys(%SLAMappingPrefs) ) {
        @MappingKeysSLA = ( @MappingKeysSLA, keys(%SLAMappingPrefs) );
    }

    push( @MappingKeysSLA, 'AssignedService' );

    $ImportExportMappingHash->{SLA} = \@MappingKeysSLA;

    #---------------------------------------------------------------------------
    # Service ...
    my %ServicePreferences     = ();
    my %ServiceMappingPrefs    = ();
    my @ServicePreferencesKeys = qw{};
    my @MappingKeysService     = (
        'ServiceID', 'Name', 'NameShort',   'Valid',
        'Comment',   'Type', 'Criticality', 'CurInciState'
    );

    if ( $Self->{ConfigObject}->Get('ServicePreferences') ) {
        %ServicePreferences = %{ $Self->{ConfigObject}->Get('ServicePreferences') };
    }
    for my $Item ( sort keys %ServicePreferences ) {
        if (
            $ServicePreferences{$Item}->{SelectionSource}
            && $ServicePreferences{$Item}->{PrefKey} =~ /^(.+)ID$/
            )
        {
            my $NamePart = $1;
            $ServiceMappingPrefs{$NamePart} = 1;
        }
        $ServiceMappingPrefs{ $ServicePreferences{$Item}->{PrefKey} } = 1;
    }

    if ( keys(%ServiceMappingPrefs) ) {
        @MappingKeysService = ( @MappingKeysService, keys(%ServiceMappingPrefs) );
    }

    $ImportExportMappingHash->{Service} = \@MappingKeysService;

    #---------------------------------------------------------------------------
    # Service2CustomerUser ...
    $ImportExportMappingHash->{Service2CustomerUser} =
        [ 'CustomerUserLogin', 'ServiceName', 'ServiceID', 'AssignmentActive' ];

    #---------------------------------------------------------------------------
    # create mappings...
    for my $ObjectMappingKey ( keys %{$ImportExportMappingHash} ) {

        # add a template customer company
        my $TemplateID = $Self->{ImportExportObject}->TemplateAdd(
            Object  => $ObjectMappingKey,
            Format  => 'CSV',
            Name    => $ObjectMappingKey . ' (auto-created map)',
            Comment => 'Automatically created during ServiceImportExport installation',
            ValidID => 1,
            UserID  => 1,
        );
        if ( !$TemplateID ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Could not add mapping for object $ObjectMappingKey",
            );
            next;
        }

        my $ServiceMappingData = {
            SourceServiceData => {
                FormatData => {
                    ColumnSeparator => 'Semicolon',
                    Charset         => 'UTF-8',
                },
                ServiceDataGet => {
                    TemplateID => $TemplateID,
                    UserID     => 1,
                },
            },
        };

        # get object attributes
        my $ObjectAttributeList = $Self->{ImportExportObject}->ObjectAttributesGet(
            TemplateID => $ServiceMappingData->{SourceServiceData}->{ServiceDataGet}
                ->{TemplateID},
            UserID => 1,
        );

        my $AttributeValues;

        for my $Default ( @{$ObjectAttributeList} ) {

            # set sla types
            if (
                $ObjectMappingKey  eq 'SLA'
                && $Default->{Key} eq 'DefaultSLATypeID'
                )
            {
                if ( $Self->{MainObject}->Require('Kernel::System::GeneralCatalog') ) {
                    $Self->{GeneralCatalogObject} = Kernel::System::GeneralCatalog->new( %{$Self} );

                    if ( $Self->{GeneralCatalogObject} ) {

                        # get SLA type list
                        $Self->{SLATypeList} = $Self->{GeneralCatalogObject}->ItemList(
                            Class => 'ITSM::SLA::Type',
                        );

                        if ( $Self->{SLATypeList} && ref( $Self->{SLATypeList} ) eq 'HASH' ) {
                            my %TmpHash = reverse( %{ $Self->{SLATypeList} } );
                            $Self->{ReverseSLATypeList} = \%TmpHash;
                        }
                    }
                }
                my $SLATypeID;
                for my $ID ( keys %{ $Self->{SLATypeList} } ) {
                    $SLATypeID = $Self->{SLATypeList}->{$ID};
                    if ( $Self->{SLATypeList}->{$ID} eq 'Other' ) {
                        $SLATypeID = $ID;
                        last;
                    }
                }

                $AttributeValues->{ $Default->{Key} } = $SLATypeID;
                next;
            }

            # set service types
            if ( $ObjectMappingKey eq 'Service' ) {
                my $CriticalityID;
                my $ServiceTypeID;
                if ( $Self->{GeneralCatalogObject} ) {

                    # get service type list
                    $Self->{ServiceTypeList} = $Self->{GeneralCatalogObject}->ItemList(
                        Class => 'ITSM::Service::Type',
                    );

                    if ( $Self->{ServiceTypeList} && ( ref( $Self->{ServiceTypeList} ) eq 'HASH' ) )
                    {
                        my %TmpHash = reverse( %{ $Self->{ServiceTypeList} } );
                        $Self->{ReverseServiceTypeList} = \%TmpHash;
                    }

                    # get criticality list
                    $Self->{CriticalityList} = $Self->{GeneralCatalogObject}->ItemList(
                        Class => 'ITSM::Core::Criticality',
                    );

                    if ( $Self->{CriticalityList} && ( ref( $Self->{CriticalityList} ) eq 'HASH' ) )
                    {
                        my %TmpHash2 = reverse( %{ $Self->{CriticalityList} } );
                        $Self->{ReverseCriticalityList} = \%TmpHash2;
                    }
                }

                if ( $Default->{Key} eq 'DefaultCriticalityID' ) {
                    for my $ID ( keys %{ $Self->{CriticalityList} } ) {

                        if ( $Self->{CriticalityList}->{$ID} =~ /normal/ ) {
                            $CriticalityID = $ID;
                            last;
                        }
                    }

                    $AttributeValues->{ $Default->{Key} } = $CriticalityID;
                    next;
                }
                if ( $Default->{Key} eq 'DefaultServiceTypeID' ) {
                    for my $ID ( keys %{ $Self->{ServiceTypeList} } ) {
                        $ServiceTypeID = $Self->{ServiceTypeList}->{$ID};
                        if ( $Self->{ServiceTypeList}->{$ID} eq 'Other' ) {
                            $ServiceTypeID = $ID;
                            last;
                        }
                    }

                    $AttributeValues->{ $Default->{Key} } = $ServiceTypeID;
                    next;
                }
            }
            $AttributeValues->{ $Default->{Key} } = $Default->{Input}->{ValueDefault};
        }

        $ServiceMappingData->{SourceServiceData}->{ObjectData} = $AttributeValues;

        my $DefaultNumberOfAssignableServices =
            $ServiceMappingData->{SourceServiceData}->{ObjectData}
            ->{NumberOfAssignableServices};

        my $i = 0;
        my @MappingObjData;
        for my $Key ( @{ $ImportExportMappingHash->{$ObjectMappingKey} } ) {

            my %MappingObjectDataHash;
            $MappingObjectDataHash{Key} =
                $ImportExportMappingHash->{$ObjectMappingKey}->[$i];
            if ( $i == 0 ) {
                $MappingObjectDataHash{Identifier} = 1;
            }
            if ( $Key eq 'Valid' && !$AttributeValues->{DefaultValid} ) {
                next;
            }

            if ( $Key eq 'AssignedService' ) {
                for (
                    my $Count = 0;
                    $Count < $DefaultNumberOfAssignableServices;
                    $Count++
                    )
                {
                    my %MappingObjectDataHashLocal = ();
                    $MappingObjectDataHashLocal{Key} =
                        'AssignedService' . sprintf( '%03s', $Count );
                    push( @MappingObjData, \%MappingObjectDataHashLocal );
                }
            }
            else {
                push( @MappingObjData, \%MappingObjectDataHash );
            }

            $i++;
        }

        $ServiceMappingData->{SourceServiceData}->{MappingObjectData} =
            \@MappingObjData;

        if (
            !$ServiceMappingData
            || ref $ServiceMappingData ne 'HASH'
            )
        {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message =>
                    "No valid mapping list found for template id $TemplateID",
            );
            return;
        }

        # set the object data
        if (
            $ServiceMappingData->{SourceServiceData}->{ObjectData}
            && ref $ServiceMappingData->{SourceServiceData}->{ObjectData} eq 'HASH'
            && $ServiceMappingData->{SourceServiceData}->{ServiceDataGet}
            ->{TemplateID}
            )
        {

            # save object data
            $Self->{ImportExportObject}->ObjectDataSave(
                TemplateID =>
                    $ServiceMappingData->{SourceServiceData}->{ServiceDataGet}
                    ->{TemplateID},
                ObjectData =>
                    $ServiceMappingData->{SourceServiceData}->{ObjectData},
                UserID => 1,
            );
        }

        # set the format data
        if (
            $ServiceMappingData->{SourceServiceData}->{FormatData}
            && ref $ServiceMappingData->{SourceServiceData}->{FormatData} eq 'HASH'
            && $ServiceMappingData->{SourceServiceData}->{ServiceDataGet}
            ->{TemplateID}
            )
        {

            # save format data
            $Self->{ImportExportObject}->FormatDataSave(
                TemplateID =>
                    $ServiceMappingData->{SourceServiceData}->{ServiceDataGet}
                    ->{TemplateID},
                FormatData =>
                    $ServiceMappingData->{SourceServiceData}->{FormatData},
                UserID => 1,
            );
        }

        # set the mapping object data
        if (
            $ServiceMappingData->{SourceServiceData}->{ObjectData}

            #&& ref $ServiceMappingData->{MappingObjectData} eq 'ARRAY'
            && $ServiceMappingData->{SourceServiceData}->{ServiceDataGet}
            ->{TemplateID}
            )
        {

            # delete all existing mapping data
            $Self->{ImportExportObject}->MappingDelete(
                TemplateID =>
                    $ServiceMappingData->{SourceServiceData}->{ServiceDataGet}
                    ->{TemplateID},
                UserID => 1,
            );

            # add the mapping object rows

            for my $MappingObjectData (
                @{ $ServiceMappingData->{SourceServiceData}->{MappingObjectData} }
                )
            {

                # add a new mapping row
                my $MappingID = $Self->{ImportExportObject}->MappingAdd(
                    TemplateID =>
                        $ServiceMappingData->{SourceServiceData}->{ServiceDataGet}
                        ->{TemplateID},
                    UserID => 1,
                );

                # add the mapping object data
                $Self->{ImportExportObject}->MappingObjectDataSave(
                    MappingID         => $MappingID,
                    MappingObjectData => $MappingObjectData,
                    UserID            => 1,
                );
            }
        }
    }

    return 1;
}

1;

=back

=head1 TERMS AND CONDITIONS

This Software is part of the OTRS project (http://otrs.org/).

This software comes with ABSOLUTELY NO WARRANTY. For details, see
the enclosed file COPYING for license information (GPL). If you
did not receive this file, see http://www.gnu.org/licenses/gpl-2.0.txt.

=cut

=head1 VERSION
$Revision: 1.14 $ $Date: 2011-11-29 10:28:57 $
=cut
 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 IyAtLQojIEltcG9ydEV4cG9ydE9iamVjdFNlcnZpY2UudCAtIGFsbCBpbXBvcnQgZXhwb3J0IHRlc3RzIGZvciB0aGUgU2VydmljZSBvYmplY3QgYmFja2VuZAojIENvcHlyaWdodCAoQykgMjAwNi0yMDEwIGMuYS5wLmUuIElUIEdtYkgsIGh0dHA6Ly93d3cuY2FwZS1pdC5kZS8KIwojIHdyaXR0ZW4vZWRpdGVkIGJ5OgojICogVG9yc3Rlbihkb3QpVGhhdShhdCljYXBlKGRhc2gpaXQoZG90KWRlCiMKIyAtLQojICRJZDogSW1wb3J0RXhwb3J0T2JqZWN0U2VydmljZS50LHYgMS4xIDIwMTAtMDQtMTUgMDg6NTc6MTcgdHRvIEV4cCAkCiMgLS0KIyBUaGlzIHNvZnR3YXJlIGNvbWVzIHdpdGggQUJTT0xVVEVMWSBOTyBXQVJSQU5UWS4gRm9yIGRldGFpbHMsIHNlZQojIHRoZSBlbmNsb3NlZCBmaWxlIENPUFlJTkcgZm9yIGxpY2Vuc2UgaW5mb3JtYXRpb24gKEFHUEwpLiBJZiB5b3UKIyBkaWQgbm90IHJlY2VpdmUgdGhpcyBmaWxlLCBzZWUgaHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL2FncGwudHh0LgojIC0tCgp1c2Ugc3RyaWN0Owp1c2Ugd2FybmluZ3M7CnVzZSB1dGY4OwoKdXNlIHZhcnMgcXcoJFNlbGYpOwoKdXNlIERhdGE6OkR1bXBlcjsKdXNlIEtlcm5lbDo6U3lzdGVtOjpFbmNvZGU7CnVzZSBLZXJuZWw6OlN5c3RlbTo6R2VuZXJhbENhdGFsb2c7CnVzZSBLZXJuZWw6OlN5c3RlbTo6SW1wb3J0RXhwb3J0Owp1c2UgS2VybmVsOjpTeXN0ZW06OkltcG9ydEV4cG9ydDo6T2JqZWN0QmFja2VuZDo6U2VydmljZTsKdXNlIEtlcm5lbDo6U3lzdGVtOjpTZXJ2aWNlOwp1c2UgS2VybmVsOjpTeXN0ZW06OlhNTDsKCiRTZWxmLT57RW5jb2RlT2JqZWN0fSAgICAgICAgID0gS2VybmVsOjpTeXN0ZW06OkVuY29kZS0+bmV3KCAleyRTZWxmfSApOwokU2VsZi0+e0dlbmVyYWxDYXRhbG9nT2JqZWN0fSA9IEtlcm5lbDo6U3lzdGVtOjpHZW5lcmFsQ2F0YWxvZy0+bmV3KCAleyRTZWxmfSApOwokU2VsZi0+e0ltcG9ydEV4cG9ydE9iamVjdH0gICA9IEtlcm5lbDo6U3lzdGVtOjpJbXBvcnRFeHBvcnQtPm5ldyggJXskU2VsZn0gKTsKJFNlbGYtPntPYmplY3RCYWNrZW5kT2JqZWN0fSAgPSBLZXJuZWw6OlN5c3RlbTo6SW1wb3J0RXhwb3J0OjpPYmplY3RCYWNrZW5kOjpTZXJ2aWNlLT5uZXcoICV7JFNlbGZ9ICk7CiRTZWxmLT57U2VydmljZU9iamVjdH0gICAgICAgID0gS2VybmVsOjpTeXN0ZW06OlNlcnZpY2UtPm5ldyggJXskU2VsZn0gKTsgICAgCgojIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAjCiMgbWFrZSBwcmVwYXJhdGlvbnMKIyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gIwoKIyBhZGQgc29tZSB0ZXN0IHRlbXBsYXRlcyBmb3IgbGF0ZXIgY2hlY2tzCm15IEBUZW1wbGF0ZUlEczsKZm9yICggMSAuLiAzMCApIHsKCiAgICAjIGFkZCBhIHRlc3QgdGVtcGxhdGUgZm9yIGxhdGVyIGNoZWNrcwogICAgbXkgJFRlbXBsYXRlSUQgPSAkU2VsZi0+e0ltcG9ydEV4cG9ydE9iamVjdH0tPlRlbXBsYXRlQWRkKAogICAgICAgIE9iamVjdCAgPT4gJ1NlcnZpY2UnLAogICAgICAgIEZvcm1hdCAgPT4gJ1VuaXRUZXN0JyAuIGludCByYW5kIDFfMDAwXzAwMCwKICAgICAgICBOYW1lICAgID0+ICdVbml0VGVzdCcgLiBpbnQgcmFuZCAxXzAwMF8wMDAsCiAgICAgICAgVmFsaWRJRCA9PiAxLAogICAgICAgIFVzZXJJRCAgPT4gMSwKICAgICk7CgogICAgcHVzaCBAVGVtcGxhdGVJRHMsICRUZW1wbGF0ZUlEOwp9CgpteSAkVGVzdENvdW50ID0gMTsKCgojIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAjCiMgT2JqZWN0TGlzdCB0ZXN0IDEgKGNoZWNrIENTViBpdGVtKQojIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAjCgojIGdldCBvYmplY3QgbGlzdApteSAkT2JqZWN0TGlzdDEgPSAkU2VsZi0+e0ltcG9ydEV4cG9ydE9iamVjdH0tPk9iamVjdExpc3QoKTsKCiMgY2hlY2sgb2JqZWN0IGxpc3QKJFNlbGYtPlRydWUoCiAgICAkT2JqZWN0TGlzdDEgJiYgcmVmICRPYmplY3RMaXN0MSBlcSAnSEFTSCcgJiYgJE9iamVjdExpc3QxLT57U2VydmljZX0sCiAgICAiVGVzdCAkVGVzdENvdW50OiBPYmplY3RMaXN0KCkgLSBTZXJ2aWNlIGV4aXN0cyIsCik7CgokVGVzdENvdW50Kys7CgoKIyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gIwojIE9iamVjdEF0dHJpYnV0ZXNHZXQgdGVzdCAxIChjaGVjayBhdHRyaWJ1dGUgaGFzaCkKIyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gIwoKIwojCiMgVE8gRE8gCiMKIwoKCg== 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