SystemMonitoring
2.4.4
OTRS AG
http://otrs.org/
GNU AFFERO GENERAL PUBLIC LICENSE Version 3, November 2007
Build for SystemMonitoring 2.4.4.
Added documentation for missnaming of dynamic fields and error messages for missnamed dynamic fields (Bug 8381).
Including new handling for TicketID param.
First version for OTRS 3.2.
Basic mail interface to System Monitoring Suites. Also provides deeper integration to Nagios (Acknowledge on lock and Checkscript).
Einfache Email Schnittstelle zu System Monitoring Suites. Weitergehende Integration mit Nagios (Acknowledge on lock and Checkscript).
3.2.x
For configuration instructions please refer to the enclosed PDF documentation.
Eine Anleitung zur Konfiguration des SystemMonitoring Moduls findet sich in der Datei doc/SystemMonitoring.txt.
# define function name
my $FunctionName = 'CodeInstall';
# create the package name
my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content};
# load the module
if ( $Self->{MainObject}->Require($CodeModule) ) {
# create new instance
my $CodeObject = $CodeModule->new( %{$Self} );
if ($CodeObject) {
# start methode
if ( !$CodeObject->$FunctionName(%{$Self}) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method $FunctionName() on $CodeModule.pm."
);
}
}
# error handling
else {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method new() on $CodeModule.pm."
);
}
}
# check if config option exists
my $Config = $Self->{ConfigObject}->Get( 'PostMaster::PreFilterModule' );
# update/rename config option
if ($Config && $Config->{'0001-SystemMonitoring'} ) {
$Self->{SysConfigObject} = Kernel::System::Config->new( %{$Self} );
$Self->{SysConfigObject}->ConfigItemUpdate(
Valid => 1,
Key => 'PostMaster::PreFilterModule###00-SystemMonitoring',
Value => $Config->{'0001-SystemMonitoring'},
);
}
# define function name
my $FunctionName = 'CodeUpgrade';
# create the package name
my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content};
# The code module has just recently been copied to it's location in the file system.
# In a persistent Perl environment an old version of the module might still be loaded,
# as watchdogs like Apache2::Reload haven't had a chance to reload it.
# So we need to make sure that the new version is being loaded.
# Kernel::System::Main::Require() checks the relative file path, so we need to remove that from %INC.
# This is only needed in persistent Perl environment, but does no harm in a CGI environment.
my $CodeModulePath = $CodeModule;
$CodeModulePath =~ s/::/\//g;
$CodeModulePath .= '.pm';
delete $INC{$CodeModulePath};
# load the module
if ( $Self->{MainObject}->Require($CodeModule) ) {
# create new instance
my $CodeObject = $CodeModule->new( %{$Self} );
if ($CodeObject) {
# start methode
if ( !$CodeObject->$FunctionName(%{$Self}) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method $FunctionName() on $CodeModule.pm.",
);
}
}
# error handling
else {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method new() on $CodeModule.pm.",
);
}
}
# define function name
my $FunctionName = 'CodeUpgradeFromLowerThan_2_2_92';
# create the package name
my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content};
# load the module
if ( $Self->{MainObject}->Require($CodeModule) ) {
# create new instance
my $CodeObject = $CodeModule->new( %{$Self} );
if ($CodeObject) {
# start methode
if ( !$CodeObject->$FunctionName(%{$Self}) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method $FunctionName() on $CodeModule.pm."
);
}
}
# error handling
else {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method new() on $CodeModule.pm."
);
}
}
# define function name
my $FunctionName = 'CodeUninstall';
# create the package name
my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content};
# load the module
if ( $Self->{MainObject}->Require($CodeModule) ) {
# create new instance
my $CodeObject = $CodeModule->new( %{$Self} );
if ($CodeObject) {
# start methode
if ( !$CodeObject->$FunctionName(%{$Self}) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method $FunctionName() on $CodeModule.pm."
);
}
}
# error handling
else {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method new() on $CodeModule.pm."
);
}
}
# cleanup stats list
{
# load required modules
$Self->{MainObject}->Require('Kernel::System::CSV');
$Self->{MainObject}->Require('Kernel::System::Group');
$Self->{MainObject}->Require('Kernel::System::User');
$Self->{MainObject}->Require('Kernel::System::Stats');
# create needed objects
$Self->{CSVObject} = Kernel::System::CSV->new( %{$Self} );
$Self->{GroupObject} = Kernel::System::Group->new( %{$Self} );
$Self->{UserObject} = Kernel::System::User->new( %{$Self} );
$Self->{StatsObject} = Kernel::System::Stats->new(
%{$Self},
UserID => 1,
);
# cleanup stats list
$Self->{StatsObject}->StatsCleanUp();
}
# define function name
my $FunctionName = 'CodeReinstall';
# create the package name
my $CodeModule = 'var::packagesetup::' . $Param{Structure}->{Name}->{Content};
# load the module
if ( $Self->{MainObject}->Require($CodeModule) ) {
# create new instance
my $CodeObject = $CodeModule->new( %{$Self} );
if ($CodeObject) {
# start methode
if ( !$CodeObject->$FunctionName(%{$Self}) ) {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method $FunctionName() on $CodeModule.pm."
);
}
}
# error handling
else {
$Self->{LogObject}->Log(
Priority => 'error',
Message => "Could not call method new() on $CodeModule.pm."
);
}
}
2017-10-09 15:56:58
opms.otrs.com
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
<?xml version="1.0" encoding="iso-8859-1" ?>
<otrs_config version="1.0" init="Application">
    <ConfigItem Name="PostMaster::PreFilterModule###1-SystemMonitoring" Required="0" Valid="1">
        <Description Translatable="1">Basic mail interface to System Monitoring Suites. Use this block if the filter should run AFTER PostMasterFilter.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Core::PostMaster</SubGroup>
        <Setting>
            <Hash>
                <Item Key="Module">Kernel::System::PostMaster::Filter::SystemMonitoring</Item>
                <Item Key="FromAddressRegExp">nagios@example.com</Item>
                <Item Key="StateRegExp">\s*State:\s+(\S+)</Item>
                <Item Key="HostRegExp">\s*Host:\s+(.*)\s*</Item>
                <Item Key="ServiceRegExp">\s*Service:\s+(.*)\s*</Item>
                <Item Key="NewTicketRegExp">CRITICAL|DOWN</Item>
                <Item Key="CloseTicketRegExp">OK|UP</Item>
                <Item Key="CloseActionState">closed successful</Item>
                <Item Key="ClosePendingTime">172800</Item>
                <Item Key="DefaultService">Host</Item>
                <Item Key="FreeTextHost">1</Item>
                <Item Key="FreeTextService">2</Item>
                <Item Key="SenderType">system</Item>
                <Item Key="ArticleType">note-report</Item>
                <Item Key="FreeTextState">1</Item>
            </Hash>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="PostMaster::PreFilterModule###00-SystemMonitoring" Required="0" Valid="0">
        <Description Translatable="1">Basic mail interface to System Monitoring Suites. Use this block if the filter should run BEFORE PostMasterFilter.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Core::PostMaster</SubGroup>
        <Setting>
            <Hash>
                <Item Key="Module">Kernel::System::PostMaster::Filter::SystemMonitoring</Item>
                <Item Key="FromAddressRegExp">nagios@example.com</Item>
                <Item Key="StateRegExp">\s*State:\s+(\S+)</Item>
                <Item Key="HostRegExp">\s*Host:\s+(.*)\s*</Item>
                <Item Key="ServiceRegExp">\s*Service:\s+(.*)\s*</Item>
                <Item Key="NewTicketRegExp">CRITICAL|DOWN</Item>
                <Item Key="CloseTicketRegExp">OK|UP</Item>
                <Item Key="CloseActionState">closed successful</Item>
                <Item Key="ClosePendingTime">172800</Item>
                <Item Key="DefaultService">Host</Item>
                <Item Key="FreeTextHost">1</Item>
                <Item Key="FreeTextService">2</Item>
                <Item Key="SenderType">system</Item>
                <Item Key="ArticleType">note-report</Item>
                <Item Key="FreeTextState">1</Item>
            </Hash>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="SystemMonitoring::SetIncidentState" Required="0" Valid="1">
        <Description Translatable="1">Set the incident state of a CI automatically when a system monitoring email arrives.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Core::ConfigItem</SubGroup>
        <Setting>
            <Option SelectedID="0">
                <Item Key="0">No</Item>
                <Item Key="1">Yes</Item>
            </Option>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="SystemMonitoring::LinkTicketWithCI" Required="0" Valid="1">
        <Description Translatable="1">Link an already opened incident ticket with the affected CI. This is only possible when a subsequent system monitoring email arrives.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Core::ConfigItem</SubGroup>
        <Setting>
            <Option SelectedID="0">
                <Item Key="0">No</Item>
                <Item Key="1">Yes</Item>
            </Option>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::FreeField::Host" Required="1" Valid="1">
        <Description Translatable="1">Name of the Dynamic Field for Host.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">DynamicField_TicketFreeText1</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::FreeField::Service" Required="1" Valid="1">
        <Description Translatable="1">Name of the Dynamic Field for Service.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">DynamicField_TicketFreeText2</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::Type" Required="0" Valid="1">
        <Description Translatable="1">Define Nagios acknowledge type.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <Option SelectedID="">
                <Item Key="">-</Item>
                <Item Key="pipe">pipe</Item>
                <Item Key="http">http</Item>
            </Option>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::NamedPipe::CMD" Required="0" Valid="1">
        <Description Translatable="1">Named pipe acknowledge command.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">echo '&lt;OUTPUTSTRING&gt;' > /usr/local/nagios/var/rw/nagios.cmd</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::NamedPipe::Host" Required="0" Valid="1">
        <Description Translatable="1">Named pipe acknowledge format for host.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">[&lt;UNIXTIME&gt;] ACKNOWLEDGE_HOST_PROBLEM;&lt;HOST_NAME&gt;;1;1;1;&lt;LOGIN&gt;;&lt;a href="&lt;CONFIG_HttpType&gt;://&lt;CONFIG_FQDN&gt;/&lt;CONFIG_ScriptAlias&gt;index.pl?Action=AgentTicketZoom&amp;TicketID=&lt;TicketID&gt;"&gt;&lt;CONFIG_Ticket::Hook&gt;&lt;TicketNumber&gt;&lt;/a&gt;</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::NamedPipe::Service" Required="0" Valid="1">
        <Description Translatable="1">Named pipe acknowledge format for service.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">[&lt;UNIXTIME&gt;] ACKNOWLEDGE_SVC_PROBLEM;&lt;HOST_NAME&gt;;&lt;SERVICE_NAME&gt;;1;1;1;&lt;LOGIN&gt;;&lt;a href="&lt;CONFIG_HttpType&gt;://&lt;CONFIG_FQDN&gt;/&lt;CONFIG_ScriptAlias&gt;index.pl?Action=AgentTicketZoom&amp;TicketID=&lt;TicketID&gt;"&gt;&lt;CONFIG_Ticket::Hook&gt;&lt;TicketNumber&gt;&lt;/a&gt;</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Ticket::EventModulePost###9-NagiosAcknowledge" Required="1" Valid="1">
        <Description Translatable="1">Ticket event module to send an acknowlage to Nagios.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <Hash>
                <Item Key="Module">Kernel::System::Ticket::Event::NagiosAcknowledge</Item>
                <Item Key="Event">TicketLockUpdate</Item>
            </Hash>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::HTTP::URL" Required="0" Valid="1">
        <Description Translatable="1">The http acknowledge url.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">http://nagios.example.com/nagios/cgi-bin/cmd.cgi?cmd_typ=&lt;CMD_TYP&gt;&amp;cmd_mod=2&amp;host=&lt;HOST_NAME&gt;&amp;service=&lt;SERVICE_NAME&gt;&amp;sticky_ack=on&amp;send_notification=on&amp;persistent=on&amp;com_data=&lt;TicketNumber&gt;&amp;btnSubmit=Commit</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::HTTP::User" Required="0" Valid="1">
        <Description Translatable="1">The http acknowledge user.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">John</String>
        </Setting>
    </ConfigItem>
    <ConfigItem Name="Nagios::Acknowledge::HTTP::Password" Required="0" Valid="1">
        <Description Translatable="1">The http acknowledge password.</Description>
        <Group>SystemMonitoring</Group>
        <SubGroup>Nagios::Acknowledge</SubGroup>
        <Setting>
            <String Regex="">some_pass</String>
        </Setting>
    </ConfigItem>
</otrs_config>

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
# --
# Copyright (C) 2001-2017 OTRS AG, http://otrs.com/
# --
# 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.
# --

# important configuration items SystemMonitoring::SetIncidentState

package Kernel::System::PostMaster::Filter::SystemMonitoring;

use strict;
use warnings;

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

#the base name for dynamic fields

use constant DynamicFieldTicketTextPrefix  => 'TicketFreeText';
use constant DynamicFieldArticleTextPrefix => 'ArticleFreeText';

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

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

    $Self->{Debug} = $Param{Debug} || 0;

    # get needed objects
    for my $Object (
        qw(DBObject ConfigObject LogObject MainObject EncodeObject TicketObject TimeObject)
        )
    {
        $Self->{$Object} = $Param{$Object} || die "Got no $Object!";
    }

    # create additional objects
    $Self->{LinkObject}         = Kernel::System::LinkObject->new( %{$Self} );
    $Self->{DynamicFieldObject} = Kernel::System::DynamicField->new( %{$Self} );

    # check if CI incident state should be set automatically
    # this requires the ITSMConfigurationManagement module to be installed
    if ( $Self->{ConfigObject}->Get('SystemMonitoring::SetIncidentState') ) {

        $Self->_IncidentStateNew();
    }

    # Default Settings
    $Self->{Config} = {
        StateRegExp       => '\s*State:\s+(\S+)',
        FromAddressRegExp => 'sysmon@example.com',
        NewTicketRegExp   => 'CRITICAL|DOWN',
        CloseTicketRegExp => 'OK|UP',
        CloseActionState  => 'closed successful',
        ClosePendingTime  => 60 * 60 * 24 * 2,                          # 2 days
        HostRegExp        => '\s*Address:\s+(\d+\.\d+\.\d+\.\d+)\s*',
        FreeTextHost      => '1',
        FreeTextService   => '2',
        FreeTextState     => '1',
        ServiceRegExp     => '\s*Service:\s+(.*)\s*',
        DefaultService    => 'Host',
        SenderType        => 'system',
        ArticleType       => 'note-report',
    };

    return $Self;
}

sub _GetDynamicFieldDefinition {
    my $Self       = shift;
    my $Config     = shift;
    my $Key        = shift;    #FreeTextHost the config key
    my $Default    = shift;    #1 the default value
    my $Base       = shift;    # DynamicFieldTicketTextPrefix
    my $Name       = shift;    #HostName
    my $ObjectType = shift;    #HostName

    my $ConfigFreeText = $Config->{$Key};

    if ( !$ConfigFreeText ) {
        $ConfigFreeText = $Default;
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Missing CI Config $Key, using value $Default!"
        );
    }

    if ( $ConfigFreeText =~ /^\d+$/ ) {
        if ( ( $ConfigFreeText < 1 ) || ( $ConfigFreeText > 16 ) ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Bad value $ConfigFreeText for CI Config $Key, must be between 1 and 16!"
            );
            die "Bad value $ConfigFreeText for CI Config $Key!";
        }
    }
    else
    {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Bad value $ConfigFreeText for CI Config $Key, must be numeric!"
        );
        die "Bad value $ConfigFreeText for CI Config $Key!";
    }

    my $FieldNameHost = $Base . $ConfigFreeText;

    # define all dynamic fields for System Monitoring, these need to be changed as well if the config changes
    return (
        {
            Name       => $FieldNameHost,
            Label      => 'SystemMonitoring ' . $Name,
            FieldType  => 'Text',
            ObjectType => $ObjectType,
            Config     => {
                TranslatableValues => 1,
            },
        }
    );
}

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

    my $Config = $Param{Config};

    push @{ $Param{NewFields} },
        _GetDynamicFieldDefinition(
        $Self, $Config, "FreeTextHost", 1, DynamicFieldTicketTextPrefix,
        "HostName", "Ticket"
        );
    push @{ $Param{NewFields} },
        _GetDynamicFieldDefinition(
        $Self, $Config, "FreeTextService", 2,
        DynamicFieldTicketTextPrefix, "ServiceName", "Ticket"
        );
    push @{ $Param{NewFields} },
        _GetDynamicFieldDefinition(
        $Self, $Config, "FreeTextState", 1,
        DynamicFieldArticleTextPrefix, "StateName", "Article"
        );

    return 1;
}

sub _IncidentStateIncident {
    my $Self = shift || die "missing self";

    # set the CI incident state to 'Incident'
    $Self->_SetIncidentState(
        Name          => $Self->{Host},
        IncidentState => 'Incident',
    );

}

sub _IncidentStateOperational {
    my $Self = shift || die "missing self";

    # set the CI incident state to 'Operational'
    $Self->_SetIncidentState(
        Name          => $Self->{Host},
        IncidentState => 'Operational',
    );
}

# these are optional modules from the ITSM Kernel::System::GeneralCatalog and Kernel::System::ITSMConfigItem

sub _IncidentStateNew {
    my $Self = shift || die "missing self";

    # require the general catalog module
    if ( $Self->{MainObject}->Require('Kernel::System::GeneralCatalog') ) {

        # create general catalog object
        $Self->{GeneralCatalogObject} = Kernel::System::GeneralCatalog->new( %{$Self} );
    }

    # require the config item module
    if ( $Self->{MainObject}->Require('Kernel::System::ITSMConfigItem') ) {

        # create config item object
        $Self->{ConfigItemObject} = Kernel::System::ITSMConfigItem->new( %{$Self} );
    }
}

sub _MailParse {
    my $Self = shift || die "missing self";
    my %Param = @_;

    my $Subject = $Param{GetParam}->{Subject} || die "No Param Subject";

    # Try to get State, Host and Service from email subject
    my @SubjectLines = split /\n/, $Subject;
    for my $Line (@SubjectLines) {
        for (qw(State Host Service)) {
            if ( $Line =~ /$Self->{Config}->{ $_ . 'RegExp' }/ ) {
                $Self->{$_} = $1;
            }
        }
    }

    #  Dont Try to get State, Host and Service from email body, we want it from the subject alone

    # split the body into separate lines
    my $Body = $Param{GetParam}->{Body} || die "Message has no Body";

    my @BodyLines = split /\n/, $Body;

    # to remember if an element was found before
    my %AlreadyMatched;

    LINE:
    for my $Line (@BodyLines) {

        # Try to get State, Host and Service from email body
        ELEMENT:
        for my $Element (qw(State Host Service)) {

            next ELEMENT if $AlreadyMatched{$Element};

            my $Regex = $Self->{Config}->{ $Element . 'RegExp' };

            if ( $Line =~ /$Regex/ ) {

                # get the found element value
                $Self->{$Element} = $1;

                # remember that we found this element already
                $AlreadyMatched{$Element} = 1;
            }
        }
    }
}

sub _LogMessage {
    my $Self        = shift;
    my $MessageText = shift;

    # logging
    # define log message
    $Self->{Service} ||= "No Service";
    $Self->{State}   ||= "No State";
    $Self->{Host}    ||= "No Host";

    my $LogMessage = $MessageText . " - "
        . "Host: $Self->{Host}, "
        . "State: $Self->{State}, "
        . "Service: $Self->{Service}";

    $Self->{LogObject}->Log(
        Priority => 'notice',
        Message  => 'SystemMonitoring Mail: ' . $LogMessage,
    );
}

sub _TicketSearch {
    my $Self = shift || die "missing self";

    # Is there a ticket for this Host/Service pair?
    my %Query = (
        Result    => 'ARRAY',
        Limit     => 1,
        UserID    => 1,
        StateType => 'Open',
    );

    for my $Type (qw(Host Service)) {
        my $FreeTextField = $Self->{Config}->{ 'FreeText' . $Type };
        my $KeyName       = "DynamicField_" . DynamicFieldTicketTextPrefix . $FreeTextField;
        my $KeyValue      = $Self->{$Type};

        $Query{$KeyName}->{Equals} = $KeyValue;
    }

    # Check if dynamic fields really exists.
    # If dynamic fields don't exists, TicketSearch will return all tickets
    # and then the new article/ticket could take wrong place.
    # The lesser of the three evils is to create a new ticket
    # instead of defacing existing tickets or dropping it.
    # This behaviour will come true if the dynamic fields
    # are named like TicketFreeTextHost. Its also bad.
    my $Errors = 0;
    for my $Type (qw(Host Service)) {
        my $FreeTextField = $Self->{Config}->{ 'FreeText' . $Type };

        my $DynamicField = $Self->{DynamicFieldObject}->DynamicFieldGet(
            'Name' => DynamicFieldTicketTextPrefix . $FreeTextField,
        );

        if ( !IsHashRefWithData($DynamicField) || $FreeTextField !~ m{\d+}xms ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "DynamicField "
                    . DynamicFieldTicketTextPrefix
                    . $FreeTextField
                    . " does not exists or missnamed."
                    . " The configuration is based on freetext fields, so the number of the freetext field is expected"
                    . " (wrong value for key FreeText" . $Type . " is set).",
            );
            $Errors = 1;
        }
    }

    my $ArticleFreeTextField = $Self->{Config}->{'FreeTextState'};
    my $DynamicFieldArticle  = $Self->{DynamicFieldObject}->DynamicFieldGet(
        'Name' => DynamicFieldArticleTextPrefix . $ArticleFreeTextField,
    );

    if ( !IsHashRefWithData($DynamicFieldArticle) || $ArticleFreeTextField !~ m{\d+}xms ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "DynamicField "
                . DynamicFieldArticleTextPrefix
                . $ArticleFreeTextField
                . " does not exists or missnamed."
                . " The configuration is based on freetext fields, so the number of the freetext field is expected"
                . " (wrong value for key FreeTextState is set).",
        );
        $Errors = 1;
    }

    my @TicketIDs = $Self->{TicketObject}->TicketSearch(%Query);

    # get the first and only ticket id
    my $TicketID;
    if ( !$Errors && @TicketIDs ) {
        $TicketID = shift @TicketIDs;
    }

    return $TicketID;

}

# the sub takes the param as a hashref not as a copy, because it is updated

sub _TicketUpdate {
    my $Self     = shift || die "missing self";
    my $TicketID = shift || die "missing ticketid";
    my $Param    = shift || die "missing param hashref";

    # get ticket number
    my $TicketNumber = $Self->{TicketObject}->TicketNumberLookup(
        TicketID => $TicketID,
        UserID   => 1,
    );

    # build subject
    $Param->{GetParam}->{Subject} = $Self->{TicketObject}->TicketSubjectBuild(
        TicketNumber => $TicketNumber,
        Subject      => $Param->{GetParam}->{Subject},
    );

    # set sender type and article type
    $Param->{GetParam}->{'X-OTRS-FollowUp-SenderType'}  = $Self->{Config}->{SenderType};
    $Param->{GetParam}->{'X-OTRS-FollowUp-ArticleType'} = $Self->{Config}->{ArticleType};

    # Set Article Free Field for State
    my $ArticleFreeTextNumber = $Self->{Config}->{'FreeTextState'};
    $Param->{GetParam}->{ 'X-OTRS-FollowUp-ArticleKey' . $ArticleFreeTextNumber }   = 'State';
    $Param->{GetParam}->{ 'X-OTRS-FollowUp-ArticleValue' . $ArticleFreeTextNumber } = $Self->{State};

    if ( $Self->{State} =~ /$Self->{Config}->{CloseTicketRegExp}/ ) {

        # Close Ticket Condition -> Take Close Action
        if ( $Self->{Config}->{CloseActionState} ne 'OLD' ) {
            $Param->{GetParam}->{'X-OTRS-FollowUp-State'} = $Self->{Config}->{CloseActionState};

            my $TimeStamp = $Self->{TimeObject}->SystemTime2TimeStamp(
                SystemTime => $Self->{TimeObject}->SystemTime()
                    + $Self->{Config}->{ClosePendingTime},
            );
            $Param->{GetParam}->{'X-OTRS-State-PendingTime'} = $TimeStamp;
        }

        # set log message
        $Self->_LogMessage('Recovered');

        # if the CI incident state should be set
        if ( $Self->{ConfigObject}->Get('SystemMonitoring::SetIncidentState') ) {
            $Self->_IncidentStateOperational();
        }
    }
    else {

        # Attach note to existing ticket
        $Self->_LogMessage('New Notice');
    }

    # link ticket with CI, this is only possible if the ticket already exists,
    # e.g. in a subsequent email request, because we need a ticket id
    if ( $Self->{ConfigObject}->Get('SystemMonitoring::LinkTicketWithCI') ) {

        # link ticket with CI
        $Self->_LinkTicketWithCI(
            Name     => $Self->{Host},
            TicketID => $TicketID,
        );
    }
}

# the sub takes the param as a hashref not as a copy, because it is updated

sub _TicketCreate {
    my $Self  = shift || die "missing self";
    my $Param = shift || die "missing param hashref";

    # Create Ticket Condition -> Create new Ticket and record Host and Service
    for (qw(Host Service)) {

        # get the freetext number from config
        my $TicketFreeTextNumber = $Self->{Config}->{ 'FreeText' . $_ };

        # see the Kernel::System::PostMaster::NewTicket  where this is read
        $Param->{GetParam}->{ 'X-OTRS-TicketKey' . $TicketFreeTextNumber }   = $_;
        $Param->{GetParam}->{ 'X-OTRS-TicketValue' . $TicketFreeTextNumber } = $Self->{$_};
    }

    # Set Article Free Field for State
    my $ArticleFreeTextNumber = $Self->{Config}->{'FreeTextState'};
    $Param->{GetParam}->{ 'X-OTRS-ArticleKey' . $ArticleFreeTextNumber }   = 'State';
    $Param->{GetParam}->{ 'X-OTRS-ArticleValue' . $ArticleFreeTextNumber } = $Self->{State};

    # set sender type and article type
    $Param->{GetParam}->{'X-OTRS-SenderType'}  = $Self->{Config}->{SenderType};
    $Param->{GetParam}->{'X-OTRS-ArticleType'} = $Self->{Config}->{ArticleType};

    # set log message
    $Self->_LogMessage('New Ticket');

    # if the CI incident state should be set
    if ( $Self->{ConfigObject}->Get('SystemMonitoring::SetIncidentState') ) {
        $Self->_IncidentStateIncident();
    }
}

# the sub takes the param as a hashref not as a copy, because it is updated

sub _TicketDrop {
    my $Self  = shift || die "missing self";
    my $Param = shift || die "missing param hashref";

    # No existing ticket and no open condition -> drop silently
    $Param->{GetParam}->{'X-OTRS-Ignore'} = 'yes';
    $Self->_LogMessage('Mail Dropped, no matching ticket found, no open on this state ');

}

sub Run {

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

    # get config options, use defaults unless value specified
    if ( $Param{JobConfig} && ref $Param{JobConfig} eq 'HASH' ) {
        KEY:
        for my $Key ( keys( %{ $Param{JobConfig} } ) ) {
            next KEY if !$Self->{Config}->{$Key};
            $Self->{Config}->{$Key} = $Param{JobConfig}->{$Key};
        }
    }

    # check if sender is of interest
    return 1 if !$Param{GetParam}->{From};
    return 1 if $Param{GetParam}->{From} !~ /$Self->{Config}->{FromAddressRegExp}/i;

    $Self->_MailParse(%Param);

    # we need State and Host to proceed
    if ( !$Self->{State} || !$Self->{Host} ) {

        $Self->{LogObject}->Log(
            Priority => 'notice',
            Message  => 'SystemMonitoring Mail: '
                . 'SystemMonitoring: Could not find host address '
                . 'and/or state in mail => Ignoring',
        );
        return 1;
    }

    # Check for Service
    $Self->{Service} ||= $Self->{Config}->{DefaultService};

    my $TicketID = $Self->_TicketSearch();

    # OK, found ticket to deal with
    if ($TicketID) {
        $Self->_TicketUpdate( $TicketID, \%Param );
    }
    elsif ( $Self->{State} =~ /$Self->{Config}->{NewTicketRegExp}/ ) {
        $Self->_TicketCreate( \%Param );
    }
    else {
        $Self->_TicketDrop( \%Param );
    }

    return 1;
}

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

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

    # check configitem object
    return if !$Self->{ConfigItemObject};

    # search configitem
    my $ConfigItemIDs = $Self->{ConfigItemObject}->ConfigItemSearchExtended(
        Name => $Param{Name},
    );

    # if no config item with this name was found
    if ( !$ConfigItemIDs || ref $ConfigItemIDs ne 'ARRAY' || !@{$ConfigItemIDs} ) {

        # log error
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Could not find any CI with the name '$Param{Name}'. ",
        );
        return;
    }

    # if more than one config item with this name was found
    if ( scalar @{$ConfigItemIDs} > 1 ) {

        # log error
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Can not set incident state for CI with the name '$Param{Name}'. "
                . "More than one CI with this name was found!",
        );
        return;
    }

    # we only found one config item
    my $ConfigItemID = shift @{$ConfigItemIDs};

    # get config item
    my $ConfigItem = $Self->{ConfigItemObject}->ConfigItemGet(
        ConfigItemID => $ConfigItemID,
    );

    # get latest version data of config item
    my $Version = $Self->{ConfigItemObject}->VersionGet(
        ConfigItemID => $ConfigItemID,
    );

    return if !$Version;
    return if ref $Version ne 'HASH';

    # get incident state list
    my $InciStateList = $Self->{GeneralCatalogObject}->ItemList(
        Class => 'ITSM::Core::IncidentState',
    );

    return if !$InciStateList;
    return if ref $InciStateList ne 'HASH';

    # reverse the incident state list
    my %ReverseInciStateList = reverse %{$InciStateList};

    # check if incident state is valid
    if ( !$ReverseInciStateList{ $Param{IncidentState} } ) {

        # log error
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Invalid incident state '$Param{IncidentState}'!",
        );
        return;
    }

    # add a new version with the new incident state
    my $VersionID = $Self->{ConfigItemObject}->VersionAdd(
        %{$Version},
        InciStateID => $ReverseInciStateList{ $Param{IncidentState} },
        UserID      => 1,
    );

    return $VersionID;
}

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

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

    # check configitem object
    return if !$Self->{ConfigItemObject};

    # search configitem
    my $ConfigItemIDs = $Self->{ConfigItemObject}->ConfigItemSearchExtended(
        Name => $Param{Name},
    );

    # if no config item with this name was found
    if ( !$ConfigItemIDs || ref $ConfigItemIDs ne 'ARRAY' || !@{$ConfigItemIDs} ) {

        # log error
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Could not find any CI with the name '$Param{Name}'. ",
        );
        return;
    }

    # if more than one config item with this name was found
    if ( scalar @{$ConfigItemIDs} > 1 ) {

        # log error
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Can not set incident state for CI with the name '$Param{Name}'. "
                . "More than one CI with this name was found!",
        );
        return;
    }

    # we only found one config item
    my $ConfigItemID = shift @{$ConfigItemIDs};

    # link the ticket with the CI
    my $LinkResult = $Self->{LinkObject}->LinkAdd(
        SourceObject => 'Ticket',
        SourceKey    => $Param{TicketID},
        TargetObject => 'ITSMConfigItem',
        TargetKey    => $ConfigItemID,
        Type         => 'RelevantTo',
        State        => 'Valid',
        UserID       => 1,
    );

    return $LinkResult;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (L<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 L<http://www.gnu.org/licenses/agpl.txt>.

=cut

=cut

# --
# Copyright (C) 2001-2017 OTRS AG, http://otrs.com/
# --
# 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::Ticket::Event::NagiosAcknowledge;

use strict;
use warnings;
use LWP::UserAgent;
use URI::Escape qw();

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

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

    # get needed objects
    for (
        qw(ConfigObject TicketObject LogObject UserObject CustomerUserObject SendmailObject TimeObject EncodeObject UserObject)
        )
    {
        $Self->{$_} = $Param{$_} || die "Got no $_!";
    }

    # get correct FreeFields
    $Self->{Fhost}    = $Self->{ConfigObject}->Get('Nagios::Acknowledge::FreeField::Host');
    $Self->{Fservice} = $Self->{ConfigObject}->Get('Nagios::Acknowledge::FreeField::Service');

    return $Self;
}

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

    # check needed stuff
    for (qw(Data Event Config)) {
        if ( !$Param{$_} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "Need $_!"
            );
            return;
        }
    }

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

    # check if acknowledge is active
    my $Type = $Self->{ConfigObject}->Get('Nagios::Acknowledge::Type');
    return 1 if !$Type;

    # check if it's a Nagios related ticket
    my %Ticket = $Self->{TicketObject}->TicketGet(
        TicketID      => $Param{Data}->{TicketID},
        DynamicFields => 1,
    );
    if ( !$Ticket{ $Self->{Fhost} } ) {
        $Self->{LogObject}->Log(
            Priority => 'debug',
            Message  => "No Nagios Ticket!"
        );
        return 1;
    }

    # check if it's an acknowledge
    return 1 if $Ticket{Lock} ne 'lock';

    # agent lookup
    my %User = $Self->{UserObject}->GetUserData(
        UserID => $Param{UserID},
        Cached => 1,                # not required -> 0|1 (default 0)
    );

    my $Return;
    if ( $Type eq 'pipe' ) {
        $Return = $Self->_Pipe(
            Ticket => \%Ticket,
            User   => \%User,
        );
    }
    elsif ( $Type eq 'http' ) {
        $Return = $Self->_HTTP(
            Ticket => \%Ticket,
            User   => \%User,
        );
    }
    else {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Unknown Nagios acknowledge type ($Type)!",
        );
        return 1;
    }

    if ($Return) {
        $Self->{TicketObject}->HistoryAdd(
            TicketID     => $Param{Data}->{TicketID},
            HistoryType  => 'Misc',
            Name         => "Sent Acknowledge to Nagios ($Type).",
            CreateUserID => $Param{UserID},
        );
        return 1;
    }
    else {
        $Self->{TicketObject}->HistoryAdd(
            TicketID     => $Param{Data}->{TicketID},
            HistoryType  => 'Misc',
            Name         => "Was not able to send Acknowledge to Nagios ($Type)!",
            CreateUserID => $Param{UserID},
        );
        return;
    }
}

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

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

    # send acknowledge to nagios
    my $CMD = $Self->{ConfigObject}->Get('Nagios::Acknowledge::NamedPipe::CMD');
    my $Data;
    if ( $Ticket{ $Self->{Fservice} } !~ /^host$/i ) {
        $Data = $Self->{ConfigObject}->Get('Nagios::Acknowledge::NamedPipe::Service');
    }
    else {
        $Data = $Self->{ConfigObject}->Get('Nagios::Acknowledge::NamedPipe::Host');
    }

    # replace ticket tags
    for my $Key ( sort keys %Ticket ) {
        next if !defined $Ticket{$Key};

        # strip not allowed characters
        $Ticket{$Key} =~ s/'//g;
        $Ticket{$Key} =~ s/;//g;
        $Data =~ s/<$Key>/$Ticket{$Key}/g;
    }

    # replace config tags
    $Data =~ s{<CONFIG_(.+?)>}{$Self->{ConfigObject}->Get($1)}egx;

    # replace login
    $Data =~ s/<LOGIN>/$User{UserLogin}/g;

    # replace host
    $Data =~ s/<HOST_NAME>/$Ticket{$Self->{Fhost}}/g;

    # replace time stamp
    $Data =~ s/<SERVICE_NAME>/$Ticket{$Self->{Fservice}}/g;

    # replace time stamp
    my $Time = time();
    $Data =~ s/<UNIXTIME>/$Time/g;

    # replace OUTPUTSTRING
    $CMD =~ s/<OUTPUTSTRING>/$Data/g;

    #print STDOUT "$CMD\n";
    system($CMD );

    return 1;
}

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

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

    my $URL  = $Self->{ConfigObject}->Get('Nagios::Acknowledge::HTTP::URL');
    my $User = $Self->{ConfigObject}->Get('Nagios::Acknowledge::HTTP::User');
    my $Pw   = $Self->{ConfigObject}->Get('Nagios::Acknowledge::HTTP::Password');

    if ( $Ticket{ $Self->{Fservice} } !~ /^host$/i ) {
        $URL =~ s/<CMD_TYP>/34/g;
    }
    else {
        $URL =~ s/<CMD_TYP>/33/g;
    }

    # replace host
    $URL =~ s/<HOST_NAME>/$Ticket{$Self->{Fhost}}/g;

    # replace time stamp
    $URL =~ s/<SERVICE_NAME>/$Ticket{$Self->{Fservice}}/g;

    # replace ticket tags

    for my $Key ( sort keys %Ticket ) {
        next if !defined $Ticket{$Key};

        # URLencode values
        $Ticket{$Key} = URI::Escape::uri_escape_utf8( $Ticket{$Key} );
        $URL =~ s/<$Key>/$Ticket{$Key}/g;
    }

    # replace config tags
    $URL =~ s{<CONFIG_(.+?)>}{$Self->{ConfigObject}->Get($1)}egx;

    my $UserAgent = LWP::UserAgent->new();
    $UserAgent->timeout(15);

    my $Request = HTTP::Request->new( GET => $URL );
    $Request->authorization_basic( $User, $Pw );
    my $Response = $UserAgent->request($Request);
    if ( !$Response->is_success() ) {
        $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Can't request $URL: " . $Response->status_line(),
        );
        return;
    }

    #    return $Response->content();

    return 1;
}
1;

IyAtLQojIENvcHlyaWdodCAoQykgMjAwMS0yMDE3IE9UUlMgQUcsIGh0dHA6Ly9vdHJzLmNvbS8KIyAtLQojIFRoaXMgc29mdHdhcmUgY29tZXMgd2l0aCBBQlNPTFVURUxZIE5PIFdBUlJBTlRZLiBGb3IgZGV0YWlscywgc2VlCiMgdGhlIGVuY2xvc2VkIGZpbGUgQ09QWUlORyBmb3IgbGljZW5zZSBpbmZvcm1hdGlvbiAoQUdQTCkuIElmIHlvdQojIGRpZCBub3QgcmVjZWl2ZSB0aGlzIGZpbGUsIHNlZSBodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvYWdwbC50eHQuCiMgLS0KCiMjIG5vZmlsdGVyKFRpZHlBbGw6OlBsdWdpbjo6T1RSUzo6UGVybDo6UGVybENyaXRpYykKCnVzZSBLZXJuZWw6OlN5c3RlbTo6VGlja2V0Owp1c2UgS2VybmVsOjpTeXN0ZW06OlBvc3RNYXN0ZXI7CgpteSAkRmlsZUFycmF5ID0gJFNlbGYtPntNYWluT2JqZWN0fS0+RmlsZVJlYWQoCiAgICBMb2NhdGlvbiA9PiAkU2VsZi0+e0NvbmZpZ09iamVjdH0tPkdldCgnSG9tZScpIC4gJy9zY3JpcHRzL3Rlc3Qvc2FtcGxlL1N5c3RlbU1vbml0b3JpbmcxLmJveCcsCiAgICBSZXN1bHQgPT4gJ0FSUkFZJywgICAgIyBvcHRpb25hbCAtIFNDQUxBUnxBUlJBWQopOwoKbXkgJFBvc3RNYXN0ZXJPYmplY3QgPSBLZXJuZWw6OlN5c3RlbTo6UG9zdE1hc3Rlci0+bmV3KAogICAgJXskU2VsZn0sCiAgICBFbWFpbCA9PiAkRmlsZUFycmF5LAopOwoKbXkgQFJldHVybiA9ICRQb3N0TWFzdGVyT2JqZWN0LT5SdW4oKTsKJFNlbGYtPklzKAogICAgJFJldHVyblswXSB8fCAwLAogICAgMSwKICAgICJSdW4oKSAtIE5ld1RpY2tldCIsCik7CiRTZWxmLT5UcnVlKAogICAgJFJldHVyblsxXSB8fCAwLAogICAgIlJ1bigpIC0gTmV3VGlja2V0L1RpY2tldElEIiwKKTsKCm15ICRUaWNrZXRPYmplY3QgPSBLZXJuZWw6OlN5c3RlbTo6VGlja2V0LT5uZXcoICV7JFNlbGZ9ICk7Cm15ICVUaWNrZXQgICAgICAgPSAkVGlja2V0T2JqZWN0LT5UaWNrZXRHZXQoCiAgICBUaWNrZXRJRCAgICAgID0+ICRSZXR1cm5bMV0sCiAgICBEeW5hbWljRmllbGRzID0+IDEsCik7CgokU2VsZi0+SXMoCiAgICAkVGlja2V0e0R5bmFtaWNGaWVsZF9UaWNrZXRGcmVlVGV4dDF9LAogICAgJ2RlbHBoaW4nLAogICAgIkhvc3QgY2hlY2siLAopOwoKJFNlbGYtPklzKAogICAgJFRpY2tldHtEeW5hbWljRmllbGRfVGlja2V0RnJlZVRleHQyfSwKICAgICdIb3N0JywKICAgICJTZXJ2aWNlIGNoZWNrIiwKKTsKJFNlbGYtPklzKAogICAgJFRpY2tldHtTdGF0ZX0sCiAgICAnbmV3JywKICAgICJSdW4oKSAtIFRpY2tldCBTdGF0ZSIsCik7CgokRmlsZUFycmF5ID0gJFNlbGYtPntNYWluT2JqZWN0fS0+RmlsZVJlYWQoCiAgICBMb2NhdGlvbiA9PiAkU2VsZi0+e0NvbmZpZ09iamVjdH0tPkdldCgnSG9tZScpIC4gJy9zY3JpcHRzL3Rlc3Qvc2FtcGxlL1N5c3RlbU1vbml0b3JpbmcyLmJveCcsCiAgICBSZXN1bHQgPT4gJ0FSUkFZJywgICAgIyBvcHRpb25hbCAtIFNDQUxBUnxBUlJBWQopOwoKJFBvc3RNYXN0ZXJPYmplY3QgPSBLZXJuZWw6OlN5c3RlbTo6UG9zdE1hc3Rlci0+bmV3KAogICAgJXskU2VsZn0sCiAgICBFbWFpbCA9PiAkRmlsZUFycmF5LAopOwoKQFJldHVybiA9ICRQb3N0TWFzdGVyT2JqZWN0LT5SdW4oKTsKJFNlbGYtPklzKAogICAgJFJldHVyblswXSB8fCAwLAogICAgMiwKICAgICJSdW4oKSAtIE5ld1RpY2tldCIsCik7CiRTZWxmLT5UcnVlKAogICAgJFJldHVyblsxXSA9PSAkVGlja2V0e1RpY2tldElEfSwKICAgICJSdW4oKSAtIE5ld1RpY2tldC9UaWNrZXRJRCIsCik7CgokVGlja2V0T2JqZWN0ID0gS2VybmVsOjpTeXN0ZW06OlRpY2tldC0+bmV3KCAleyRTZWxmfSApOwolVGlja2V0ICAgICAgID0gJFRpY2tldE9iamVjdC0+VGlja2V0R2V0KAogICAgVGlja2V0SUQgPT4gJFJldHVyblsxXSwKKTsKJFNlbGYtPklzKAogICAgJFRpY2tldHtTdGF0ZX0sCiAgICAnY2xvc2VkIHN1Y2Nlc3NmdWwnLAogICAgIlJ1bigpIC0gVGlja2V0IFN0YXRlIiwKKTsKCiMgZGVsZXRlIHRpY2tldApteSAkRGVsZXRlID0gJFRpY2tldE9iamVjdC0+VGlja2V0RGVsZXRlKAogICAgVGlja2V0SUQgPT4gJFJldHVyblsxXSwKICAgIFVzZXJJRCAgID0+IDEsCik7CiRTZWxmLT5UcnVlKAogICAgJERlbGV0ZSB8fCAwLAogICAgIlRpY2tldERlbGV0ZSgpIiwKKTsKCjE7Cg==
UmV0dXJuLVBhdGg6IDxuYWdpb3NAZXhhbXBsZS5jb20+ClRvOiBvdHJzQGV4YW1wbGUuY29tClN1YmplY3Q6ICoqIFBST0JMRU0gYWxlcnQgMSAtIGRlbHBoaW4gaG9zdCBpcyBET1dOICoqCk1lc3NhZ2UtSWQ6IDwyMDA3MDMxNzIzMTU0Ni4wREZENTVEQzAwRkBoNTM3OTUuZXhhbXBsZS5jb20+CkRhdGU6IFN1biwgMTggTWFyIDIwMDcgMDA6MTU6NDYgKzAxMDAgKENFVCkKRnJvbTogbmFnaW9zQGV4YW1wbGUuY29tCk1pbWUtVmVyc2lvbjogMS4wCgoqKioqKiBOYWdpb3MgICoqKioqCgpOb3RpZmljYXRpb24gVHlwZTogUFJPQkxFTQpIb3N0OiBkZWxwaGluClN0YXRlOiBET1dOIGZvciAwZCAwaCAwbSAwcwpBZGRyZXNzOiAxMjcuMS4xLjEKSW5mbzoKCkNSSVRJQ0FMIC0gVGltZSB0byBsaXZlIGV4Y2VlZGVkICgxMjcuMS4xLjEpCgpEYXRlL1RpbWU6IFN1biBNYXIgMTggMDA6MTg6MzAgQ0VUIDIwMDcKCkFDSyBieTogCkNvbW1lbnQ6CiAKCgo=
UmV0dXJuLVBhdGg6IDxuYWdpb3NAZXhhbXBsZS5jb20+ClRvOiBvdHJzQGV4YW1wbGUuY29tClN1YmplY3Q6ICoqIFJFQ09WRVJZIGFsZXJ0IDIgLSBkZWxwaGluIGhvc3QgaXMgVVAgKioKTWVzc2FnZS1JZDogPDIwMDcwMzE3MjMxOTQ2LjBERkQ1NURDMDBGQGg1Mzc5NS5leGFtcGxlLmNvbT4KRGF0ZTogU3VuLCAxOCBNYXIgMjAwNyAwMDoxOTo0NiArMDEwMCAoQ0VUKQpGcm9tOiBuYWdpb3NAZXhhbXBsZS5jb20KTWltZS1WZXJzaW9uOiAxLjAKCioqKioqIE5hZ2lvcyAgKioqKioKCk5vdGlmaWNhdGlvbiBUeXBlOiBSRUNPVkVSWQpIb3N0OiBkZWxwaGluClN0YXRlOiBVUCBmb3IgMGQgMGggMG0gMHMKQWRkcmVzczogMTcyLjEuMS4xCkluZm86CgpQSU5HIE9LIC0gUGFja2V0IGxvc3MgPSAwJSwgUlRBID0gMTUuMDkgbXMKCkRhdGUvVGltZTogU3VuIE1hciAxOCAwMDoxOTo0NiBDRVQgMjAwNwoKQUNLIGJ5OiAKQ29tbWVudDogCg==
# --
# Copyright (C) 2001-2017 OTRS AG, http://otrs.com/
# --
# 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 var::packagesetup::SystemMonitoring;

use strict;
use warnings;

use Kernel::Config;
use Kernel::System::SysConfig;
use Kernel::System::Ticket;
use Kernel::System::Type;
use Kernel::System::Valid;
use Kernel::System::DynamicField;

use vars qw(@ISA $VERSION);
use YAML;

=head1 NAME

SystemMonitoring.pm - code to excecute during package installation

=head1 SYNOPSIS

All functions

=head1 PUBLIC INTERFACE

=over 4

=cut

=item new()

create an object

    use Kernel::Config;
    use Kernel::System::Encode;
    use Kernel::System::Log;
    use Kernel::System::Main;
    use Kernel::System::Time;
    use Kernel::System::DB;
    use Kernel::System::XML;
    use var::packagesetup::SystemMonitoring;

    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 $TimeObject = Kernel::System::Time->new(
        ConfigObject => $ConfigObject,
        LogObject    => $LogObject,
    );
    my $DBObject = Kernel::System::DB->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
    );
    my $XMLObject = Kernel::System::XML->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
        LogObject    => $LogObject,
        DBObject     => $DBObject,
        MainObject   => $MainObject,
    );
    my $CodeObject = var::packagesetup::SystemMonitoring->new(
        ConfigObject => $ConfigObject,
        EncodeObject => $EncodeObject,
        LogObject    => $LogObject,
        MainObject   => $MainObject,
        TimeObject   => $TimeObject,
        DBObject     => $DBObject,
        XMLObject    => $XMLObject,
    );

=cut

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

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

    # check needed objects
    for my $Object (
        qw( ConfigObject EncodeObject LogObject MainObject TimeObject DBObject XMLObject )
        )
    {
        $Self->{$Object} = $Param{$Object} ||
            $Self->{LogObject}->Log(
            Priority => 'error',
            Message  => "Missing parameter for $Object!",
            );
    }

    # create needed sysconfig object
    $Self->{SysConfigObject} = Kernel::System::SysConfig->new( %{$Self} );

    $Self->{TicketObject} = Kernel::System::Ticket->new( %{$Self} );

    # rebuild ZZZ* files
    $Self->{SysConfigObject}->WriteDefault();

    # define the ZZZ files
    my @ZZZFiles = (
        'ZZZAAuto.pm',
        'ZZZAuto.pm',
    );

    # reload the ZZZ files (mod_perl workaround)
    for my $ZZZFile (@ZZZFiles) {

        PREFIX:
        for my $Prefix (@INC) {
            my $File = $Prefix . '/Kernel/Config/Files/' . $ZZZFile;
            next PREFIX if !-f $File;

            do $File;
            last PREFIX;
        }
    }

    # create needed objects? again?
    $Self->{ConfigObject} = Kernel::Config->new();

    $Self->{TypeObject}         = Kernel::System::Type->new( %{$Self} );
    $Self->{ValidObject}        = Kernel::System::Valid->new( %{$Self} );
    $Self->{DynamicFieldObject} = Kernel::System::DynamicField->new( %{$Self} );

    return $Self;
}

=item CodeInstall()

run the code install part

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

=cut

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

    $Self->_CreateDynamicFields();

    return 1;
}

=item CodeReinstall()

run the code reinstall part

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

=cut

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

    return 1;
}

=item CodeUpgrade()

run the code upgrade part

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

=cut

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

    return 1;
}

=item CodeUpgradeFromLowerThan_2_2_92()

This function is only executed if the installed module version is smaller than 2.2.92.

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

=cut

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

    # get the definition for all dynamic fields for SystemMonitoring
    my @DynamicFields = $Self->_GetDynamicFieldsDefinition();

    # clean up the migrated freetext and freetime fields
    # e.g. delete the possible values for fields that use the general catalog
    DYNAMICFIELD:
    for my $DynamicFieldNew (@DynamicFields) {

        # get existing dynamic field data
        my $DynamicFieldOld = $Self->{DynamicFieldObject}->DynamicFieldGet(
            Name => $DynamicFieldNew->{Name},
        );

        if ( !exists $DynamicFieldOld->{ID} ) {
            $Self->{LogObject}->Log(
                Priority => 'error',
                Message  => "The old Field does not exist $DynamicFieldNew->{Name}, skipping."
            );
            next;
        }

        # update the dynamic field
        my $Success = $Self->{DynamicFieldObject}->DynamicFieldUpdate(
            ID         => $DynamicFieldOld->{ID},
            FieldOrder => $DynamicFieldOld->{FieldOrder},
            Name       => $DynamicFieldNew->{Name},
            Label      => $DynamicFieldNew->{Label},
            FieldType  => $DynamicFieldNew->{FieldType},
            ObjectType => $DynamicFieldNew->{ObjectType},
            Config     => $DynamicFieldNew->{Config},
            ValidID    => 1,
            Reorder    => 0,
            UserID     => 1,
        );
    }

    return 1;
}

=item CodeUninstall()

run the code uninstall part

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

=cut

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

    return 1;
}

=item _CreateDynamicFields()

creates all dynamic fields that are necessary for SystemMonitoring

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

=cut

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

    my $ValidID = $Self->{ValidObject}->ValidLookup(
        Valid => 'valid',
    );

    # get all current dynamic fields
    my $DynamicFieldList = $Self->{DynamicFieldObject}->DynamicFieldListGet(
        Valid => 0,
    );

    # get the list of order numbers (is already sorted).
    my @DynamicfieldOrderList;
    for my $Dynamicfield ( @{$DynamicFieldList} ) {
        push @DynamicfieldOrderList, $Dynamicfield->{FieldOrder};
    }

    # get the last element from the order list and add 1
    my $NextOrderNumber = 1;
    if (@DynamicfieldOrderList) {
        $NextOrderNumber = $DynamicfieldOrderList[-1] + 1;
    }

    # get the definition for all dynamic fields for
    my @DynamicFields = $Self->_GetDynamicFieldsDefinition();

    # create dynamic fields
    DYNAMICFIELD:

    for my $DynamicField (@DynamicFields) {

        # create a new field
        my $OldDynamicField = $Self->{DynamicFieldObject}->DynamicFieldGet(
            Name => $DynamicField->{Name},
        );

        if ( defined($OldDynamicField) ) {
            if ( exists( $OldDynamicField->{Label} ) ) {
                if (
                    ( $OldDynamicField->{Label} eq $DynamicField->{Label} )
                    )
                {
                    $Self->{LogObject}->Log(
                        Priority => 'info',
                        Message  => "Field already exists Label:$DynamicField->{Label}, skipping."
                    );
                    next;    # skip the record, it has been created already
                }

            }
        }

        #

        my $FieldID = $Self->{DynamicFieldObject}->DynamicFieldAdd(
            Name       => $DynamicField->{Name},
            Label      => $DynamicField->{Label},
            FieldOrder => $NextOrderNumber,
            FieldType  => $DynamicField->{FieldType},
            ObjectType => $DynamicField->{ObjectType},
            Config     => $DynamicField->{Config},
            ValidID    => $ValidID,
            UserID     => 1,
        );
        next DYNAMICFIELD if !$FieldID;

        # increase the order number
        $NextOrderNumber++;

    }

    return 1;
}

=item _GetDynamicFieldsDefinition()

returns the definition for System Monitoring related dynamic fields

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

=cut

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

    my @AllNewFields = ();    # the fields that are filled out

    # run all PreFilterModules (modify email params)
    for my $Key ('PostMaster::PreFilterModule')
    {
        if ( ref $Self->{ConfigObject}->Get($Key) eq 'HASH' ) {
            my %Jobs = %{ $Self->{ConfigObject}->Get($Key) };
            JOB:
            for my $Job ( sort keys %Jobs ) {
                return if !$Self->{MainObject}->Require( $Jobs{$Job}->{Module} );

                if (
                    $Jobs{$Job}->{Module} ne 'Kernel::System::PostMaster::Filter::SystemMonitoring'
                    )
                {
                    next JOB;
                }

                my @NewFields;

                my $FilterObject = $Jobs{$Job}->{Module}->new( %{$Self} );

                if ( !$FilterObject ) {
                    $Kernel::OM->Get('Kernel::System::Log')->Log(
                        Priority => 'error',
                        Message  => "Can not create $Jobs{$Job}->{Module} object!",
                    );
                    next JOB;
                }

                my $Run = $FilterObject->GetDynamicFieldsDefinition(
                    Config    => $Jobs{$Job},    # the job config
                    NewFields => \@NewFields
                );
                if ( !$Run ) {
                    $Kernel::OM->Get('Kernel::System::Log')->Log(
                        Priority => 'error',
                        Message =>
                            "Execute GetDynamicFieldsDefinition() of $Key $Jobs{$Job}->{Module} not successful!",
                    );
                }
                else {
                    push @AllNewFields, (@NewFields);
                }
            }
        }
    }
    return @AllNewFields;
}

1;

=back

=head1 TERMS AND CONDITIONS

This software is part of the OTRS project (L<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 L<http://www.gnu.org/licenses/agpl.txt>.

=cut

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