SAP SolMan eMail Notification

//Bei W2K3
//als Windows Dienst erstellen “runas /user:Administrator “INSTSRV.EXE CRM_Async_Checker C:\Program Files (x86)\Windows Resource Kits\Tools\srvany.exe” ”
//Bei W2K8
//” runas /user:Administrator “sc create SAP_eMail_Notification binPath= E:\Service_Desk_eMail_Notification_add_on\srvany.exe DisplayName= “SAP_eMail_Notification” ” ”
//Regedit öffnen und HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CRM_async_checker auswaehlen. Key hinzufügen -> “Parameters” -> Dann unter Parameters -> Strin Value -> “Application” mit Pfad zum CRM_Async_Checker. http://support.microsoft.com/kb/137890

//To DO:
//Parameteruebergabe fue eMail Empfaenger, SQL Datenbank/Tabelle und Check Interval
//Bessere Fehlertolleranz

//C++_CLI Header
#include “stdafx.h”

//Standard ISO C++ Header
#include <stdio.h>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <vector>
#include <iomanip>
#include <cstdio>
#include <sstream>
#include <stdexcept>
#include <msclr\marshal_cppstd.h>        //Header zur Nutzung zwischen ISO C++ und C++_CLI
#include <msclr\marshal.h>
#include “public_variables.h”            //Eigener Header fuer oeffentliche Variablen

//C++_CLI Namespaces
using namespace System;
using namespace System::Data;
using namespace System::Data::SqlClient;    //Namespace fuer den MSSQL Connect
using namespace System::Configuration;
using namespace System::Threading;            //Threading Namespace
using namespace System::IO;
using namespace msclr::interop;            //Name Space zur Nutzung zwischen ISO C++ und C++_CLI
using namespace System::Text;
using namespace System::Net;
using namespace System::Net::Sockets;    //Dot Net Socket
using namespace System::Collections;
using namespace System::Diagnostics;        //Fuer Windows Event log Eintraege. Darauf reagiert der AM.

//Standard ISO C++ Namespace
using namespace std;

//SMTP Connect Socket
//##################################################################################################################################################################################################################################################################
Socket^ ConnectSocket( String^ server, int port )
{
Socket^ s = nullptr;
IPHostEntry^ hostEntry = nullptr;

hostEntry = Dns::Resolve(server); //Absender Host via DNS herausfinden

IEnumerator^ myEnum = hostEntry->AddressList->GetEnumerator();    //freien TCP Port suchen
while ( myEnum->MoveNext() )
{
IPAddress^ address = safe_cast<IPAddress^>(myEnum->Current);
IPEndPoint^ endPoint = gcnew IPEndPoint( address,port );
Socket^ tmpS = gcnew Socket( endPoint->AddressFamily,SocketType::Stream,ProtocolType::Tcp );  //Socket erstellen
tmpS->Connect( endPoint );
if ( tmpS->Connected )  //Socket verbinden
{
s = tmpS;
break;
}
else
{
continue;
}
}

return s;
}
//##################################################################################################################################################################################################################################################################

//##################################################################################################################################################################################################################################################################

String^ SocketSendReceive( String^ server, int port)
{
//SMTP Protokoll nach RFC 821 http://tools.ietf.org/html/rfc821
//#################################################################################################################################
//Im Prinzip reicht es hier nur den Connect aufzubauen da der eMail Server immer gleich antwortet
String^ request = String::Concat( “helo eMail-Server” );

array<Byte>^bytesSent = Encoding::ASCII->GetBytes( request );
array<Byte>^bytesReceived = gcnew array<Byte>(256);

//Socket oeffnen####
Socket^ s = ConnectSocket( server, port );
if ( s == nullptr )
return (“Connection failed”);

int bytes = 0;
String^ strRetPage ;//= String::Concat( “Default HTML page on “, server, “:\r\n” );

//Bytes empfangen##
bytes = s->Receive( bytesReceived, bytesReceived->Length, static_cast<SocketFlags>(0) );
strRetPage = String::Concat( strRetPage, Encoding::ASCII->GetString( bytesReceived, 0, bytes ) );
//Console::WriteLine(“Server Antwort: ” + strRetPage );
strRetPage = “”;
//#################################################################################################################################
request = String::Concat( “helo eMail-Server\r\n” );

bytesSent = Encoding::ASCII->GetBytes( request );
bytesReceived = gcnew array<Byte>(256);

s->Send( bytesSent, bytesSent->Length, static_cast<SocketFlags>(0) );
//Console::WriteLine( request );

bytes = 0;
bytes = s->Receive( bytesReceived, bytesReceived->Length, static_cast<SocketFlags>(0) );
strRetPage = String::Concat( strRetPage, Encoding::ASCII->GetString( bytesReceived, 0, bytes ) );
//Console::WriteLine(“Server Antwort: ” + strRetPage );
strRetPage = “”;
//#################################################################################################################################

//#################################################################################################################################
request = String::Concat( “mail from: SWP_Support_Ticket@domain.com\r\n” );

bytesSent = Encoding::ASCII->GetBytes( request );
bytesReceived = gcnew array<Byte>(256);

s->Send( bytesSent, bytesSent->Length, static_cast<SocketFlags>(0) );
//Console::WriteLine( request );

bytes = 0;
bytes = s->Receive( bytesReceived, bytesReceived->Length, static_cast<SocketFlags>(0) );
strRetPage = String::Concat( strRetPage, Encoding::ASCII->GetString( bytesReceived, 0, bytes ) );
//Console::WriteLine(“Server Antwort: ” + strRetPage );
strRetPage = “”;
//#################################################################################################################################

//#################################################################################################################################
request = String::Concat( “rcpt to: user@domain.com\r\n” );

bytesSent = Encoding::ASCII->GetBytes( request );
bytesReceived = gcnew array<Byte>(256);

s->Send( bytesSent, bytesSent->Length, static_cast<SocketFlags>(0) );
//Console::WriteLine( request );

bytes = 0;
bytes = s->Receive( bytesReceived, bytesReceived->Length, static_cast<SocketFlags>(0) );
strRetPage = String::Concat( strRetPage, Encoding::ASCII->GetString( bytesReceived, 0, bytes ) );
//Console::WriteLine(“Server Antwort: ” + strRetPage );
strRetPage = “”;
//#################################################################################################################################

//#################################################################################################################################
request = String::Concat( “rcpt to: user2@domain.com\r\n” );

bytesSent = Encoding::ASCII->GetBytes( request );
bytesReceived = gcnew array<Byte>(256);

s->Send( bytesSent, bytesSent->Length, static_cast<SocketFlags>(0) );
//Console::WriteLine( request );

bytes = 0;
bytes = s->Receive( bytesReceived, bytesReceived->Length, static_cast<SocketFlags>(0) );
strRetPage = String::Concat( strRetPage, Encoding::ASCII->GetString( bytesReceived, 0, bytes ) );
//Console::WriteLine(“Server Antwort: ” + strRetPage );
strRetPage = “”;
//#################################################################################################################################

//#################################################################################################################################
request = String::Concat( “rcpt to: user3@domain.com\r\n” );

bytesSent = Encoding::ASCII->GetBytes( request );
bytesReceived = gcnew array<Byte>(256);

s->Send( bytesSent, bytesSent->Length, static_cast<SocketFlags>(0) );
//Console::WriteLine( request );

bytes = 0;
bytes = s->Receive( bytesReceived, bytesReceived->Length, static_cast<SocketFlags>(0) );
strRetPage = String::Concat( strRetPage, Encoding::ASCII->GetString( bytesReceived, 0, bytes ) );
//Console::WriteLine(“Server Antwort: ” + strRetPage );
strRetPage = “”;
//#################################################################################################################################

//#################################################################################################################################
request = String::Concat( “rcpt to: user4@domain.com\r\n” );

bytesSent = Encoding::ASCII->GetBytes( request );
bytesReceived = gcnew array<Byte>(256);

s->Send( bytesSent, bytesSent->Length, static_cast<SocketFlags>(0) );
//Console::WriteLine( request );

bytes = 0;
bytes = s->Receive( bytesReceived, bytesReceived->Length, static_cast<SocketFlags>(0) );
strRetPage = String::Concat( strRetPage, Encoding::ASCII->GetString( bytesReceived, 0, bytes ) );
//Console::WriteLine(“Server Antwort: ” + strRetPage );
strRetPage = “”;
//#################################################################################################################################

//#################################################################################################################################
request = String::Concat( “data\r\n” );

bytesSent = Encoding::ASCII->GetBytes( request );
bytesReceived = gcnew array<Byte>(256);

s->Send( bytesSent, bytesSent->Length, static_cast<SocketFlags>(0) );
//Console::WriteLine( request );

bytes = 0;
bytes = s->Receive( bytesReceived, bytesReceived->Length, static_cast<SocketFlags>(0) );
strRetPage = String::Concat( strRetPage, Encoding::ASCII->GetString( bytesReceived, 0, bytes ) );
//Console::WriteLine(“Server Antwort: ” + strRetPage );
strRetPage = “”;
//#################################################################################################################################

//#################################################################################################################################
request = String::Concat( “subject: Ein neues Ticket !!! \r\n” );

bytesSent = Encoding::ASCII->GetBytes( request );
bytesReceived = gcnew array<Byte>(256);

s->Send( bytesSent, bytesSent->Length, static_cast<SocketFlags>(0) );
//Console::WriteLine( request );

//bytes = 0;
//bytes = s->Receive( bytesReceived, bytesReceived->Length, static_cast<SocketFlags>(0) );
//strRetPage = String::Concat( strRetPage, Encoding::ASCII->GetString( bytesReceived, 0, bytes ) );
//Console::WriteLine(“Server Antwort: ” + strRetPage );
//strRetPage = “”;
//#################################################################################################################################

//#################################################################################################################################
request = String::Concat( “\r\n” );

bytesSent = Encoding::ASCII->GetBytes( request );
bytesReceived = gcnew array<Byte>(256);

s->Send( bytesSent, bytesSent->Length, static_cast<SocketFlags>(0) );
//Console::WriteLine( request );

//bytes = 0;
//bytes = s->Receive( bytesReceived, bytesReceived->Length, static_cast<SocketFlags>(0) );
//strRetPage = String::Concat( strRetPage, Encoding::ASCII->GetString( bytesReceived, 0, bytes ) );
//Console::WriteLine(“Server Antwort: ” + strRetPage );
//strRetPage = “”;
//#################################################################################################################################

//#################################################################################################################################
//cout<<public_subject_wert_fuer_email[public_anzahl_elemente – 1]<<endl;
String^ ticket_fuer_email;
//ticket_fuer_email = marshal_as<String^>(public_subject_wert_fuer_email[public_anzahl_elemente – 1]);
//public_subject_wert_fuer_email.clear();

String^ datum_fuer_email;
//datum_fuer_email = marshal_as<String^>(public_CREA_TSTMP_wert_fuer_email[public_anzahl_elemente – 1]);
//public_CREA_TSTMP_wert_fuer_email.clear();*/

ticket_fuer_email = marshal_as<String^>(public_subject_wert_fuer_email);
datum_fuer_email = marshal_as<String^>(public_CREA_TSTMP_wert_fuer_email);

request = String::Concat( “Es liegt ein neues Ticket vor !!!\n Ticket: ” + ticket_fuer_email + “\n Datum: ” + datum_fuer_email + “\r\n” );

public_subject_wert_fuer_email = “”;
public_CREA_TSTMP_wert_fuer_email = “”;

bytesSent = Encoding::ASCII->GetBytes( request );
bytesReceived = gcnew array<Byte>(256);

s->Send( bytesSent, bytesSent->Length, static_cast<SocketFlags>(0) );
//Console::WriteLine( request );

//bytes = 0;
//bytes = s->Receive( bytesReceived, bytesReceived->Length, static_cast<SocketFlags>(0) );
//strRetPage = String::Concat( strRetPage, Encoding::ASCII->GetString( bytesReceived, 0, bytes ) );
//Console::WriteLine(“Server Antwort: ” + strRetPage );
//strRetPage = “”;
//#################################################################################################################################

//#################################################################################################################################
request = String::Concat( “\r\n.\r\n” );

bytesSent = Encoding::ASCII->GetBytes( request );
bytesReceived = gcnew array<Byte>(256);

s->Send( bytesSent, bytesSent->Length, static_cast<SocketFlags>(0) );
//Console::WriteLine( request );

bytes = 0;
bytes = s->Receive( bytesReceived, bytesReceived->Length, static_cast<SocketFlags>(0) );
strRetPage = String::Concat( strRetPage, Encoding::ASCII->GetString( bytesReceived, 0, bytes ) );
//Console::WriteLine(“Server Antwort: ” + strRetPage );
strRetPage = “”;
//#################################################################################################################################

return strRetPage;
}

//############################################################################################################################################################################################

public ref class orga_thread_klasse
{

//Public Class fuer den Orag Thread
public:
static void orga_read_thread()
{
while (1) //Endlos Schleife
{
Sleep(20000); //Fuer 20 Sekunden schalfen.
//Sleep(480000); //Fuer 8 Minuten schalfen.
//cout<<public_subject_wert[1];
//cout<<public_CREA_TSTMP_wert[1];

//Daten aus dem Public Vector blind in Datei schreiben##########################################################
String^ subject_wert;
String^ CREA_TSTMP_wert;

//StreamWriter^ sw= File::AppendText(“C:\\Temp\\sap_tickets_temp.log”);
StreamWriter^ sw= File::AppendText(“sap_tickets_temp.log”);

for ( int i = 0; i < public_subject_wert.size(); i++)
{
if (public_subject_wert.size() == 0)
{
break;
}

subject_wert = marshal_as<String^>(public_subject_wert[i]);
CREA_TSTMP_wert = marshal_as<String^>(public_CREA_TSTMP_wert[i]);
sw->Write(“Ticket: ” + subject_wert + “; Datum: ” + CREA_TSTMP_wert +”;\n”);
}

sw->Flush();
sw->Close();

//Public Vector leeren
public_subject_wert.clear();
public_CREA_TSTMP_wert.clear();

//Temp Datei einlesen##########################################################
//StreamReader^ din = gcnew StreamReader( “C:\\Temp\\sap_tickets_temp.log” );
//String^ fileName = “C:\\Temp\\sap_tickets_temp.log”;
vector<string> temp_zeilen_inhalt;

try
{
//StreamReader^ din = gcnew StreamReader( “C:\\Temp\\sap_tickets_temp.log” );
StreamReader^ din = gcnew StreamReader( “sap_tickets_temp.log” );
try
{
String^ text_zeilen_inhalt;

int i = 0;
while ( text_zeilen_inhalt = din->ReadLine() )
{
i++;
//Console::WriteLine(text_zeilen_inhalt);
//Daten der Temp Datei in Vector schreiben###############################
temp_zeilen_inhalt.push_back(marshal_as<std::string>(text_zeilen_inhalt));

}
}
finally
{
if ( din )
delete (IDisposable^)din; //File Handle schliessen
FileInfo ^ fleMembers = gcnew FileInfo(L”sap_tickets_temp.log”);    //Temp Datei loeschen
fleMembers->Delete(); //File Handle schliessen
}

}
catch (Exception^ e)
{
//Console::WriteLine( “The file could not be read:” );
//Console::WriteLine( e->Message );
}

//Work Datei einlesen##########################################################
vector<string> work_zeilen_inhalt;
try
{
//StreamReader^ din_2 = gcnew StreamReader( “C:\\Temp\\sap_tickets.log” );
StreamReader^ din_2 = gcnew StreamReader( “sap_tickets.log” );
try
{
String^ text_zeilen_inhalt_2;

int i = 0;
while ( text_zeilen_inhalt_2 = din_2->ReadLine() )
{
i++;
//Console::WriteLine(text_zeilen_inhalt);
//Daten der Temp Datei in Vector schreiben###############################
work_zeilen_inhalt.push_back(marshal_as<std::string>(text_zeilen_inhalt_2));

}
}
finally
{
if ( din_2 )
delete (IDisposable^)din_2;
//Console::WriteLine(text_zeilen_inhalt);
}

}
catch (Exception^ e)
{
//Console::WriteLine( “The file could not be read:” );
//Console::WriteLine( e->Message );
}

//Vectoren vergleichen und Quitiert suchen bzw. setzen###################################################
String^ work_zeilen_inhalt_string;
String^ temp_zeilen_inhalt_string;
int vector_ende = 666;

for (int i = 0 ; i < public_anzahl_elemente; i++)
{
//cout<<work_zeilen_inhalt[1];
//cout<<temp_zeilen_inhalt[1];

//Sobald mehr Tickets aus dem SQL kommen als in der Quitierungs Datei stehen, handeln.###################################
if (i >= work_zeilen_inhalt.size())
{
//zusätzlcihe Zeilen in Datei schreiben und eMail versenden#####################
//cout<<public_subject_wert[i]<<endl;
//sw->Flush();
//sw->Close();
//StreamWriter^ sw= File::AppendText(“C:\\Temp\\sap_tickets.log”);
StreamWriter^ sw_2 = File::AppendText(“sap_tickets.log”);
sw_2->Write(“Ticket: ” + subject_wert + “; Datum: ” + CREA_TSTMP_wert +”;\n”);
sw_2->Flush();
sw_2->Close();

//Hier die oeffentlich Variable fuer die eMail Infos entnehmen
public_subject_wert_fuer_email = marshal_as<std::string>(subject_wert);
public_CREA_TSTMP_wert_fuer_email = marshal_as<std::string>(CREA_TSTMP_wert);
//###################################################################################################################################
//eMail Benachrichtigung starten#########
//sw->Write(“Sende eMail \n”);
String^ host;
int port = 25;
host = “wdf-excas01″;
String^ result = SocketSendReceive(host, port); //EMail Funktion starten
//###################################################################################################################################

//sw_2->Flush();
//sw_2->Close();

continue;
}

work_zeilen_inhalt_string = marshal_as<String^>(work_zeilen_inhalt[i]);
temp_zeilen_inhalt_string = marshal_as<String^>(temp_zeilen_inhalt[i]);

int gleich = String::Compare(work_zeilen_inhalt_string, temp_zeilen_inhalt_string);
//cout<<gleich<<endl;
}

//FileInfo ^ fleMembers = gcnew FileInfo(L”sap_tickets_temp.log”);
//fleMembers->Delete();

//sw->Flush();
//sw->Close();
}

}
};

//############################################################################################################################################################################################

//############################################################################################################################################################################################

public ref class sql_thread_klasse
{

//Public Class fuer den SQL Read Thread
public:
static void sql_read_thread()
//void sql_read_thread()
{
SqlConnection ^connection = gcnew SqlConnection();

//connection->ConnectionString = “Data Source=wdf-crmapp01dev;Initial Catalog=domain_MSCRM;Integrated Security=SSPI;”;
//connection->ConnectionString = “Data Source=wdf-dbcl02db;Initial Catalog=domain_MSCRM;Integrated Security=SSPI;”;
//connection->ConnectionString = “Data Source=wdf-crmsql01qa;Initial Catalog=domain_MSCRM;Integrated Security=SSPI;”;
connection->ConnectionString = “Data Source=wdf-swpsol01;Initial Catalog=SWP;User Id=swp;Password=password!”;

//SQL Query zur Prüfung des Async Service auf SQL Basis##############
//Eventuell eigenen Thread dafür starten!!!
//int in_progress_wert = 0;

while (1) //Endlos Schleife
{

Sleep(10000); //Fuer 10 Sekunden schalfen.
//Sleep(600000); //Fuer 10 Minuten schalfen.

try
{
SqlCommand ^cmd = gcnew SqlCommand();

cmd->Connection = connection;

cmd->CommandType = CommandType::Text;

cmd->CommandText =String::Format(“SELECT * FROM swp.DNOD_NOTIF;”);

connection->Open();

SqlDataReader ^reader = cmd->ExecuteReader();

reader->Close();

reader = cmd->ExecuteReader();

String ^subject_wert;
String ^CREA_TSTMP_wert;
int anzahl_an_elemente = 0;

while(reader->Read())
{
//Console::WriteLine(reader[“In Progress”]);
//Console::WriteLine(DateTime::Now);
subject_wert = reader[“SUBJECT”]->ToString();
CREA_TSTMP_wert = reader[“CREA_TSTMP”]->ToString();

public_subject_wert.push_back(marshal_as<std::string>(subject_wert));
public_CREA_TSTMP_wert.push_back(marshal_as<std::string>(CREA_TSTMP_wert));

//public_subject_wert_fuer_email.push_back(marshal_as<std::string>(subject_wert));
//public_CREA_TSTMP_wert_fuer_email.push_back(marshal_as<std::string>(CREA_TSTMP_wert));

anzahl_an_elemente++;
//public_in_progress_wert.push_back(Convert::ToInt32( in_progress_wert ));        //String^ Variable in int32 Variable umkonvertieren und in oeffentliche Variable schreiben
//public_in_progress_wert.push_back(666); //Aus Debug Gruenden ist dieser Wer eingestellt !!!!!!!!!!!!!######################################################
//Console::WriteLine(subject_wert);
//Console::WriteLine(CREA_TSTMP_wert);
}

public_anzahl_elemente = anzahl_an_elemente;

reader->Close();
connection->Close();
}

catch (SqlException ^e)
{
//Console::WriteLine(“Probleme mit dem SQL Server: {0}”,e->Message);
}

}
}
};

//############################################################################################################################################################################################

int main(int argc,char *argv[])
{

//Thread zur SQL Status Abfrage starten
Thread^ sql_thread_klasse = gcnew Thread( gcnew ThreadStart( &sql_thread_klasse::sql_read_thread ) );
sql_thread_klasse->Start();

//Thread zur organisation der gefunden Meldungen
Thread^ orga_thread_klasse = gcnew Thread( gcnew ThreadStart( &orga_thread_klasse::orga_read_thread ) );
orga_thread_klasse->Start();

return 0;
}

Post Revisions: