Webservice-CustomerOperations 11.1.1 Perl-Services.de http://www.perl-services.de GNU AFFERO GENERAL PUBLIC LICENSE Version 3, November 2007 Initial Release. Verbesserungen am GenericInterface Enhancements for the GenericInterface 11.1.x 5a1a820bc14fe1107bcee5bbfead341bbc44fa29 2026-10-09 14:41:41 opms.rother-oss.com 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 # --
# Copyright (C) 2018 Perl-Services.de, http://perl-services.de
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# 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::GenericInterface::Operation::Customer::CustomerUpsert;

use v5.24;
use strict;
use warnings;

use parent qw(
    Kernel::GenericInterface::Operation::Common
    Kernel::GenericInterface::Operation::Customer::Common
);

# core modules

# CPAN modules

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

our $ObjectManagerDisabled = 1;

=head1 NAME

Kernel::GenericInterface::Operation::Customer::CustomerUpsert - GenericInterface Customer CustomerUpsert Operation backend

=head1 PUBLIC INTERFACE

=head2 new()

usually, you want to create an instance of this
by using Kernel::GenericInterface::Operation->new();

=cut

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

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

    # check needed objects
    for my $Needed (qw( DebuggerObject WebserviceID )) {
        if ( !$Param{$Needed} ) {
            return {
                Success      => 0,
                ErrorMessage => "Got no $Needed!"
            };
        }

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

    $Self->{Config} = $Kernel::OM->Get('Kernel::Config')->Get('GenericInterface::Operation::CustomerUpsert');

    return $Self;
}

=head2 Run()

perform CustomerUpsert Operation. This function is able to accept
one or more customer entries in one call and returns successfully
inserted or updated customer IDs.

    my $Result = $OperationObject->Run(
        Data => {
            UserLogin => 'some agent login',                            # UserLogin or SessionID is required
            SessionID => 123,
            Password  => 'some password',                               # if UserLogin is sent then Password is required

            Customer => {                                               # Single customer or customer list is required
                CustomerID              => 'test.com',
                CustomerCompanyID       => 'oldtest.com',               # required for CustomerID-update (if no such customer
                                                                        # exists, this will be ignored by the default mapping
                                                                        # and instead a new customer via CustomerID is inserted)
                CustomerCompanyName     => 'Test Inc.',
                CustomerCompanyStreet   => '5201 Blue Lagoon Drive',
                CustomerCompanyZIP      => '33126',
                CustomerCompanyLocation => 'Miami',
                CustomerCompanyCountry  => 'USA',
                CustomerCompanyURL      => 'http://example.com',
                CustomerCompanyComment  => 'some comment',
                ValidID                 => 1,
            },
            Customer => [
                {
                    CustomerID          => 'test.com',
                    CustomerCompanyID   => 'oldtest.com',
                    CustomerCompanyName => 'Test Inc.',
                    CustomerCompanyStreet   => '5201 Blue Lagoon Drive',
                    CustomerCompanyZIP      => '33126',
                    CustomerCompanyLocation => 'Miami',
                    CustomerCompanyCountry  => 'USA',
                    CustomerCompanyURL      => 'http://example.com',
                    CustomerCompanyComment  => 'some comment',
                    ValidID                 => 1,
                },
                {
                    # . . .
                },
            ],
        },
    );

    $Result = {
        Success         => 1,                                  # 0 or 1
        ErrorMessage    => '',                                 # in case of error
        Data            => {                                   # result data payload after Operation
            CustomerID => '123',                               # returns single customer or list of all
                                                               # successfully inserted/updated customer
            CustomerID => ['123', '456'],
            Error      => {                                    # should not return errors
                ErrorCode    => 'Customer.Upsert.ErrorCode'
                ErrorMessage => 'Error Description'
            },
        },
    };

=cut

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

    my $InitResult = $Self->Init(
        WebserviceID => $Self->{WebserviceID},
    );

    if ( !$InitResult->{Success} ) {
        return $Self->ReturnError(
            ErrorCode    => 'Webservice.InvalidConfiguration',
            ErrorMessage => $InitResult->{ErrorMessage},
        );
    }

    # check needed stuff
    if (
        !$Param{Data}->{UserLogin}
        && !$Param{Data}->{SessionID}
        )
    {
        return $Self->ReturnError(
            ErrorCode    => 'CustomerUpsert.MissingParameter',
            ErrorMessage => "CustomerUpsert: UserLogin or SessionID is required!",
        );
    }

    if ( $Param{Data}->{UserLogin} ) {

        if ( !$Param{Data}->{Password} )
        {
            return $Self->ReturnError(
                ErrorCode    => 'CustomerUpsert.MissingParameter',
                ErrorMessage => "CustomerUpsert: Password or SessionID is required!",
            );
        }
    }

    # authenticate user
    my ( $UserID, $UserType ) = $Self->Auth(
        %Param,
    );

    if ( !$UserID ) {
        return $Self->ReturnError(
            ErrorCode    => 'CustomerUpsert.AuthFail',
            ErrorMessage => "CustomerUpsert: User could not be authenticated!",
        );
    }

    my $PermissionUserID = $UserID;

    # check needed stuff
    for my $Needed (qw(Customer)) {
        if ( !$Param{Data}->{$Needed} ) {
            return $Self->ReturnError(
                ErrorCode    => 'CustomerUpsert.MissingParameter',
                ErrorMessage => "CustomerUpsert: $Needed parameter is missing or not valid!",
            );
        }
    }

    my $SingleCustomer;
    my $Result = {
        Success => 1,
        Data    => {},
    };

    # transform single customers to an array reference
    if ( !IsArrayRefWithData( $Param{Data}{Customer} ) ) {
        $Param{Data}{Customer} = [ $Param{Data}{Customer} ];
        $SingleCustomer = 1;
    }
    else {
        $Result->{Data}->{CustomerID} = [];
    }

    # upsert each customer
    for my $Customer ( @{ $Param{Data}{Customer} } ) {

        # remove leading and trailing spaces
        ATTRIBUTE:
        for my $Attribute ( sort keys %{$Customer} ) {
            next ATTRIBUTE if !$Customer->{$Attribute};
            next ATTRIBUTE if ref $Customer->{$Attribute} eq 'HASH';
            next ATTRIBUTE if ref $Customer->{$Attribute} eq 'ARRAY';

            $Customer->{$Attribute} =~ s{\A\s+}{};
            $Customer->{$Attribute} =~ s{\s+\z}{};
        }

        my $CustomerCheck = $Self->_CheckCustomer( Customer => $Customer );

        # if an error occurs, return, but still include all customers already upserted
        if ( !$CustomerCheck->{Success} ) {
            $Result->{Success}       = 0;
            $Result->{ErrorMessage}  = "$CustomerCheck->{ErrorCode}: $CustomerCheck->{ErrorMessage}";
            $Result->{Data}->{Error} = {
                ErrorCode    => $CustomerCheck->{ErrorCode},
                ErrorMessage => $CustomerCheck->{ErrorMessage},
            };

            return $Result;
        }

        my $UpsertResult = $Self->_CustomerUpsert(
            Customer => $Customer,
            UserID   => $UserID,
        );

        # if an error occurs, return, but still include all customers already upserted
        if ( !$UpsertResult->{Success} ) {
            $Result->{Success}      = 0;
            $Result->{ErrorMessage} = $UpsertResult->{ErrorMessage};

            return $Result;
        }

        if ($SingleCustomer) {
            $Result->{Data}->{CustomerID} = $UpsertResult->{CustomerID};
        }
        else {
            push @{ $Result->{Data}->{CustomerID} }, $UpsertResult->{CustomerID};
        }
    }

    return $Result;
}

=begin Internal:

=head2 _CheckCustomer()

checks if the given customer parameters are valid.

    my $CustomerCheck = $OperationObject->_CheckCustomer(
        Customer => $Customer,                               # all customer parameters
    );

    returns:

    $CustomerCheck = {
        Success => 1,                                        # if everything is OK
    }

    $CustomerCheck = {
        ErrorCode    => 'Function.Error',                    # if error
        ErrorMessage => 'Error description',
    }

=cut

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

    my $Customer = $Param{Customer};

    # check customer internally
    for my $Needed (qw(CustomerID CustomerCompanyName)) {
        if ( !$Customer->{$Needed} ) {
            return {
                ErrorCode    => 'CustomerUpsert.MissingParameter',
                ErrorMessage => "CustomerUpsert: Customer->$Needed parameter is missing!",
            };
        }
    }

    # if everything is OK then return Success
    return {
        Success => 1,
    };
}

=head2 _CustomerUpsert()

updates or inserts a customer.

    my $Response = $OperationObject->_CustomerUpsert(
        Customer => $Customer,                                        # all customer parameters
        UserID   => 123,
    );

    returns:

    $Response = {
        Success => 1,                                                 # if everething is OK
        Data    => {
            CustomerID => 123,
        }
    }

    $Response = {
        Success      => 0,                                            # if unexpected error
        ErrorMessage => "$Param{ErrorCode}: $Param{ErrorMessage}",
    }

=cut

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

    my $Customer   = $Param{Customer};
    my $CustomerID = $Customer->{CustomerID};

    # customers are by default valid
    $Customer->{ValidID} //= 1;

    # get customer object
    my $CustomerObject = $Kernel::OM->Get('Kernel::System::CustomerCompany');

    # check whether this customer exists (update) or is new (insert)
    $Customer->{CustomerCompanyID} ||= $Customer->{CustomerID};

    my %Company = $CustomerObject->CustomerCompanyGet( CustomerID => $Customer->{CustomerCompanyID} );
    if (%Company) {

        # check if new CustomerID already exists
        if ( $Customer->{CustomerID} ne $Customer->{CustomerCompanyID} ) {
            my %Result = $CustomerObject->CustomerCompanyGet( User => $Customer->{CustomerID} );
            if (%Result) {
                $Kernel::OM->Get('Kernel::System::Log')->Log(
                    Priority => 'error',
                    Message  => $Kernel::OM->Get('Kernel::Language')->Translate( 'Customer "%s" already exists.', $Customer->{CustomerID} ),
                );
                return;
            }
        }

        my $Success = $CustomerObject->CustomerCompanyUpdate(
            %{$Customer},
            UserID => $Param{UserID},
        );

        if ( !$Success ) {
            return {
                Success      => 0,
                ErrorMessage => 'Customer could not be updated, please contact the system administrator',
            };
        }
    }
    else {
        $CustomerID = $CustomerObject->CustomerCompanyAdd(
            %{$Customer},
            UserID => $Param{UserID},
        );

        if ( !$CustomerID ) {
            return {
                Success      => 0,
                ErrorMessage => 'Customer could not be inserted, please contact the system administrator',
            };
        }
    }

    my %CustomerData = $CustomerObject->CustomerCompanyGet(
        CustomerID => $CustomerID,
        UserID     => $Param{UserID},
    );

    if ( !IsHashRefWithData( \%CustomerData ) ) {
        return {
            Success      => 0,
            ErrorMessage => 'Could not get new customer information, please contact the system'
                . ' administrator',
        };
    }

    return {
        Success    => 1,
        CustomerID => $CustomerID,
    };
}

1;

=end Internal:

=head1 TERMS AND CONDITIONS

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 L<http://www.gnu.org/licenses/agpl.txt>.

=cut
 # --
# Copyright (C) 2018 Perl-Services.de, http://perl-services.de
# Copyright (C) 2019-2026 Rother OSS GmbH, https://otobo.io/
# --
# 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::GenericInterface::Operation::Customer::CustomerUserUpsert;

use v5.24;
use strict;
use warnings;

use parent qw(
    Kernel::GenericInterface::Operation::Common
    Kernel::GenericInterface::Operation::Customer::Common
);

# core modules

# CPAN modules

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

our $ObjectManagerDisabled = 1;

=head1 NAME

Kernel::GenericInterface::Operation::Customer::CustomerUserUpsert - GenericInterface Customer CustomerUserUpsert Operation backend

=head1 PUBLIC INTERFACE

=head2 new()

usually, you want to create an instance of this
by using Kernel::GenericInterface::Operation->new();

=cut

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

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

    # check needed objects
    for my $Needed (qw( DebuggerObject WebserviceID )) {
        if ( !$Param{$Needed} ) {
            return {
                Success      => 0,
                ErrorMessage => "Got no $Needed!"
            };
        }

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

    $Self->{Config} = $Kernel::OM->Get('Kernel::Config')->Get('GenericInterface::Operation::CustomerUserUpsert');

    return $Self;
}

=head2 Run()

perform CustomerUserUpsert Operation. This function is able to accept
one or more customer user entries in one call and returns successfully
inserted or updated customer user logins.

    my $Result = $OperationObject->Run(
        Data => {
            UserLogin => 'some agent login',                          # UserLogin or SessionID is required
            SessionID => 123,
            Password  => 'some password',                             # if UserLogin is sent then Password is required

            CustomerUser => {                                         # Single customer user or customer user list is required
                UserLogin      => 'tc',
                ID             => 'oldtc',                            # required for UserLogin-update (if no such customer user
                                                                      # exists, this will be ignored by the default mapping and
                                                                      # instead a new customer user via UserLogin is inserted)
                UserFirstname  => 'Test',
                UserLastname   => 'Customer',
                UserPassword   => 'some-pass',                        # not required
                UserEmail      => 'test.customer@example.com',
                UserCustomerID => '12345',                            # required when inserting
                ValidID        => 1,
            },
            CustomerUser => [
                {
                    UserLogin      => 'tc',
                    UserPassword   => 'some-pass',
                    UserFirstname  => 'Test',
                    UserLastname   => 'Customer',
                    UserEmail      => 'test.customer@example.com',
                    UserCustomerID => '12345',
                    ValidID        => 1,
                },
                {
                    # . . .
                },
            ],
        },
    );

    $Result = {
        Success         => 1,                                      # 0 or 1
        ErrorMessage    => '',                                     # in case of error
        Data            => {                                       # result data payload after Operation
            UserLogin => 'tc',                                     # returns single customer user or list of all
                                                                   # successfully inserted/updated customer users
            UserLogin => ['tc', 'tc2'],
            Error     => {                                         # should not return errors
                ErrorCode    => 'CustomerUser.Upsert.ErrorCode'
                ErrorMessage => 'Error Description'
            },
        },
    };

=cut

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

    my $InitResult = $Self->Init(
        WebserviceID => $Self->{WebserviceID},
    );

    if ( !$InitResult->{Success} ) {
        return $Self->ReturnError(
            ErrorCode    => 'Webservice.InvalidConfiguration',
            ErrorMessage => $InitResult->{ErrorMessage},
        );
    }

    # check needed stuff
    if (
        !$Param{Data}->{UserLogin}
        && !$Param{Data}->{SessionID}
        )
    {
        return $Self->ReturnError(
            ErrorCode    => 'CustomerUserUpsert.MissingParameter',
            ErrorMessage => "CustomerUserUpsert: UserLogin or SessionID is required!",
        );
    }

    if ( $Param{Data}->{UserLogin} ) {

        if ( !$Param{Data}->{Password} )
        {
            return $Self->ReturnError(
                ErrorCode    => 'CustomerUserUpsert.MissingParameter',
                ErrorMessage => "CustomerUserUpsert: Password or SessionID is required!",
            );
        }
    }

    # authenticate user
    my ( $UserID, $UserType ) = $Self->Auth(
        %Param,
    );

    if ( !$UserID ) {
        return $Self->ReturnError(
            ErrorCode    => 'CustomerUserUpsert.AuthFail',
            ErrorMessage => "CustomerUserUpsert: User could not be authenticated!",
        );
    }

    my $PermissionUserID = $UserID;

    # check needed stuff
    for my $Needed (qw(CustomerUser)) {
        if ( !$Param{Data}->{$Needed} ) {
            return $Self->ReturnError(
                ErrorCode    => 'CustomerUserUpsert.MissingParameter',
                ErrorMessage => "CustomerUserUpsert: $Needed parameter is missing or not valid!",
            );
        }
    }

    my $SingleCustomerUser;
    my $Result = {
        Success => 1,
        Data    => {},
    };

    # transform single customer users to an array reference
    if ( !IsArrayRefWithData( $Param{Data}{CustomerUser} ) ) {
        $Param{Data}{CustomerUser} = [ $Param{Data}{CustomerUser} ];
        $SingleCustomerUser = 1;
    }
    else {
        $Result->{Data}->{UserLogin} = [];
    }

    # upsert each customer user
    for my $CustomerUser ( @{ $Param{Data}{CustomerUser} } ) {

        # remove leading and trailing spaces
        ATTRIBUTE:
        for my $Attribute ( sort keys %{$CustomerUser} ) {
            next ATTRIBUTE if !$CustomerUser->{$Attribute};
            next ATTRIBUTE if ref $CustomerUser->{$Attribute} eq 'HASH';
            next ATTRIBUTE if ref $CustomerUser->{$Attribute} eq 'ARRAY';

            $CustomerUser->{$Attribute} =~ s{\A\s+}{};
            $CustomerUser->{$Attribute} =~ s{\s+\z}{};
        }

        my $CustomerUserCheck = $Self->_CheckCustomerUser( CustomerUser => $CustomerUser );

        # if an error occurs, return, but still include all customer users already upserted
        if ( !$CustomerUserCheck->{Success} ) {
            $Result->{Success}       = 0;
            $Result->{ErrorMessage}  = "$CustomerUserCheck->{ErrorCode}: $CustomerUserCheck->{ErrorMessage}";
            $Result->{Data}->{Error} = {
                ErrorCode    => $CustomerUserCheck->{ErrorCode},
                ErrorMessage => $CustomerUserCheck->{ErrorMessage},
            };

            return $Result;
        }

        my $UpsertResult = $Self->_CustomerUserUpsert(
            CustomerUser => $CustomerUser,
            UserID       => $UserID,
        );

        # if an error occurs, return, but still include all customer users already upserted
        if ( !$UpsertResult->{Success} ) {
            $Result->{Success}      = 0;
            $Result->{ErrorMessage} = $UpsertResult->{ErrorMessage};

            return $Result;
        }

        if ($SingleCustomerUser) {
            $Result->{Data}->{UserLogin} = $UpsertResult->{UserLogin};
        }
        else {
            push @{ $Result->{Data}->{UserLogin} }, $UpsertResult->{UserLogin};
        }
    }

    return $Result;
}

=begin Internal:

=head2 _CheckCustomerUser()

checks if the given customer user parameters are valid.

    my $CustomerUserCheck = $OperationObject->_CheckCustomerUser(
        CustomerUser => $CustomerUser,                               # all customer user parameters
    );

    returns:

    $CustomerUserCheck = {
        Success => 1,                                                # if everything is OK
    }

    $CustomerUserCheck = {
        ErrorCode    => 'Function.Error',                            # if error
        ErrorMessage => 'Error description',
    }

=cut

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

    my $CustomerUser = $Param{CustomerUser};

    # check customer user internally
    for my $Needed (qw(UserFirstname UserLastname UserLogin UserEmail)) {
        if ( !$CustomerUser->{$Needed} ) {
            return {
                ErrorCode    => 'CustomerUserUpsert.MissingParameter',
                ErrorMessage => "CustomerUseUpsertt: CustomerUser->$Needed parameter is missing!",
            };
        }
    }

    # if everything is OK then return Success
    return {
        Success => 1,
    };
}

=head2 _CustomerUserUpsert()

updates or inserts a customer user.

    my $Response = $OperationObject->_CustomerUserUpsert(
        CustomerUser => $CustomerUser,                                # all customer user parameters
        UserID       => 123,
    );

    returns:

    $Response = {
        Success => 1,                                                 # if everething is OK
        Data    => {
            CustomerUserID => 123,
        }
    }

    $Response = {
        Success      => 0,                                            # if unexpected error
        ErrorMessage => "$Param{ErrorCode}: $Param{ErrorMessage}",
    }

=cut

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

    my $CustomerUser = $Param{CustomerUser};
    my $UserLogin    = $CustomerUser->{UserLogin};

    # customer users are by default valid
    $CustomerUser->{ValidID} //= 1;

    # get customer user object
    my $CustomerUserObject = $Kernel::OM->Get('Kernel::System::CustomerUser');

    # check whether this customer user exists (update) or is new (insert)
    $CustomerUser->{ID} ||= $CustomerUser->{UserLogin};

    my %User = $CustomerUserObject->CustomerUserDataGet(
        User   => $CustomerUser->{ID},
        UserID => $Param{UserID},
    );
    if (%User) {
        my $Success = $CustomerUserObject->CustomerUserUpdate(
            %{$CustomerUser},
            UserID => $Param{UserID},
        );

        if ( !$Success ) {
            return {
                Success      => 0,
                ErrorMessage => 'Customer could not be updated, please contact the system administrator',
            };
        }
    }
    else {
        # when adding a new customer user, the customer (company) is required
        if ( !$CustomerUser->{UserCustomerID} ) {
            return {
                ErrorCode    => 'CustomerUserUpsert.MissingParameter',
                ErrorMessage => "CustomerUseUpsertt: CustomerUser->UserCustomerID parameter is missing!",
            };
        }

        $UserLogin = $CustomerUserObject->CustomerUserAdd(
            %{$CustomerUser},
            UserID => $Param{UserID},
        );

        if ( !$UserLogin ) {
            return {
                Success      => 0,
                ErrorMessage => 'Customer could not be inserted, please contact the system administrator',
            };
        }
    }

    my %CustomerUserData = $CustomerUserObject->CustomerUserDataGet(
        User   => $UserLogin,
        UserID => $Param{UserID},
    );

    if ( !IsHashRefWithData( \%CustomerUserData ) ) {
        return {
            Success      => 0,
            ErrorMessage => 'Could not get new customer user information, please contact the system'
                . ' administrator',
        };
    }

    return {
        Success   => 1,
        UserLogin => $UserLogin,
    };
}

1;

=end Internal:

=head1 TERMS AND CONDITIONS

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 L<http://www.gnu.org/licenses/agpl.txt>.

=cut
 PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPG90b2JvX2NvbmZpZyB2ZXJzaW9uPSIyLjAiIGluaXQ9IkNvbmZpZyI+CiAgICA8U2V0dGluZyBOYW1lPSJHZW5lcmljSW50ZXJmYWNlOjpPcGVyYXRpb246Ok1vZHVsZSMjI0N1c3RvbWVyOjpDdXN0b21lclVwc2VydCIgUmVxdWlyZWQ9IjAiIFZhbGlkPSIxIj4KICAgICAgICA8RGVzY3JpcHRpb24gVHJhbnNsYXRhYmxlPSIxIj5HZW5lcmljSW50ZXJmYWNlIG1vZHVsZSByZWdpc3RyYXRpb24gZm9yIHRoZSBvcGVyYXRpb24gbGF5ZXIuPC9EZXNjcmlwdGlvbj4KICAgICAgICA8TmF2aWdhdGlvbj5HZW5lcmljSW50ZXJmYWNlOjpPcGVyYXRpb246Ok1vZHVsZVJlZ2lzdHJhdGlvbjwvTmF2aWdhdGlvbj4KICAgICAgICA8VmFsdWU+CiAgICAgICAgICAgIDxIYXNoPgogICAgICAgICAgICAgICAgPEl0ZW0gS2V5PSJOYW1lIj5DdXN0b21lclVwc2VydDwvSXRlbT4KICAgICAgICAgICAgICAgIDxJdGVtIEtleT0iQ29udHJvbGxlciI+Q3VzdG9tZXI8L0l0ZW0+CiAgICAgICAgICAgICAgICA8SXRlbSBLZXk9IkNvbmZpZ0RpYWxvZyI+QWRtaW5HZW5lcmljSW50ZXJmYWNlT3BlcmF0aW9uRGVmYXVsdDwvSXRlbT4KICAgICAgICAgICAgPC9IYXNoPgogICAgICAgIDwvVmFsdWU+CiAgICA8L1NldHRpbmc+CiAgICA8U2V0dGluZyBOYW1lPSJHZW5lcmljSW50ZXJmYWNlOjpPcGVyYXRpb246Ok1vZHVsZSMjI0N1c3RvbWVyOjpDdXN0b21lclVzZXJVcHNlcnQiIFJlcXVpcmVkPSIwIiBWYWxpZD0iMSI+CiAgICAgICAgPERlc2NyaXB0aW9uIFRyYW5zbGF0YWJsZT0iMSI+R2VuZXJpY0ludGVyZmFjZSBtb2R1bGUgcmVnaXN0cmF0aW9uIGZvciB0aGUgb3BlcmF0aW9uIGxheWVyLjwvRGVzY3JpcHRpb24+CiAgICAgICAgPE5hdmlnYXRpb24+R2VuZXJpY0ludGVyZmFjZTo6T3BlcmF0aW9uOjpNb2R1bGVSZWdpc3RyYXRpb248L05hdmlnYXRpb24+CiAgICAgICAgPFZhbHVlPgogICAgICAgICAgICA8SGFzaD4KICAgICAgICAgICAgICAgIDxJdGVtIEtleT0iTmFtZSI+Q3VzdG9tZXJVc2VyVXBzZXJ0PC9JdGVtPgogICAgICAgICAgICAgICAgPEl0ZW0gS2V5PSJDb250cm9sbGVyIj5DdXN0b21lcjwvSXRlbT4KICAgICAgICAgICAgICAgIDxJdGVtIEtleT0iQ29uZmlnRGlhbG9nIj5BZG1pbkdlbmVyaWNJbnRlcmZhY2VPcGVyYXRpb25EZWZhdWx0PC9JdGVtPgogICAgICAgICAgICA8L0hhc2g+CiAgICAgICAgPC9WYWx1ZT4KICAgIDwvU2V0dGluZz4KPC9vdG9ib19jb25maWc+Cg==