OTRS-CiCS-CustomerCompanyService 1.0.0 c.a.p.e. IT GmbH http://www.cape-it.de/ GNU GENERAL PUBLIC LICENSE Version 2, June 1991 First production release. First test release. 2008-12-12 v0.1.0 New package CustomerCompanyService package. KundenFirmenService-Paket. 2.4.x WELCOME You are about to install OTRS-CiCS-CustomerCompanyService. REQUIRED OTRS PACKAGES <ul> <li>OTRS::CiCS 3.3.2 or OTRS::CiCS::ITSM 2.3.2 or higher</li> c.a.p.e. IT ...global consulting - individual solutions. WILLKOMMEN Sie sind im Begriff OTRS-CiCS-CustomerCompanyService zu installieren. BENOETIGTE OTRS-PAKETE <ul> <li>OTRS::CiCS 3.3.2 bzw. OTRS::CiCS::ITSM 2.3.2 oder hoeher</li> c.a.p.e. IT ...global consulting - individual solutions. OTRS-CiCS my $FunctionName = 'CodeInstall'; my $CodeModule = 'var::packagesetup::CustomerCompanyService'; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}, %Param) ) { $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::CustomerCompanyService'; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}, %Param) ) { $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::CustomerCompanyService'; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}, %Param) ) { $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::CustomerCompanyService'; if ( $Self->{MainObject}->Require($CodeModule) ) { my $CodeObject = $CodeModule->new( %{$Self} ); if ($CodeObject) { if ( !$CodeObject->$FunctionName(%{$Self}, %Param) ) { $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." ); } } 2010-10-14 13:33:21 cvs.intra.cape-it.de IyAtLQojIENIQU5HRVNfQ3VzdG9tZXJDb21wYW55U2VydmljZSAtIGNoYW5nZSBsb2cgb2YgQ3VzdG9tZXJTZXJ2aWNlIG1vZHVsZQojIENvcHlyaWdodCAoQykgMjAwNi0yMDEwIGMuYS5wLmUuIElUIEdtYkgsIGh0dHA6Ly93d3cuY2FwZS1pdC5kZS8KIyAtLQojICRJZDogQ0hBTkdFU19DdXN0b21lckNvbXBhbnlTZXJ2aWNlLHYgMS4zIDIwMTAtMTAtMTQgMTE6MzI6NTAgcmJvIEV4cCAkCiMgLS0KIyBUaGlzIHNvZnR3YXJlIGNvbWVzIHdpdGggQUJTT0xVVEVMWSBOTyBXQVJSQU5UWS4gRm9yIGRldGFpbHMsIHNlZQojIHRoZSBlbmNsb3NlZCBmaWxlIENPUFlJTkcgZm9yIGxpY2Vuc2UgaW5mb3JtYXRpb24gKEdQTCkuIElmIHlvdQojIGRpZCBub3QgcmVjZWl2ZSB0aGlzIGZpbGUsIHNlZSBodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvZ3BsLTIuMC50eHQuCiMgLS0KCiMtLS0tLS0tLS0tLS0tLS0tLS0tLSAxLjAuMCAtLS0tLS0tLSAoMjAxMC8xMC8xNCkgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIyAqIGZpcnN0IHByb2R1Y3Rpb24gcmVsZWFzZQojICogKDIwMTAvMTAvMTQpIC0gYnVnZml4ZWQgaW5zdGFsbGF0aW9uIHByb2NlZHVyZSBhbmQgaW1wbGVtZW50ZWQgSVRTTSBjaGVjawojICogKDIwMTAvMTAvMTQpIC0gYWRkZWQgdHJhbnNsYXRpb25zCiAgCgojLS0tLS0tLS0tLS0tLS0tLS0tLS0gMC4wLjEgLS0tLS0tLS0gKDIwMTAvMTAvMTIpIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiMgKiBmaXJzdCB0ZXN0IHJlbGVhc2UgIAoK PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iaXNvLTg4NTktMSI/Pgo8b3Ryc19jb25maWcgdmVyc2lvbj0iMS4wIiBpbml0PSJBcHBsaWNhdGlvbiI+CiAgICA8Q1ZTPiRJZDogQ3VzdG9tZXJDb21wYW55U2VydmljZS54bWwsdiAxLjEgMjAxMC0xMC0wNyAxNjoxNTo1OSByYm8gRXhwICQ8L0NWUz4KICAgIAogICAgPENvbmZpZ0l0ZW0gTmFtZT0iRnJvbnRlbmQ6Ok1vZHVsZSMjI0FkbWluQ3VzdG9tZXJDb21wYW55U2VydmljZSIgUmVxdWlyZWQ9IjAiIFZhbGlkPSIxIj4KICAgICAgICA8RGVzY3JpcHRpb24gTGFuZz0iZW4iPkZyb250ZW5kIG1vZHVsZSByZWdpc3RyYXRpb24gZm9yIHRoZSBBZG1pbkN1c3RvbWVyQ29tcGFueVNlcnZpY2Ugb2JqZWN0IGluIHRoZSBhZG1pbiBhcmVhLjwvRGVzY3JpcHRpb24+CiAgICAgICAgPERlc2NyaXB0aW9uIExhbmc9ImRlIj5Gcm9udGVuZG1vZHVsLVJlZ2lzdHJhdGlvbiBkZXMgQWRtaW5DdXN0b21lckNvbXBhbnlTZXJ2aWNlLU9iamVrdHMgaW0gQWRtaW4tQmVyZWljaC48L0Rlc2NyaXB0aW9uPgogICAgICAgIDxHcm91cD5GcmFtZXdvcms8L0dyb3VwPgogICAgICAgIDxTdWJHcm91cD5Gcm9udGVuZDo6QWRtaW46Ok1vZHVsZVJlZ2lzdHJhdGlvbjwvU3ViR3JvdXA+CiAgICAgICAgPFNldHRpbmc+CiAgICAgICAgICAgIDxGcm9udGVuZE1vZHVsZVJlZz4KICAgICAgICAgICAgICAgIDxHcm91cD5hZG1pbjwvR3JvdXA+CiAgICAgICAgICAgICAgICA8RGVzY3JpcHRpb24+QWRtaW48L0Rlc2NyaXB0aW9uPgogICAgICAgICAgICAgICAgPFRpdGxlPkN1c3RvbWVyIENvbXBhbnkgJmx0Oy0mZ3Q7IFNlcnZpY2VzPC9UaXRsZT4KICAgICAgICAgICAgICAgIDxOYXZCYXJOYW1lPkFkbWluPC9OYXZCYXJOYW1lPgogICAgICAgICAgICAgICAgPE5hdkJhck1vZHVsZT4KICAgICAgICAgICAgICAgICAgICA8TW9kdWxlPktlcm5lbDo6T3V0cHV0OjpIVE1MOjpOYXZCYXJNb2R1bGVBZG1pbjwvTW9kdWxlPgogICAgICAgICAgICAgICAgICAgIDxOYW1lPkN1c3RvbWVyIENvbXBhbnkgJmx0Oy0mZ3Q7IFNlcnZpY2VzPC9OYW1lPgogICAgICAgICAgICAgICAgICAgIDxCbG9jaz5CbG9jazE8L0Jsb2NrPgogICAgICAgICAgICAgICAgICAgIDxQcmlvPjMxNTwvUHJpbz4KICAgICAgICAgICAgICAgIDwvTmF2QmFyTW9kdWxlPgogICAgICAgICAgICA8L0Zyb250ZW5kTW9kdWxlUmVnPgogICAgICAgIDwvU2V0dGluZz4KICAgIDwvQ29uZmlnSXRlbT4KICAgIAo8L290cnNfY29uZmlnPgogICAg IyAtLQojIEtlcm5lbC9MYW5ndWFnZS9kZV9DdXN0b21lckNvbXBhbnlTZXJ2aWNlLnBtIC0gcHJvdmlkZXMgZ2VybWFuIGxhbmd1YWdlIHRyYW5zbGF0aW9uIGZvciBDdXN0b21lckNvbXBhbnlTZXJ2aWNlCiMKIyBDb3B5cmlnaHQgKEMpIDIwMDYtMjAxMCBjLmEucC5lLiBJVCBHbWJILCBodHRwOi8vd3d3LmNhcGUtaXQuZGUKIyAtLQojICRJZDogZGVfQ3VzdG9tZXJDb21wYW55U2VydmljZS5wbSx2IDEuMSAyMDEwLTEwLTE0IDExOjMxOjQ0IHJibyBFeHAgJAojIC0tCiMgVGhpcyBzb2Z0d2FyZSBjb21lcyB3aXRoIEFCU09MVVRFTFkgTk8gV0FSUkFOVFkuIEZvciBkZXRhaWxzLCBzZWUKIyB0aGUgZW5jbG9zZWQgZmlsZSBDT1BZSU5HIGZvciBsaWNlbnNlIGluZm9ybWF0aW9uIChHUEwpLiBJZiB5b3UKIyBkaWQgbm90IHJlY2VpdmUgdGhpcyBmaWxlLCBzZWUgaHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzL2dwbC0yLjAudHh0LgojIC0tCnBhY2thZ2UgS2VybmVsOjpMYW5ndWFnZTo6ZGVfQ3VzdG9tZXJDb21wYW55U2VydmljZTsKCnVzZSBzdHJpY3Q7Cgp1c2UgdmFycyBxdygkVkVSU0lPTik7CiRWRVJTSU9OID0gJyRSZXZpc2lvbjogMS4xICQnOwokVkVSU0lPTiA9fiBzL15cJC4qOlxXKC4qKVxXLis/JC8kMS87CgojIC0tCnN1YiBEYXRhIHsKICAgIG15ICRTZWxmICA9IHNoaWZ0OwogICAgbXkgJVBhcmFtID0gQF87CgogICAgJFNlbGYtPntUcmFuc2xhdGlvbn0tPnsnQ3VzdG9tZXIgQ29tcGFueSA8LT4gU2VydmljZXMnfSA9ICdLdW5kZW4tRmlybWEgPC0+IFNlcnZpY2VzJzsKICAgICRTZWxmLT57VHJhbnNsYXRpb259LT57J0N1c3RvbWVyIENvbXBhbnkgPC0+IFNlcnZpY2VzIE1hbmFnZW1lbnQnfSA9CiAgICAgICAgJ0t1bmRlbi1GaXJtYSA8LT4gU2VydmljZXMgVmVyd2FsdHVuZyc7CiAgICAkU2VsZi0+e1RyYW5zbGF0aW9ufS0+eydBbGxvY2F0ZSBzZXJ2aWNlcyB0byBDdXN0b21lciBDb21wYW55J30gPQogICAgICAgICdTZXJ2aWNlcyB6dW9yZG5lbiB6dXIgS3VuZGVuLUZpcm1hJzsKICAgICRTZWxmLT57VHJhbnNsYXRpb259LT57J0FsbG9jYXRlIEN1c3RvbWVyIENvbXBhbnkgdG8gU2VydmljZSd9ID0KICAgICAgICAnS3VuZGVuLUZpcm1hIHp1b3JkbmVuIHp1IFNlcnZpY2UnOwp9CgojIC0tCjE7Cg== # --
# Kernel/Modules/AdminCustomerCompanyService.pm - to add/update/delete customers <-> services
# original Copyright (C) 2001-2009 OTRS AG, http://otrs.org/
#
# Extensions Copyright (C) 2006-2010 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by:
#   Rene(dot)Boehm(at)cape-it.de
#
# --
# $Id: AdminCustomerCompanyService.pm,v 1.1 2010-10-07 16:15:59 rbo Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --

package Kernel::Modules::AdminCustomerCompanyService;

use strict;
use warnings;

# capeIT
use Kernel::System::CustomerCompany;

# EO capeIT
use Kernel::System::Service;
use Kernel::System::Valid;

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

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

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

    # check all needed objects
    for (qw(ParamObject DBObject LayoutObject ConfigObject LogObject)) {
        if ( !$Self->{$_} ) {
            $Self->{LayoutObject}->FatalError( Message => "Got no $_!" );
        }
    }

    # capeIT
    $Self->{CustomerCompanyObject} = Kernel::System::CustomerCompany->new(%Param);

    # EO capeIT
    $Self->{ServiceObject} = Kernel::System::Service->new(%Param);
    $Self->{ValidObject}   = Kernel::System::Valid->new(%Param);

    return $Self;
}

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

    # set search limit
    my $SearchLimit = 200;

    # ------------------------------------------------------------ #
    # allocate customer user
    # ------------------------------------------------------------ #
    # capeIT
    if ( $Self->{Subaction} eq 'AllocateCustomerCompany' ) {

        # get params
        $Param{CustomerID} = $Self->{ParamObject}->GetParam( Param => 'CustomerID' )
            || '<DEFAULT>';
        $Param{CustomerCompanySearch} =
            $Self->{ParamObject}->GetParam( Param => 'CustomerCompanySearch' )
            || '*';

        # EO capeIT
        $Param{ServiceSearch} = $Self->{ParamObject}->GetParam( Param => 'ServiceSearch' ) || '*';

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

        # output search block
        $Self->{LayoutObject}->Block(
            Name => 'Search',
            Data => {
                %Param,

                # capeIT
                CustomerCompanySearch => $Param{CustomerCompanySearch},

                # EO capeIT
                ServiceSearch => $Param{ServiceSearch},
            },
        );

        # output default block
        $Self->{LayoutObject}->Block( Name => 'Default', );

        # get service member
        # capeIT
        my %ServiceMemberList = $Self->{ServiceObject}->CustomerCompanyServiceMemberList(
            CustomerID      => $Param{CustomerID},
            Result          => 'HASH',
            DefaultServices => 0,
        );

        # EO capeIT

        # search services
        my @ServiceList = $Self->{ServiceObject}->ServiceSearch(
            Name   => $Param{ServiceSearch},
            Limit  => $SearchLimit + 1,
            UserID => $Self->{UserID},
        );

        # set max count
        my $MaxCount = @ServiceList;
        if ( $MaxCount > $SearchLimit ) {
            $MaxCount = $SearchLimit;
        }

        # capeIT
        # output allocate block
        $Self->{LayoutObject}->Block(
            Name => 'AllocateCustomerCompany',
            Data => {
                CustomerCompany => $Param{CustomerCompanyLogin},
                ServiceCount => @ServiceList || 0,
                %Param,
            },
        );

        # output count block
        if ( !@ServiceList ) {
            $Self->{LayoutObject}->Block(
                Name => 'AllocateCustomerCompanyServiceCountLimit',
                Data => { ServiceCount => 0, },
            );
        }
        elsif ( @ServiceList > $SearchLimit ) {
            $Self->{LayoutObject}->Block(
                Name => 'AllocateCustomerCompanyServiceCountLimit',
                Data => { ServiceCount => ">" . $SearchLimit, },
            );
        }
        else {
            $Self->{LayoutObject}->Block(
                Name => 'AllocateCustomerCompanyServiceCount',
                Data => { ServiceCount => scalar @ServiceList, },
            );
        }

        # EO capeIT

        my $Css;

        # output rows
        for my $Counter ( 1 .. $MaxCount ) {

            # set output class
            $Css = $Css && $Css eq 'searchactive' ? 'searchpassive' : 'searchactive';

            # get service
            my %Service = $Self->{ServiceObject}->ServiceGet(
                ServiceID => $ServiceList[ $Counter - 1 ],
                UserID    => $Self->{UserID},
            );

            # set checked
            my $Checked = $ServiceMemberList{ $Service{ServiceID} } ? 'checked' : '';

            # capeIT
            # output row block
            $Self->{LayoutObject}->Block(
                Name => 'AllocateCustomerCompanyRow',
                Data => {
                    Service   => $Service{Name},
                    ServiceID => $Service{ServiceID},
                    Checked   => $Checked,
                    CssClass  => $Css,
                },
            );

            # EO capeIT
        }

        # generate output
        # capeIT
        $Output .= $Self->{LayoutObject}->Output(
            TemplateFile => 'AdminCustomerCompanyService',
            Data         => \%Param,
        );

        # EO capeIT
        $Output .= $Self->{LayoutObject}->Footer();

        return $Output;
    }

    # ------------------------------------------------------------ #
    # allocate service
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'AllocateService' ) {

        # capeIT
        # get params
        $Param{ServiceID} = $Self->{ParamObject}->GetParam( Param => "ServiceID" );
        $Param{CustomerCompanySearch} =
            $Self->{ParamObject}->GetParam( Param => "CustomerCompanySearch" )
            || '*';

        # EO capeIT
        $Param{ServiceSearch} = $Self->{ParamObject}->GetParam( Param => "ServiceSearch" ) || '*';

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

        # capeIT
        # output search block
        $Self->{LayoutObject}->Block(
            Name => 'Search',
            Data => {
                %Param,
                CustomerCompanySearch => $Param{CustomerCompanySearch},
                ServiceSearch         => $Param{ServiceSearch},
            },
        );

        # EO capeIT

        # output default block
        $Self->{LayoutObject}->Block( Name => 'Default', );

        # get service
        my %Service = $Self->{ServiceObject}->ServiceGet(
            ServiceID => $Param{ServiceID},
            UserID    => $Self->{UserID},
        );

        # capeIT
        # get customer company member
        my %CustomerCompanyMemberList = $Self->{ServiceObject}->CustomerCompanyServiceMemberList(
            ServiceID       => $Param{ServiceID},
            Result          => 'HASH',
            DefaultServices => 0,
        );

        # search customer company
        my %CustomerCompanyList
            = $Self->{CustomerCompanyObject}
            ->CustomerCompanyList( Search => $Param{CustomerCompanySearch}, );
        my @CustomerCompanyKeyList
            = sort { $CustomerCompanyList{$a} cmp $CustomerCompanyList{$b} }
            keys %CustomerCompanyList;

        # set max count
        my $MaxCount = @CustomerCompanyKeyList;
        if ( $MaxCount > $SearchLimit ) {
            $MaxCount = $SearchLimit;
        }

        # output allocate block
        $Self->{LayoutObject}->Block(
            Name => 'AllocateService',
            Data => {
                Service => $Service{Name},
                CustomerCompanyCount => @CustomerCompanyKeyList || 0,
                %Param,
            },
        );

        # output count block
        if ( !@CustomerCompanyKeyList ) {
            $Self->{LayoutObject}->Block(
                Name => 'AllocateServiceCustomerCompanyCountLimit',
                Data => { CustomerCompanyCount => 0, },
            );
        }
        elsif ( @CustomerCompanyKeyList > $SearchLimit ) {
            $Self->{LayoutObject}->Block(
                Name => 'AllocateServiceCustomerCompanyCountLimit',
                Data => { CustomerCompanyCount => ">" . $SearchLimit, },
            );
        }
        else {
            $Self->{LayoutObject}->Block(
                Name => 'AllocateServiceCustomerCompanyCount',
                Data => { CustomerCompanyCount => scalar @CustomerCompanyKeyList, },
            );
        }

        # EO capeIT

        # output rows
        my $Css;
        for my $Counter ( 1 .. $MaxCount ) {

            # set output class
            $Css = $Css && $Css eq 'searchactive' ? 'searchpassive' : 'searchactive';

            # capeIT
            # set checked
            my $Checked
                = $CustomerCompanyMemberList{ $CustomerCompanyKeyList[ $Counter - 1 ] }
                ? 'checked'
                : '';

            # output row block
            $Self->{LayoutObject}->Block(
                Name => 'AllocateServiceRow',
                Data => {
                    CustomerCompanyLogin => $CustomerCompanyKeyList[ $Counter - 1 ],
                    CustomerCompany =>
                        $CustomerCompanyList{ $CustomerCompanyKeyList[ $Counter - 1 ] },
                    Checked  => $Checked,
                    CssClass => $Css,
                },
            );
        }

        # generate output
        $Output .= $Self->{LayoutObject}->Output(
            TemplateFile => 'AdminCustomerCompanyService',
            Data         => \%Param,
        );

        # EO capeIT
        $Output .= $Self->{LayoutObject}->Footer();

        return $Output;
    }

    # ------------------------------------------------------------ #
    # allocate customer user save
    # ------------------------------------------------------------ #
    elsif ( $Self->{Subaction} eq 'AllocateCustomerCompanySave' ) {

        # capeIT
        # get params
        $Param{CustomerID} = $Self->{ParamObject}->GetParam( Param => 'CustomerID' );
        $Param{CustomerCompanySearch} =
            $Self->{ParamObject}->GetParam( Param => 'CustomerCompanySearch' )
            || '*';

        # EO capeIT
        $Param{ServiceSearch} = $Self->{ParamObject}->GetParam( Param => 'ServiceSearch' ) || '*';
        my @ServiceIDsSelected = $Self->{ParamObject}->GetArray( Param => 'ServiceIDsSelected' );
        my @ServiceIDsAll      = $Self->{ParamObject}->GetArray( Param => 'ServiceIDsAll' );

        # create hash with selected ids
        my %ServiceIDSelected = map { $_ => 1 } @ServiceIDsSelected;

        # check all used service ids
        for my $ServiceID (@ServiceIDsAll) {
            my $Active = $ServiceIDSelected{$ServiceID} ? 1 : 0;

            # capeIT
            # set customer company service member
            $Self->{ServiceObject}->CustomerCompanyServiceMemberAdd(
                CustomerID => $Param{CustomerID},
                ServiceID  => $ServiceID,
                Active     => $Active,
                UserID     => $Self->{UserID},
            );
        }

        # redirect to overview
        return $Self->{LayoutObject}->Redirect(
            OP =>
                "Action=$Self->{Action}&CustomerCompanySearch=$Param{CustomerCompanySearch}&ServiceSearch=$Param{ServiceSearch}"
        );

        # EO capeIT
    }

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

        # capeIT
        # get params
        $Param{ServiceID} = $Self->{ParamObject}->GetParam( Param => 'ServiceID' );
        $Param{CustomerCompanySearch} =
            $Self->{ParamObject}->GetParam( Param => 'CustomerCompanySearch' )
            || '*';

        # EO capeIT
        $Param{ServiceSearch} = $Self->{ParamObject}->GetParam( Param => 'ServiceSearch' ) || '*';

        # capeIT
        my @CustomerIDsSelected
            = $Self->{ParamObject}->GetArray( Param => 'CustomerIDsSelected' );
        my @CustomerIDsAll
            = $Self->{ParamObject}->GetArray( Param => 'CustomerIDsAll' );

        # create hash with selected customer companies
        my %CustomerIDsSelected;
        for my $CustomerID (@CustomerIDsSelected) {
            $CustomerIDsSelected{$CustomerID} = 1;
        }

        # check all used customer companies
        for my $CustomerID (@CustomerIDsAll) {
            my $Active = $CustomerIDsSelected{$CustomerID} ? 1 : 0;

            # set customer company service member
            $Self->{ServiceObject}->CustomerCompanyServiceMemberAdd(
                CustomerID => $CustomerID,
                ServiceID  => $Param{ServiceID},
                Active     => $Active,
                UserID     => $Self->{UserID},
            );
        }

        # redirect to overview
        return $Self->{LayoutObject}->Redirect(
            OP =>
                "Action=$Self->{Action}&CustomerCompanySearch=$Param{CustomerCompanySearch}&ServiceSearch=$Param{ServiceSearch}"
        );

        # EO capeIT
    }

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

        # capeIT
        # get params
        $Param{CustomerCompanySearch} =
            $Self->{ParamObject}->GetParam( Param => 'CustomerCompanySearch' )
            || '*';

        # EO capeIT
        $Param{ServiceSearch} = $Self->{ParamObject}->GetParam( Param => 'ServiceSearch' ) || '*';

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

        # capeIT
        # output search block
        $Self->{LayoutObject}->Block(
            Name => 'Search',
            Data => {
                %Param,
                CustomerCompanySearch => $Param{CustomerCompanySearch},
                ServiceSearch         => $Param{ServiceSearch},
            },
        );

        # EO capeIT

        # output default block
        $Self->{LayoutObject}->Block( Name => 'Default', );

        # capeIT
        # search customer company
        my %CustomerCompanyList
            = $Self->{CustomerCompanyObject}
            ->CustomerCompanyList( Search => $Param{CustomerCompanySearch}, );
        my @CustomerCompanyKeyList
            = sort { $CustomerCompanyList{$a} cmp $CustomerCompanyList{$b} }
            keys %CustomerCompanyList;

        # EO capeIT

        # search services
        my @ServiceList = $Self->{ServiceObject}->ServiceSearch(
            Name   => $Param{ServiceSearch},
            Limit  => $SearchLimit + 1,
            UserID => $Self->{UserID},
        );

        # capeIT
        # count results
        my $CustomerCompanyCount = @CustomerCompanyKeyList;

        # EO capeIT
        my $ServiceCount = @ServiceList;

        # capeIT
        # set max count
        my $MaxCount = $CustomerCompanyCount;

        # EO capeIT
        if ( $ServiceCount > $MaxCount ) {
            $MaxCount = $ServiceCount;
        }
        if ( $MaxCount > $SearchLimit ) {
            $MaxCount = $SearchLimit;
        }

        # capeIT
        # output result block
        $Self->{LayoutObject}->Block(
            Name => 'Result',
            Data => {
                %Param,
                CustomerCompanyCount => $CustomerCompanyCount,
                ServiceCount         => $ServiceCount,
            },
        );

        # output customer company count block
        if ( !@CustomerCompanyKeyList ) {
            $Self->{LayoutObject}->Block(
                Name => 'ResultCustomerCompanyCountLimit',
                Data => { CustomerCompanyCount => 0, },
            );
        }
        elsif ( @CustomerCompanyKeyList > $SearchLimit ) {
            $Self->{LayoutObject}->Block(
                Name => 'ResultCustomerCompanyCountLimit',
                Data => { CustomerCompanyCount => ">" . $SearchLimit, },
            );
        }
        else {
            $Self->{LayoutObject}->Block(
                Name => 'ResultCustomerCompanyCount',
                Data => { CustomerCompanyCount => scalar @CustomerCompanyKeyList, },
            );
        }

        # EO capeIT

        # output service count block
        if ( !@ServiceList ) {
            $Self->{LayoutObject}->Block(
                Name => 'ResultServiceCountLimit',
                Data => { ServiceCount => 0, },
            );
        }
        elsif ( @ServiceList > $SearchLimit ) {
            $Self->{LayoutObject}->Block(
                Name => 'ResultServiceCountLimit',
                Data => { ServiceCount => ">" . $SearchLimit, },
            );
        }
        else {
            $Self->{LayoutObject}->Block(
                Name => 'ResultServiceCount',
                Data => { ServiceCount => scalar @ServiceList, },
            );
        }

        # output rows
        my $Css = 'searchpassive';
        for my $Counter ( 1 .. $MaxCount ) {

            # set output class
            $Css = $Css eq 'searchactive' ? 'searchpassive' : 'searchactive';

            my %RowParam;

            # capeIT
            # set customer company row params
            if ( defined( $CustomerCompanyKeyList[ $Counter - 1 ] ) ) {
                $RowParam{CustomerID} = $CustomerCompanyKeyList[ $Counter - 1 ];
                $RowParam{CustomerCompany} =
                    $CustomerCompanyList{ $CustomerCompanyKeyList[ $Counter - 1 ] };
                $RowParam{CustomerCompanyCssClass} = $Css;
            }

            # EO capeIT

            # set service row params
            if ( $ServiceList[ $Counter - 1 ] ) {
                my %Service = $Self->{ServiceObject}->ServiceGet(
                    ServiceID => $ServiceList[ $Counter - 1 ],
                    UserID    => $Self->{UserID},
                );
                $RowParam{ServiceID}       = $Service{ServiceID};
                $RowParam{Service}         = $Service{Name};
                $RowParam{ServiceCssClass} = $Css;
            }

            # output row block
            $Self->{LayoutObject}->Block(
                Name => 'ResultRow',
                Data => { %Param, %RowParam, },
            );
        }

        # capeIT
        # generate output
        $Output .= $Self->{LayoutObject}->Output(
            TemplateFile => 'AdminCustomerCompanyService',
            Data         => \%Param,
        );

        # EO capeIT
        $Output .= $Self->{LayoutObject}->Footer();

        return $Output;
    }
}

1;
 # --
# AdminCustomerCompanyService.dtl - provides HTML form for AdminInterface
# original Copyright (C) 2001-2009 OTRS AG, http://otrs.org/
#
# Extensions Copyright (C) 2006-2010 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by:
#   Rene(dot)Boehm(at)cape-it.de
#
# --
# $Id: AdminCustomerCompanyService.dtl,v 1.2 2010-10-14 11:31:35 rbo Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --

<table border="0" width="100%" cellspacing="0" cellpadding="3">
  <tr>
    <td colspan="2" class="mainhead">
# capeIT    
      $Env{"Box0"}$Text{"Customer Company <-> Services Management"}$Env{"Box1"}
# EO capeIT
    </td>
  </tr>
  <tr>
    <td width="30%" class="mainbody">
<!-- dtl:block:Search -->
      <form action="$Env{"CGIHandle"}" method="post">
        <input type="hidden" name="Action" value="$Env{"Action"}"/>
        <table width="100%" cellspacing="0" cellpadding="4">
          <tr>
            <td class="contenthead">$Text{"Search"}:</td>
          </tr>
          <tr>
            <td class="contentbody">
              <table>
                <tr>
# capeIT
                  <td class="contentkey">$Text{"Search for"} $Text{"Customer Company"}:</td>
                  <td class="contentvalue"><input type="text" name="CustomerCompanySearch" value="$QData{"CustomerCompanySearch"}" size="20"/></td>
# EO capeIT
                </tr>
                <tr>
                  <td class="contentkey">$Text{"Search for"} $Text{"Service"}:</td>
                  <td class="contentvalue"><input type="text" name="ServiceSearch" value="$QData{"ServiceSearch"}" size="20"/></td>
                </tr>
              </table>
            </td>
          </tr>
          <tr>
            <td class="contentfooter">
              <input class="button" type="submit" value="$Text{"Search"}"/>
            </td>
          </tr>
        </table>
      </form>
<!-- dtl:block:Search -->
<!-- dtl:block:Default -->
      <br/>
      <form action="$Env{"CGIHandle"}" method="post">
        <input type="hidden" name="Action" value="$Env{"Action"}"/>
# capeIT
        <input type="hidden" name="Subaction" value="AllocateCustomerCompany"/>
# EO capeIT
        <table width="100%" cellspacing="0" cellpadding="4">
          <tr>
            <td class="contenthead">$Text{"Edit"}:</td>
          </tr>
          <tr>
            <td class="contentbody">
              $Text{"Edit default services."}
            </td>
          </tr>
          <tr>
            <td class="contentfooter">
              <input class="button" type="submit" value="$Text{"Edit"}"/>
            </td>
          </tr>
        </table>
      </form>
<!-- dtl:block:Default -->
    </td>
    <td width="70%" class="mainbody">
<!-- dtl:block:Result -->
      <table width="100%" cellspacing="0" cellpadding="4">
        <tr>
          <td class="contenthead">$Text{"Search Result"}:</td>
        </tr>
        <tr>
          <td class="contentbody">
            <table width="100%" border="0" cellspacing="0" cellpadding="3">
              <tr>
# capeIT
                <td class="contentkey" width="49%">$Text{"Customer Company"}
<!-- dtl:block:ResultCustomerCompanyCount -->
                  ($QData{"CustomerCompanyCount"})
<!-- dtl:block:ResultCustomerCompanyCount -->
<!-- dtl:block:ResultCustomerCompanyCountLimit -->
                  (<font color="red">$QData{"CustomerCompanyCount"}</font>)
<!-- dtl:block:ResultCustomerCompanyCountLimit -->
# EO capeIT
                </td>
                <td class="contentkey" width="1%"></td>
                <td class="contentkey" width="50%">$Text{"Service"}
<!-- dtl:block:ResultServiceCount -->
                  ($QData{"ServiceCount"})
<!-- dtl:block:ResultServiceCount -->
<!-- dtl:block:ResultServiceCountLimit -->
                  (<font color="red">$QData{"ServiceCount"}</font>)
<!-- dtl:block:ResultServiceCountLimit -->
                </td>
              </tr>
<!-- dtl:block:ResultRow -->
              <tr>
# capeIT
                <td class="$QData{"CustomerCompanyCssClass"}">
                  <a href="$Env{"Baselink"}Action=$Env{"Action"}&Subaction=AllocateCustomerCompany&CustomerID=$LQData{"CustomerID"}&CustomerCompanySearch=$LQData{"CustomerCompanySearch"}&ServiceSearch=$LQData{"ServiceSearch"}">$QData{"CustomerCompany"}</a>
# EO capeIT
                </td>
                <td></td>
                <td class="$QData{"ServiceCssClass"}">
# capeIT
                  <a href="$Env{"Baselink"}Action=$Env{"Action"}&Subaction=AllocateService&ServiceID=$LQData{"ServiceID"}&CustomerCompanySearch=$LQData{"CustomerCompanySearch"}&ServiceSearch=$LQData{"ServiceSearch"}">$QData{"Service"}</a>
# EO capeIT
                </td>
              </tr>
<!-- dtl:block:ResultRow -->
            </table>
          </td>
        </tr>
        <tr>
          <td class="contentfooter">
            &nbsp;
          </td>
        </tr>
      </table>
<!-- dtl:block:Result -->
# capeIT
<!-- dtl:block:AllocateCustomerCompany -->
      <form action="$Env{"CGIHandle"}" method="post">
        <input type="hidden" name="Action" value="$Env{"Action"}"/>
        <input type="hidden" name="Subaction" value="AllocateCustomerCompanySave"/>
        <input type="hidden" name="CustomerCompanySearch" value="$QData{"CustomerCompanySearch"}"/>
        <input type="hidden" name="ServiceSearch" value="$QData{"ServiceSearch"}"/>
        <input type="hidden" name="CustomerID" value="$QData{"CustomerID"}"/>
        <table width="100%" cellspacing="0" cellpadding="4">
          <tr>
            <td class="contenthead">$Text{"Allocate services to Customer Company"} "$QData{"CustomerID"}":</td>
# EO capeIT
          </tr>
          <tr>
            <td class="contentbody">
              <table width="100%" border="0" cellspacing="0" cellpadding="3">
                <tr>
                  <td class="contentkey">$Text{"Service"}
# capeIT
<!-- dtl:block:AllocateCustomerCompanyServiceCount -->
                    ($QData{"ServiceCount"})
<!-- dtl:block:AllocateCustomerCompanyServiceCount -->
<!-- dtl:block:AllocateCustomerCompanyServiceCountLimit -->
                    (<font color="red">$QData{"ServiceCount"}</font>)
<!-- dtl:block:AllocateCustomerCompanyServiceCountLimit -->
# EO capeIT
                  </td>
                  <td class="contentkey" width="100">$Text{"Active"}</td>
                </tr>
# capeIT
<!-- dtl:block:AllocateCustomerCompanyRow -->
# EO capeIT
                <tr>
                  <td class="$QData{"CssClass"}">
                    <a href="$Env{"Baselink"}Action=AdminService&Subaction=ServiceEdit&ServiceID=$QData{"ServiceID"}">
                    $QData{"Service"}
                    </a>
                  </td>
                  <td class="$QData{"CssClass"}">
                    <input type="checkbox" name="ServiceIDsSelected" value="$QData{"ServiceID"}" $QData{"Checked"}/>
                    <input type="hidden" name="ServiceIDsAll" value="$QData{"ServiceID"}"/>
                  </td>
                </tr>
# capeIT
<!-- dtl:block:AllocateCustomerCompanyRow -->
# EO capeIT
              </table>
            </td>
          </tr>
          <tr>
            <td class="contentfooter">
              <input class="button" type="submit" value="$Text{"Submit"}"/>
            </td>
          </tr>
        </table>
      </form>
# capeIT
<!-- dtl:block:AllocateCustomerCompany -->
# EO capeIT
<!-- dtl:block:AllocateService -->
      <form action="$Env{"CGIHandle"}" method="post">
        <input type="hidden" name="Action" value="$Env{"Action"}"/>
        <input type="hidden" name="Subaction" value="AllocateServiceSave"/>
# capeIT
        <input type="hidden" name="CustomerCompanySearch" value="$QData{"CustomerCompanySearch"}"/>
# EO capeIT
        <input type="hidden" name="ServiceSearch" value="$QData{"ServiceSearch"}"/>
        <input type="hidden" name="ServiceID" value="$QData{"ServiceID"}"/>
        <table width="100%" cellspacing="0" cellpadding="4">
          <tr>
# capeIT
            <td class="contenthead">$Text{"Allocate Customer Company to Service"} "$QData{"Service"}":</td>
# EO capeIT
          </tr>
          <tr>
            <td class="contentbody">
              <table width="100%" border="0" cellspacing="0" cellpadding="3">
                <tr>
# capeIT
                  <td class="contentkey">$Text{"Customer Company"}
<!-- dtl:block:AllocateServiceCustomerCompanyCount -->
                    ($QData{"CustomerCompanyCount"})
<!-- dtl:block:AllocateServiceCustomerCompanyCount -->
<!-- dtl:block:AllocateServiceCustomerCompanyCountLimit -->
                    (<font color="red">$QData{"CustomerCompanyCount"}</font>)
<!-- dtl:block:AllocateServiceCustomerCompanyCountLimit -->
# EO capeIT
                  </td>
                  <td class="contentkey" width="100">$Text{"Active"}</td>
                </tr>
<!-- dtl:block:AllocateServiceRow -->
                <tr>
                  <td class="$QData{"CssClass"}">
# capeIT
                    <a href="$Env{"Baselink"}Action=AdminCustomerCompany&Subaction=Change&ID=$LQData{"CustomerID"}">$QData{"CustomerCompany"}</a>
# EO capeIT
                  </td>
                  <td class="$QData{"CssClass"}">
# capeIT
                    <input type="checkbox" name="CustomerIDsSelected" value="$QData{"CustomerID"}" $QData{"Checked"}/>
                    <input type="hidden" name="CustomerIDsAll" value="$QData{"CustomerID"}"/>
# EO capeIT
                  </td>
                </tr>
<!-- dtl:block:AllocateServiceRow -->
              </table>
            </td>
          </tr>
          <tr>
            <td class="contentfooter">
              <input class="button" type="submit" value="$Text{"Submit"}"/>
            </td>
          </tr>
        </table>
      </form>
<!-- dtl:block:AllocateService -->
    </td>
  </tr>
</table>
 # --
# Kernel/System/Service.pm - all service function
# original Copyright (C) 2001-2009 OTRS AG, http://otrs.org/
#
# Extensions Copyright (C) 2006-2010 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by:
#   Rene(dot)Boehm(at)cape-it.de
#
# --
# $Id: Service.pm,v 1.1 2010-10-07 16:15:59 rbo Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --

package Kernel::System::Service;

use strict;
use warnings;

use Kernel::System::CheckItem;
use Kernel::System::Valid;

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

=head1 NAME

Kernel::System::Service - service lib

=head1 SYNOPSIS

All service functions.

=head1 PUBLIC INTERFACE

=over 4

=cut

=item new()

create an object

    use Kernel::Config;
    use Kernel::System::Encode;
    use Kernel::System::Log;
    use Kernel::System::Main;
    use Kernel::System::DB;
    use Kernel::System::Service;

    my $ConfigObject = Kernel::Config->new();
    my $EncodeObject = Kernel::System::Encode->new(
        ConfigObject => $ConfigObject,
    );
    my $LogObject = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
    );
    my $MainObject = Kernel::System::Main->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
        LogObject    => $LogObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
    );
    my $ServiceObject = Kernel::System::Service->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
        LogObject    => $LogObject,
        DBObject     => $DBObject,
        MainObject   => $MainObject,
    );

=cut

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

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

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

    # load generator preferences module
    my $GeneratorModule = $Self->{ConfigObject}->Get('Service::PreferencesModule')
        || 'Kernel::System::Service::PreferencesDB';
    if ( $Self->{MainObject}->Require($GeneratorModule) ) {
        $Self->{PreferencesObject} = $GeneratorModule->new(%Param);
    }

    return $Self;
}

=item ServiceList()

return a hash list of services

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

=cut

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

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

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

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

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

    return %ServiceList if !$Param{Valid};

    # get valid ids
    my @ValidIDs = $Self->{ValidObject}->ValidIDsGet();

    # duplicate service list
    my %ServiceListTmp = %ServiceList;

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

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

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

        next SERVICEID if $Valid;

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

    # delete invalid services and childs
    for my $ServiceID ( keys %ServiceList ) {

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

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

    return %ServiceList;
}

=item ServiceGet()

return a service as hash

Return
    $ServiceData{ServiceID}
    $ServiceData{ParentID}
    $ServiceData{Name}
    $ServiceData{NameShort}
    $ServiceData{ValidID}
    $ServiceData{Comment}
    $ServiceData{CreateTime}
    $ServiceData{CreateBy}
    $ServiceData{ChangeTime}
    $ServiceData{ChangeBy}

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

=cut

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

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

    # get service from db
    $Self->{DBObject}->Prepare(
        SQL =>
            'SELECT id, name, valid_id, comments, create_time, create_by, change_time, change_by '
            . 'FROM service WHERE id = ?',
        Bind  => [ \$Param{ServiceID} ],
        Limit => 1,
    );

    # fetch the result
    my %ServiceData;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        $ServiceData{ServiceID}  = $Row[0];
        $ServiceData{Name}       = $Row[1];
        $ServiceData{ValidID}    = $Row[2];
        $ServiceData{Comment}    = $Row[3] || '';
        $ServiceData{CreateTime} = $Row[4];
        $ServiceData{CreateBy}   = $Row[5];
        $ServiceData{ChangeTime} = $Row[6];
        $ServiceData{ChangeBy}   = $Row[7];
    }

    # check service
    if ( !$ServiceData{ServiceID} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No such ServiceID ($Param{ServiceID})!",
        );
        return;
    }

    # create short name and parentid
    $ServiceData{NameShort} = $ServiceData{Name};
    if ( $ServiceData{Name} =~ /^(.*)::(.+?)$/ ) {
        $ServiceData{NameShort} = $2;

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

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

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

    return %ServiceData;
}

=item ServiceLookup()

return a service name and id

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

    or

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

=cut

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

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

    if ( $Param{ServiceID} ) {

        # check cache
        my $CacheKey = 'Cache::ServiceLookup::ID::' . $Param{ServiceID};
        if ( defined $Self->{$CacheKey} ) {
            return $Self->{$CacheKey};
        }

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

        return $Self->{$CacheKey};
    }
    else {

        # check cache
        my $CacheKey = 'Cache::ServiceLookup::Name::' . $Param{Name};
        if ( defined $Self->{$CacheKey} ) {
            return $Self->{$CacheKey};
        }

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

        return $Self->{$CacheKey};
    }
}

=item ServiceAdd()

add a service

    my $ServiceID = $ServiceObject->ServiceAdd(
        Name     => 'Service Name',
        ParentID => 1,           # (optional)
        ValidID  => 1,
        Comment  => 'Comment',    # (optional)
        UserID   => 1,
    );

=cut

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

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

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

    # cleanup given params
    for my $Argument (qw(Name Comment)) {
        $Self->{CheckItemObject}->StringClean(
            StringRef         => \$Param{$Argument},
            RemoveAllNewlines => 1,
            RemoveAllTabs     => 1,
        );
    }

    # check service name
    if ( $Param{Name} =~ /::/ ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Can't add service! Invalid Service name '$Param{Name}'!",
        );
        return;
    }

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

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

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

    # add service to database
    if ($Exists) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Can\'t add service! Service with same name and parent already exists.'
        );
        return;
    }

    return if !$Self->{DBObject}->Do(
        SQL => 'INSERT INTO service '
            . '(name, valid_id, comments, create_time, create_by, change_time, change_by) '
            . 'VALUES (?, ?, ?, current_timestamp, ?, current_timestamp, ?)',
        Bind => [
            \$Param{FullName}, \$Param{ValidID}, \$Param{Comment},
            \$Param{UserID}, \$Param{UserID},
        ],
    );

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

    # reset cache
    delete $Self->{ 'Cache::ServiceLookup::ID::' . $ServiceID };
    delete $Self->{ 'Cache::ServiceLookup::Name::' . $Param{FullName} };

    return $ServiceID;
}

=item ServiceUpdate()

update a existing service

    my $True = $ServiceObject->ServiceUpdate(
        ServiceID => 123,
        ParentID  => 1,           # (optional)
        Name      => 'Service Name',
        ValidID   => 1,
        Comment   => 'Comment',    # (optional)
        UserID    => 1,
    );

=cut

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

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

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

    # cleanup given params
    for my $Argument (qw(Name Comment)) {
        $Self->{CheckItemObject}->StringClean(
            StringRef         => \$Param{$Argument},
            RemoveAllNewlines => 1,
            RemoveAllTabs     => 1,
        );
    }

    # check service name
    if ( $Param{Name} =~ /::/ ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Can't update service! Invalid Service name '$Param{Name}'!",
        );
        return;
    }

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

    # reset cache
    delete $Self->{ 'Cache::ServiceLookup::ID::' . $Param{ServiceID} };
    delete $Self->{ 'Cache::ServiceLookup::Name::' . $OldServiceName };

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

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

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

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

        # check, if selected parent was a child of this service
        if ( $Param{FullName} =~ /^(\Q$OldServiceName\E)::/ ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => 'Can\'t update service! Invalid parent was selected.'
            );
            return;
        }
    }

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

    # update service
    if ($Exists) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Can\'t update service! Service with same name and parent already exists.'
        );
        return;

    }

    # update service
    return if !$Self->{DBObject}->Do(
        SQL => 'UPDATE service SET name = ?, valid_id = ?, comments = ?, '
            . ' change_time = current_timestamp, change_by = ? WHERE id = ?',
        Bind => [
            \$Param{FullName}, \$Param{ValidID}, \$Param{Comment},
            \$Param{UserID}, \$Param{ServiceID},
        ],
    );

    # find all childs
    $Self->{DBObject}->Prepare(
        SQL => "SELECT id, name FROM service WHERE name LIKE '"
            . $Self->{DBObject}->Quote( $OldServiceName, 'Like' )
            . "::%'",
    );
    my @Childs;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        my %Child;
        $Child{ServiceID} = $Row[0];
        $Child{Name}      = $Row[1];
        push @Childs, \%Child;
    }

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

=item ServiceSearch()

return service ids as an array

    my @ServiceList = $ServiceObject->ServiceSearch(
        Name   => 'Service Name', # (optional)
        Limit  => 122,            # (optional) default 1000
        UserID => 1,
    );

=cut

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

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

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

    # create sql query
    my $SQL
        = "SELECT id FROM service WHERE valid_id IN ( ${\(join ', ', $Self->{ValidObject}->ValidIDsGet())} )";

    if ( $Param{Name} ) {

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

        # replace * with % and clean the string
        $Param{Name} =~ s{ \*+ }{%}xmsg;
        $Param{Name} =~ s{ %+ }{%}xmsg;

        $SQL .= " AND name LIKE '$Param{Name}' ";
    }

    $SQL .= ' ORDER BY name';

    # search service in db
    $Self->{DBObject}->Prepare( SQL => $SQL );

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

    return @ServiceList;
}

=item CustomerUserServiceMemberList()

returns a list of customeruser/service members

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

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

    Example (get services of customer user):

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

    Example (get customer user of service):

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

=cut

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

    # check needed stuff
    if ( !$Param{Result} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Result!',
        );
        return;
    }
    if ( !$Param{ServiceID} && !$Param{CustomerUserLogin} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need ServiceID or CustomerUserLogin!',
        );
        return;
    }

    # set default
    if ( !defined $Param{DefaultServices} ) {
        $Param{DefaultServices} = 1;
    }

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

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

    # check cache
    if ( $Param{ServiceID} || $Param{CustomerUserLogin} ) {
        if ( $Self->{ForceCache} ) {
            $Param{Cached} = $Self->{ForceCache};
        }
        if ( $Param{Cached} && $Self->{$CacheKey} ) {
            if ( ref( $Self->{$CacheKey} ) eq 'ARRAY' ) {
                return @{ $Self->{$CacheKey} };
            }
            elsif ( ref( $Self->{$CacheKey} ) eq 'HASH' ) {
                return %{ $Self->{$CacheKey} };
            }
        }
    }

    # sql
    my %Data;
    my @Name;
    my @ID;
    my $SQL = 'SELECT scu.service_id, scu.customer_user_login, s.name '
        . ' FROM '
        . ' service_customer_user scu, service s'
        . ' WHERE '
        . " s.valid_id IN ( ${\(join ', ', $Self->{ValidObject}->ValidIDsGet())} ) AND "
        . ' s.id = scu.service_id AND ';

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

    $Self->{DBObject}->Prepare( SQL => $SQL );

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

        my $Key   = '';
        my $Value = '';
        if ( $Param{ServiceID} ) {
            $Key   = $Row[1];
            $Value = $Row[0];
        }
        else {
            $Key   = $Row[0];
            $Value = $Row[2];
        }

        # remember permissions
        if ( !defined $Data{$Key} ) {
            $Data{$Key} = $Value;
            push @Name, $Value;
            push @ID,   $Key;
        }
    }
    if ( $Param{CustomerUserLogin} && $Param{DefaultServices} && !keys(%Data) ) {
        %Data = $Self->CustomerUserServiceMemberList(
            CustomerUserLogin => '<DEFAULT>',
            Result            => 'HASH',
            DefaultServices   => 0,
        );
        for my $Key ( keys %Data ) {
            push @Name, $Data{$Key};
            push @ID,   $Key;
        }
    }

    # return result
    if ( $Param{Result} && $Param{Result} eq 'ID' ) {
        if ( $Param{ServiceID} || $Param{CustomerUserLogin} ) {

            # cache result
            $Self->{$CacheKey} = \@ID;
        }
        return @ID;
    }
    if ( $Param{Result} && $Param{Result} eq 'Name' ) {
        if ( $Param{ServiceID} || $Param{CustomerUserLogin} ) {

            # cache result
            $Self->{$CacheKey} = \@Name;
        }
        return @Name;
    }
    else {
        if ( $Param{ServiceID} || $Param{CustomerUserLogin} ) {

            # cache result
            $Self->{$CacheKey} = \%Data;
        }
        return %Data;
    }
}

=item CustomerUserServiceMemberAdd()

to add a member to a service

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

=cut

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

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

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

    # return if relation is not active
    return if !$Param{Active};

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

# capeIT

=item CustomerCompanyServiceMemberList()

returns a list of CustomerCompany/service members

    ServiceID: service id
    CustomerID: customer ID
    DefaultServices: activate or deactivate default services

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

    Example (get services of customer user):

    $ServiceObject->CustomerCompanyServiceMemberList(
        CustomerID        => 'Test',
        Result            => 'HASH',
        DefaultServices   => 0,
    );

    Example (get customer company of service):

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

=cut

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

    # check needed stuff
    if ( !$Param{Result} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Result!',
        );
        return;
    }
    if ( !$Param{ServiceID} && !$Param{CustomerID} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need ServiceID or CustomerID!',
        );
        return;
    }

    # set default
    if ( !defined $Param{DefaultServices} ) {
        $Param{DefaultServices} = 1;
    }

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

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

    # check cache
    if ( $Param{ServiceID} || $Param{CustomerID} ) {
        if ( $Self->{ForceCache} ) {
            $Param{Cached} = $Self->{ForceCache};
        }
        if ( $Param{Cached} && $Self->{$CacheKey} ) {
            if ( ref( $Self->{$CacheKey} ) eq 'ARRAY' ) {
                return @{ $Self->{$CacheKey} };
            }
            elsif ( ref( $Self->{$CacheKey} ) eq 'HASH' ) {
                return %{ $Self->{$CacheKey} };
            }
        }
    }

    # sql
    my %Data;
    my @Name;
    my @ID;
    my $SQL = 'SELECT scc.service_id, scc.customer_id, s.name '
        . ' FROM '
        . ' service_customer_company scc, service s'
        . ' WHERE '
        . " s.valid_id IN ( ${\(join ', ', $Self->{ValidObject}->ValidIDsGet())} ) AND "
        . ' s.id = scc.service_id AND ';

    if ( $Param{ServiceID} ) {
        $SQL .= " scc.service_id = $Param{ServiceID}";
    }
    elsif ( $Param{CustomerID} ) {
        $SQL .= " scc.customer_id = '$Param{CustomerID}'";
    }

    $Self->{DBObject}->Prepare( SQL => $SQL );

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

        my $Key   = '';
        my $Value = '';
        if ( $Param{ServiceID} ) {
            $Key   = $Row[1];
            $Value = $Row[0];
        }
        else {
            $Key   = $Row[0];
            $Value = $Row[2];
        }

        # remember permissions
        if ( !defined $Data{$Key} ) {
            $Data{$Key} = $Value;
            push @Name, $Value;
            push @ID,   $Key;
        }
    }
    if ( $Param{CustomerID} && $Param{DefaultServices} && !keys(%Data) ) {
        %Data = $Self->CustomerCompanyServiceMemberList(
            CustomerID      => '<DEFAULT>',
            Result          => 'HASH',
            DefaultServices => 0,
        );
        for my $Key ( keys %Data ) {
            push @Name, $Data{$Key};
            push @ID,   $Key;
        }
    }

    # return result
    if ( $Param{Result} && $Param{Result} eq 'ID' ) {
        if ( $Param{ServiceID} || $Param{CustomerID} ) {

            # cache result
            $Self->{$CacheKey} = \@ID;
        }
        return @ID;
    }
    if ( $Param{Result} && $Param{Result} eq 'Name' ) {
        if ( $Param{ServiceID} || $Param{CustomerID} ) {

            # cache result
            $Self->{$CacheKey} = \@Name;
        }
        return @Name;
    }
    else {
        if ( $Param{ServiceID} || $Param{CustomerID} ) {

            # cache result
            $Self->{$CacheKey} = \%Data;
        }
        return %Data;
    }
}

=item CustomerCompanyServiceMemberAdd()

to add a member to a service

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

=cut

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

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

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

    # return if relation is not active
    return if !$Param{Active};

    # insert new relation
    return $Self->{DBObject}->Do(
        SQL => 'INSERT INTO service_customer_company '
            . '(customer_id, service_id, create_time, create_by) '
            . 'VALUES (?, ?, current_timestamp, ?)',
        Bind => [ \$Param{CustomerID}, \$Param{ServiceID}, \$Param{UserID} ]
    );
}

# EO capeIT

=item ServicePreferencesSet()

set queue preferences

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

=cut

sub ServicePreferencesSet {
    my $Self = shift;

    return $Self->{PreferencesObject}->ServicePreferencesSet(@_);
}

=item ServicePreferencesGet()

get queue preferences

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

=cut

sub ServicePreferencesGet {
    my $Self = shift;

    return $Self->{PreferencesObject}->ServicePreferencesGet(@_);
}

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 (AGPL). If you
did not receive this file, see http://www.gnu.org/licenses/agpl.txt.

=cut

=head1 VERSION

$Revision: 1.1 $ $Date: 2010-10-07 16:15:59 $

=cut
 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 # --
# Kernel/System/Service.pm - all service function
# original Copyright (C) 2001-2010 OTRS AG, http://otrs.org/
#
# Extensions Copyright (C) 2006-2010 c.a.p.e. IT GmbH, http://www.cape-it.de
#
# written/edited by:
#   Rene(dot)Boehm(at)cape-it.de
#
# --
# $Id: Service.pm,v 1.1 2010-10-07 16:15:59 rbo Exp $
# $OldId: Service.pm,v 1.39.2.1 2010/04/13 17:31:45 ub Exp $
# --
# This software comes with ABSOLUTELY NO WARRANTY. For details, see
# the enclosed file COPYING for license information (AGPL). If you
# did not receive this file, see http://www.gnu.org/licenses/agpl.txt.
# --

package Kernel::System::Service;

use strict;
use warnings;

use Kernel::System::CheckItem;
use Kernel::System::Valid;

# ---
# ITSM
# ---
use Kernel::System::GeneralCatalog;
use Kernel::System::LinkObject;
use Kernel::System::Time;

# ---

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

=head1 NAME

Kernel::System::Service - service lib

=head1 SYNOPSIS

All service functions.

=head1 PUBLIC INTERFACE

=over 4

=cut

=item new()

create an object

    use Kernel::Config;
    use Kernel::System::Encode;
    use Kernel::System::Log;
    use Kernel::System::Main;
    use Kernel::System::DB;
    use Kernel::System::Service;

    my $ConfigObject = Kernel::Config->new();
    my $EncodeObject = Kernel::System::Encode->new(
        ConfigObject => $ConfigObject,
    );
    my $LogObject = Kernel::System::Log->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
    );
    my $MainObject = Kernel::System::Main->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
        LogObject    => $LogObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
    );
    my $ServiceObject = Kernel::System::Service->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
        LogObject    => $LogObject,
        DBObject     => $DBObject,
        MainObject   => $MainObject,
    );

=cut

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

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

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

    # ---
    # ITSM
    # ---
    $Self->{TimeObject}           = Kernel::System::Time->new( %{$Self} );
    $Self->{GeneralCatalogObject} = Kernel::System::GeneralCatalog->new( %{$Self} );
    $Self->{LinkObject}           = Kernel::System::LinkObject->new( %{$Self} );

    # ---

    # load generator preferences module
    my $GeneratorModule = $Self->{ConfigObject}->Get('Service::PreferencesModule')
        || 'Kernel::System::Service::PreferencesDB';
    if ( $Self->{MainObject}->Require($GeneratorModule) ) {
        $Self->{PreferencesObject} = $GeneratorModule->new(%Param);
    }

    return $Self;
}

=item ServiceList()

return a hash list of services

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

=cut

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

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

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

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

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

    return %ServiceList if !$Param{Valid};

    # get valid ids
    my @ValidIDs = $Self->{ValidObject}->ValidIDsGet();

    # duplicate service list
    my %ServiceListTmp = %ServiceList;

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

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

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

        next SERVICEID if $Valid;

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

    # delete invalid services and childs
    for my $ServiceID ( keys %ServiceList ) {

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

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

    return %ServiceList;
}

=item ServiceGet()

return a service as hash

Return
    $ServiceData{ServiceID}
    $ServiceData{ParentID}
    $ServiceData{Name}
    $ServiceData{NameShort}
    $ServiceData{ValidID}
    $ServiceData{Comment}
    $ServiceData{CreateTime}
    $ServiceData{CreateBy}
    $ServiceData{ChangeTime}
    $ServiceData{ChangeBy}
# ---
# ITSM
# ---
    $ServiceData{TypeID}
    $ServiceData{Type}
    $ServiceData{CriticalityID}
    $ServiceData{Criticality}
    $ServiceData{CurInciStateID}
    $ServiceData{CurInciState}
    $ServiceData{CurInciStateType}
# ---

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

=cut

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

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

    # get service from db
    $Self->{DBObject}->Prepare(
        SQL =>
            'SELECT id, name, valid_id, comments, create_time, create_by, change_time, change_by '

            # ---
            # ITSM
            # ---
            . ", type_id, criticality_id "

            # ---
            . 'FROM service WHERE id = ?',
        Bind  => [ \$Param{ServiceID} ],
        Limit => 1,
    );

    # fetch the result
    my %ServiceData;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        $ServiceData{ServiceID}  = $Row[0];
        $ServiceData{Name}       = $Row[1];
        $ServiceData{ValidID}    = $Row[2];
        $ServiceData{Comment}    = $Row[3] || '';
        $ServiceData{CreateTime} = $Row[4];
        $ServiceData{CreateBy}   = $Row[5];
        $ServiceData{ChangeTime} = $Row[6];
        $ServiceData{ChangeBy}   = $Row[7];

        # ---
        # ITSM
        # ---
        $ServiceData{TypeID}        = $Row[8];
        $ServiceData{CriticalityID} = $Row[9];

        # ---
    }

    # check service
    if ( !$ServiceData{ServiceID} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "No such ServiceID ($Param{ServiceID})!",
        );
        return;
    }

    # create short name and parentid
    $ServiceData{NameShort} = $ServiceData{Name};
    if ( $ServiceData{Name} =~ /^(.*)::(.+?)$/ ) {
        $ServiceData{NameShort} = $2;

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

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

    # ---
    # ITSM
    # ---

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

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

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

    # get ITSM module directory
    my $ConfigItemModule = $Self->{ConfigObject}->Get('Home') . '/Kernel/System/ITSMConfigItem.pm';

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

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

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

        # set the preferences setting for CurInciStateTypeFromCIs
        else {

            # get the incident link type
            my $LinkType = $Self->{ConfigObject}->Get('ITSM::Core::IncidentLinkType');

            # find all linked config items
            my %LinkedConfigItemIDs = $Self->{LinkObject}->LinkKeyListWithData(
                Object1 => 'Service',
                Key1    => $Param{ServiceID},
                Object2 => 'ITSMConfigItem',
                State   => 'Valid',
                Type    => $LinkType,
                UserID  => 1,
            );

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

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

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

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

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

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

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

        # create the valid string
        my $ValidIDString = join q{, }, $Self->{ValidObject}->ValidIDsGet();

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

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

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

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

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

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

            push @ChildIDs, $Row[0];
        }

        SERVICEID:
        for my $ServiceID (@ChildIDs) {

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

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

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

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

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

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

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

    # get incident state functionality
    my $InciState = $Self->{GeneralCatalogObject}->ItemGet(
        ItemID => $ServiceData{CurInciStateID},
    );

    $ServiceData{CurInciState}     = $InciState->{Name};
    $ServiceData{CurInciStateType} = $InciState->{Functionality};

    # ---

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

    return %ServiceData;
}

=item ServiceLookup()

return a service name and id

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

    or

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

=cut

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

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

    if ( $Param{ServiceID} ) {

        # check cache
        my $CacheKey = 'Cache::ServiceLookup::ID::' . $Param{ServiceID};
        if ( defined $Self->{$CacheKey} ) {
            return $Self->{$CacheKey};
        }

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

        return $Self->{$CacheKey};
    }
    else {

        # check cache
        my $CacheKey = 'Cache::ServiceLookup::Name::' . $Param{Name};
        if ( defined $Self->{$CacheKey} ) {
            return $Self->{$CacheKey};
        }

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

        return $Self->{$CacheKey};
    }
}

=item ServiceAdd()

add a service

    my $ServiceID = $ServiceObject->ServiceAdd(
        Name     => 'Service Name',
        ParentID => 1,           # (optional)
        ValidID  => 1,
        Comment  => 'Comment',    # (optional)
        UserID   => 1,
# ---
# ITSM
# ---
        TypeID        => 2,
        CriticalityID => 1,
# ---
    );

=cut

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

    # check needed stuff
    # ---
    # ITSM
    # ---
    #    for my $Argument (qw(Name ValidID UserID)) {
    for my $Argument (qw(Name ValidID UserID TypeID CriticalityID)) {

        # ---
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

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

    # cleanup given params
    for my $Argument (qw(Name Comment)) {
        $Self->{CheckItemObject}->StringClean(
            StringRef         => \$Param{$Argument},
            RemoveAllNewlines => 1,
            RemoveAllTabs     => 1,
        );
    }

    # check service name
    if ( $Param{Name} =~ /::/ ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Can't add service! Invalid Service name '$Param{Name}'!",
        );
        return;
    }

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

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

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

    # add service to database
    if ($Exists) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Can\'t add service! Service with same name and parent already exists.'
        );
        return;
    }

    return if !$Self->{DBObject}->Do(

        # ---
        # ITSM
        # ---
        #        SQL => 'INSERT INTO service '
        #            . '(name, valid_id, comments, create_time, create_by, change_time, change_by) '
        #            . 'VALUES (?, ?, ?, current_timestamp, ?, current_timestamp, ?)',
        #        Bind => [
        #            \$Param{FullName}, \$Param{ValidID}, \$Param{Comment},
        #            \$Param{UserID}, \$Param{UserID},
        #        ],
        SQL => 'INSERT INTO service '
            . '(name, valid_id, comments, create_time, create_by, change_time, change_by, '
            . 'type_id, criticality_id) '
            . 'VALUES (?, ?, ?, current_timestamp, ?, current_timestamp, ?, ?, ?)',
        Bind => [
            \$Param{FullName}, \$Param{ValidID}, \$Param{Comment},
            \$Param{UserID}, \$Param{UserID}, \$Param{TypeID}, \$Param{CriticalityID},
        ],

        # ---
    );

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

    # reset cache
    delete $Self->{ 'Cache::ServiceLookup::ID::' . $ServiceID };
    delete $Self->{ 'Cache::ServiceLookup::Name::' . $Param{FullName} };

    return $ServiceID;
}

=item ServiceUpdate()

update a existing service

    my $True = $ServiceObject->ServiceUpdate(
        ServiceID => 123,
        ParentID  => 1,           # (optional)
        Name      => 'Service Name',
        ValidID   => 1,
        Comment   => 'Comment',    # (optional)
        UserID    => 1,
# ---
# ITSM
# ---
        TypeID        => 2,
        CriticalityID => 1,
# ---
    );

=cut

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

    # check needed stuff
    # ---
    # ITSM
    # ---
    #    for my $Argument (qw(ServiceID Name ValidID UserID)) {
    for my $Argument (qw(ServiceID Name ValidID UserID TypeID CriticalityID)) {

        # ---
        if ( !$Param{$Argument} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $Argument!",
            );
            return;
        }
    }

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

    # cleanup given params
    for my $Argument (qw(Name Comment)) {
        $Self->{CheckItemObject}->StringClean(
            StringRef         => \$Param{$Argument},
            RemoveAllNewlines => 1,
            RemoveAllTabs     => 1,
        );
    }

    # check service name
    if ( $Param{Name} =~ /::/ ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Can't update service! Invalid Service name '$Param{Name}'!",
        );
        return;
    }

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

    # reset cache
    delete $Self->{ 'Cache::ServiceLookup::ID::' . $Param{ServiceID} };
    delete $Self->{ 'Cache::ServiceLookup::Name::' . $OldServiceName };

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

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

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

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

        # check, if selected parent was a child of this service
        if ( $Param{FullName} =~ /^(\Q$OldServiceName\E)::/ ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => 'Can\'t update service! Invalid parent was selected.'
            );
            return;
        }
    }

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

    # update service
    if ($Exists) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Can\'t update service! Service with same name and parent already exists.'
        );
        return;

    }

    # update service
    return if !$Self->{DBObject}->Do(

        # ---
        # ITSM
        # ---
        #        SQL => 'UPDATE service SET name = ?, valid_id = ?, comments = ?, '
        #            . ' change_time = current_timestamp, change_by = ? WHERE id = ?',
        #        Bind => [
        #            \$Param{FullName}, \$Param{ValidID}, \$Param{Comment},
        #            \$Param{UserID}, \$Param{ServiceID},
        #        ],
        SQL => 'UPDATE service SET name = ?, valid_id = ?, comments = ?, '
            . ' change_time = current_timestamp, change_by = ?, type_id = ?, criticality_id = ?'
            . ' WHERE id = ?',
        Bind => [
            \$Param{FullName}, \$Param{ValidID}, \$Param{Comment},
            \$Param{UserID}, \$Param{TypeID}, \$Param{CriticalityID}, \$Param{ServiceID},
        ],

        # ---
    );

    # find all childs
    $Self->{DBObject}->Prepare(
        SQL => "SELECT id, name FROM service WHERE name LIKE '"
            . $Self->{DBObject}->Quote( $OldServiceName, 'Like' )
            . "::%'",
    );
    my @Childs;
    while ( my @Row = $Self->{DBObject}->FetchrowArray() ) {
        my %Child;
        $Child{ServiceID} = $Row[0];
        $Child{Name}      = $Row[1];
        push @Childs, \%Child;
    }

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

=item ServiceSearch()

return service ids as an array

    my @ServiceList = $ServiceObject->ServiceSearch(
        Name   => 'Service Name', # (optional)
        Limit  => 122,            # (optional) default 1000
        UserID => 1,
# ---
# ITSM
# ---
        TypeIDs        => 2,
        CriticalityIDs => 1,
# ---
    );

=cut

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

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

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

    # create sql query
    my $SQL
        = "SELECT id FROM service WHERE valid_id IN ( ${\(join ', ', $Self->{ValidObject}->ValidIDsGet())} )";

    if ( $Param{Name} ) {

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

        # replace * with % and clean the string
        $Param{Name} =~ s{ \*+ }{%}xmsg;
        $Param{Name} =~ s{ %+ }{%}xmsg;

        $SQL .= " AND name LIKE '$Param{Name}' ";
    }

    # ---
    # ITSM
    # ---
    # add type ids
    if ( $Param{TypeIDs} && ref $Param{TypeIDs} eq 'ARRAY' && @{ $Param{TypeIDs} } ) {
        $SQL .= "AND type_id IN (" . join( ', ', @{ $Param{TypeIDs} } ) . ") ";
    }

    # add criticality ids
    if (   $Param{CriticalityIDs}
        && ref $Param{CriticalityIDs} eq 'ARRAY'
        && @{ $Param{CriticalityIDs} } )
    {
        $SQL .= "AND criticality_id IN (" . join( ', ', @{ $Param{CriticalityIDs} } ) . ") ";
    }

    # ---

    $SQL .= ' ORDER BY name';

    # search service in db
    $Self->{DBObject}->Prepare( SQL => $SQL );

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

    return @ServiceList;
}

=item CustomerUserServiceMemberList()

returns a list of customeruser/service members

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

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

    Example (get services of customer user):

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

    Example (get customer user of service):

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

=cut

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

    # check needed stuff
    if ( !$Param{Result} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Result!',
        );
        return;
    }
    if ( !$Param{ServiceID} && !$Param{CustomerUserLogin} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need ServiceID or CustomerUserLogin!',
        );
        return;
    }

    # set default
    if ( !defined $Param{DefaultServices} ) {
        $Param{DefaultServices} = 1;
    }

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

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

    # check cache
    if ( $Param{ServiceID} || $Param{CustomerUserLogin} ) {
        if ( $Self->{ForceCache} ) {
            $Param{Cached} = $Self->{ForceCache};
        }
        if ( $Param{Cached} && $Self->{$CacheKey} ) {
            if ( ref( $Self->{$CacheKey} ) eq 'ARRAY' ) {
                return @{ $Self->{$CacheKey} };
            }
            elsif ( ref( $Self->{$CacheKey} ) eq 'HASH' ) {
                return %{ $Self->{$CacheKey} };
            }
        }
    }

    # sql
    my %Data;
    my @Name;
    my @ID;
    my $SQL = 'SELECT scu.service_id, scu.customer_user_login, s.name '
        . ' FROM '
        . ' service_customer_user scu, service s'
        . ' WHERE '
        . " s.valid_id IN ( ${\(join ', ', $Self->{ValidObject}->ValidIDsGet())} ) AND "
        . ' s.id = scu.service_id AND ';

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

    $Self->{DBObject}->Prepare( SQL => $SQL );

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

        my $Key   = '';
        my $Value = '';
        if ( $Param{ServiceID} ) {
            $Key   = $Row[1];
            $Value = $Row[0];
        }
        else {
            $Key   = $Row[0];
            $Value = $Row[2];
        }

        # remember permissions
        if ( !defined $Data{$Key} ) {
            $Data{$Key} = $Value;
            push @Name, $Value;
            push @ID,   $Key;
        }
    }
    if ( $Param{CustomerUserLogin} && $Param{DefaultServices} && !keys(%Data) ) {
        %Data = $Self->CustomerUserServiceMemberList(
            CustomerUserLogin => '<DEFAULT>',
            Result            => 'HASH',
            DefaultServices   => 0,
        );
        for my $Key ( keys %Data ) {
            push @Name, $Data{$Key};
            push @ID,   $Key;
        }
    }

    # return result
    if ( $Param{Result} && $Param{Result} eq 'ID' ) {
        if ( $Param{ServiceID} || $Param{CustomerUserLogin} ) {

            # cache result
            $Self->{$CacheKey} = \@ID;
        }
        return @ID;
    }
    if ( $Param{Result} && $Param{Result} eq 'Name' ) {
        if ( $Param{ServiceID} || $Param{CustomerUserLogin} ) {

            # cache result
            $Self->{$CacheKey} = \@Name;
        }
        return @Name;
    }
    else {
        if ( $Param{ServiceID} || $Param{CustomerUserLogin} ) {

            # cache result
            $Self->{$CacheKey} = \%Data;
        }
        return %Data;
    }
}

=item CustomerUserServiceMemberAdd()

to add a member to a service

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

=cut

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

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

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

    # return if relation is not active
    return if !$Param{Active};

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

# capeIT

=item CustomerCompanyServiceMemberList()

returns a list of CustomerCompany/service members

    ServiceID: service id
    CustomerID: customer ID
    DefaultServices: activate or deactivate default services

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

    Example (get services of customer user):

    $ServiceObject->CustomerCompanyServiceMemberList(
        CustomerID        => 'Test',
        Result            => 'HASH',
        DefaultServices   => 0,
    );

    Example (get customer company of service):

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

=cut

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

    # check needed stuff
    if ( !$Param{Result} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need Result!',
        );
        return;
    }
    if ( !$Param{ServiceID} && !$Param{CustomerID} ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => 'Need ServiceID or CustomerID!',
        );
        return;
    }

    # set default
    if ( !defined $Param{DefaultServices} ) {
        $Param{DefaultServices} = 1;
    }

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

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

    # check cache
    if ( $Param{ServiceID} || $Param{CustomerID} ) {
        if ( $Self->{ForceCache} ) {
            $Param{Cached} = $Self->{ForceCache};
        }
        if ( $Param{Cached} && $Self->{$CacheKey} ) {
            if ( ref( $Self->{$CacheKey} ) eq 'ARRAY' ) {
                return @{ $Self->{$CacheKey} };
            }
            elsif ( ref( $Self->{$CacheKey} ) eq 'HASH' ) {
                return %{ $Self->{$CacheKey} };
            }
        }
    }

    # sql
    my %Data;
    my @Name;
    my @ID;
    my $SQL = 'SELECT scc.service_id, scc.customer_id, s.name '
        . ' FROM '
        . ' service_customer_company scc, service s'
        . ' WHERE '
        . " s.valid_id IN ( ${\(join ', ', $Self->{ValidObject}->ValidIDsGet())} ) AND "
        . ' s.id = scc.service_id AND ';

    if ( $Param{ServiceID} ) {
        $SQL .= " scc.service_id = $Param{ServiceID}";
    }
    elsif ( $Param{CustomerID} ) {
        $SQL .= " scc.customer_id = '$Param{CustomerID}'";
    }

    $Self->{DBObject}->Prepare( SQL => $SQL );

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

        my $Key   = '';
        my $Value = '';
        if ( $Param{ServiceID} ) {
            $Key   = $Row[1];
            $Value = $Row[0];
        }
        else {
            $Key   = $Row[0];
            $Value = $Row[2];
        }

        # remember permissions
        if ( !defined $Data{$Key} ) {
            $Data{$Key} = $Value;
            push @Name, $Value;
            push @ID,   $Key;
        }
    }
    if ( $Param{CustomerID} && $Param{DefaultServices} && !keys(%Data) ) {
        %Data = $Self->CustomerCompanyServiceMemberList(
            CustomerID      => '<DEFAULT>',
            Result          => 'HASH',
            DefaultServices => 0,
        );
        for my $Key ( keys %Data ) {
            push @Name, $Data{$Key};
            push @ID,   $Key;
        }
    }

    # return result
    if ( $Param{Result} && $Param{Result} eq 'ID' ) {
        if ( $Param{ServiceID} || $Param{CustomerID} ) {

            # cache result
            $Self->{$CacheKey} = \@ID;
        }
        return @ID;
    }
    if ( $Param{Result} && $Param{Result} eq 'Name' ) {
        if ( $Param{ServiceID} || $Param{CustomerID} ) {

            # cache result
            $Self->{$CacheKey} = \@Name;
        }
        return @Name;
    }
    else {
        if ( $Param{ServiceID} || $Param{CustomerID} ) {

            # cache result
            $Self->{$CacheKey} = \%Data;
        }
        return %Data;
    }
}

=item CustomerCompanyServiceMemberAdd()

to add a member to a service

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

=cut

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

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

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

    # return if relation is not active
    return if !$Param{Active};

    # insert new relation
    return $Self->{DBObject}->Do(
        SQL => 'INSERT INTO service_customer_company '
            . '(customer_id, service_id, create_time, create_by) '
            . 'VALUES (?, ?, current_timestamp, ?)',
        Bind => [ \$Param{CustomerID}, \$Param{ServiceID}, \$Param{UserID} ]
    );
}

# EO capeIT

=item ServicePreferencesSet()

set service preferences

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

=cut

sub ServicePreferencesSet {
    my $Self = shift;

    return $Self->{PreferencesObject}->ServicePreferencesSet(@_);
}

=item ServicePreferencesGet()

get service preferences

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

=cut

sub ServicePreferencesGet {
    my $Self = shift;

    return $Self->{PreferencesObject}->ServicePreferencesGet(@_);
}

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 (AGPL). If you
did not receive this file, see http://www.gnu.org/licenses/agpl.txt.

=cut

=head1 VERSION

$Revision: 1.1 $ $Date: 2010-10-07 16:15:59 $

=cut
 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