/// <summary>
/// Sends message to a remote SMPP server
/// </summary>
/// <param name="message">A message to send</param>
/// <param name="timeOut">A value in miliseconds after which the send operation times out</param>
public void SendMessage(ShortMessage message, int timeOut)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
//Check if connection is open
if (vState != SmppConnectionState.Connected)
{
throw new SmppClientException("Sending message operation failed because the SmppClient is not connected");
}
string messageId = null;
foreach (SendSmPDU pdu in message.GetMessagePDUs(vProperties.DefaultEncoding, vSmppEncodingService))
{
if (_Log.IsDebugEnabled)
{
_Log.DebugFormat("SendMessage SendSmPDU: {0}", LoggingExtensions.DumpString(pdu, vSmppEncodingService));
}
ResponsePDU resp = SendPdu(pdu, timeOut);
var submitSmResp = resp as SubmitSmResp;
if (submitSmResp != null)
{
if (_Log.IsDebugEnabled)
{
_Log.DebugFormat("SendMessage Response: {0}", LoggingExtensions.DumpString(resp, vSmppEncodingService));
}
messageId = ((SubmitSmResp)resp).MessageID;
}
message.ReceiptedMessageId = messageId;
RaiseMessageSentEvent(message);
}
}
private static void DeployBundlesTo(string where)
{
foreach (var bundle in _bundles.Where(x => x.SupportsCurrentPlatform))
{
_Log.DebugFormat("Attempting to deploy bundle: {0}", bundle);
try
{
foreach (var item in bundle.Resources)
{
_Log.DebugFormat("Deploying resource/file: {0}", item.FileName);
using (var stream = item.GetResourceStream())
{
DeployLibrary(stream, item.FileName, item.Date, where);
}
}
}
catch (Exception ex)
{
var msg = string.Format("Deploying of bundle {0} failed.", bundle.GetType().Name);
throw new ApplicationException(msg, ex);
}
}
}
private void CloseStream()
{
if (_stream != null)
{
_Log.DebugFormat("Closing stream for: {0}", _filePath);
_stream.Close();
_stream.Dispose();
_stream = null;
}
}
private MultiplexingConverter _GetConverter()
{
var obj = new MultiplexingConverter();
obj.Begin += (s, e) => _Log.DebugFormat("Conversion begin, phase count: {0}", e.Value);
obj.Error += (s, e) => _Log.Error(e.Value);
obj.Warning += (s, e) => _Log.Warn(e.Value);
obj.PhaseChanged += (s, e) => _Log.InfoFormat("PhaseChanged: {0} - {1}", e.Value, e.Value2);
obj.ProgressChanged += (s, e) => _Log.InfoFormat("ProgressChanged: {0} - {1}", e.Value, e.Value2);
obj.Finished += (s, e) => _Log.InfoFormat("Finished: {0}", e.Value ? "success" : "failed!");
return(obj);
}
public WkHtmlToPdfConverter()
{
bool useX11 = false;
try
{
useX11 = SysConvert.ToBoolean(ConfigurationManager.AppSettings["WkHtmlToXSharp.UseX11"]);
}
catch (Exception ex)
{
_Log.Error("Unable to parse 'WkHtmlToXSharp.UseX11' app. setting.", ex);
}
// Try to deploy native libraries bundles.
WkHtmlToXLibrariesManager.InitializeNativeLibrary();
var version = NativeCalls.WkHtmlToPdfVersion();
if (NativeCalls.wkhtmltopdf_init(useX11 ? 1 : 0) == 0)
{
throw new InvalidOperationException(string.Format("wkhtmltopdf_init failed! (version: {0}, useX11 = {1})", version, useX11));
}
_Log.DebugFormat("Initialized new converter instance (Version: {0}, UseX11 = {1})", version, useX11);
}
private static void DeployLibraries()
{
var manager = new WkHtmlToXLibrariesManager();
foreach (var bundle in _bundles.Where(x => x.SupportsCurrentPlatform))
{
_Log.DebugFormat("Attempting to deploy bundle: {0}", bundle);
try
{
bundle.DeployBundle(manager);
}
catch (Exception ex)
{
var msg = string.Format("Deploying of bundle {0} failed.", bundle.GetType().Name);
throw new ApplicationException(msg, ex);
}
}
}
/// <summary>
/// Sends a user-specified Pdu(see the RoaminSMPP base library for
/// Pdu types). This allows complete flexibility for sending Pdus.
/// </summary>
/// <param name="packet">The Pdu to send.</param>
/// <returns>The sequence number of the sent PDU, or null if failed.</returns>
public uint SendPdu(Pdu packet)
{
_Log.DebugFormat("Sending PDU: {0}", packet);
if (packet.SequenceNumber == 0)
{
packet.SequenceNumber = GenerateSequenceNumber();
}
var bytes = packet.GetEncodedPdu();
try
{
if (asClient == null || !asClient.Connected)
{
throw new InvalidOperationException("Session not connected to remote party.");
}
if (!(packet is SmppBind) && !_Bound)
{
throw new InvalidOperationException("Session not bound to remote party.");
}
asClient.Send(bytes);
return(packet.SequenceNumber);
}
catch
{
lock (_bindingLock)
{
_Log.Debug("SendPdu failed, scheduling a re-bind operation.");
_ReBindRequired = true;
}
throw; // Let the exception flow..
}
}
private static void SendMessage(string command)
{
var parts = command.Split(' ');
var dest = parts[1];
var msgTxt = string.Join(" ", parts, 2, parts.Length - 2);
if (string.IsNullOrEmpty(msgTxt))
{
msgTxt = @"السلام عليكم ورحمة الله وبركاته
هذه رسالة عربية
متعددة الاسطر";
}
TextMessage msg = new TextMessage();
msg.DestinationAddress = dest; //Receipient number
msg.SourceAddress = smppConfig.SourceAddress; //Originating number
//msg.Text = "Hello, this is my test message!";
msg.Text = msgTxt;
msg.RegisterDeliveryNotification = true; //I want delivery notification for this message
msg.UserMessageReference = GenerateUserMessageReference(smppConfig.UserMessageReferenceType);
_Log.DebugFormat($"msg.UserMessageReference: {msg.UserMessageReference}");
try
{
client.SendMessage(msg);
}
catch (SmppException smppEx)
{
_Log.ErrorFormat("smppEx.ErrorCode:({0}) {1} ", (int)smppEx.ErrorCode, smppEx.ErrorCode);
_Log.Error(smppEx);
}
catch (Exception e)
{
_Log.Error("SendMessage:" + e.Message, e);
}
//client.BeginSendMessage(msg, SendMessageCompleteCallback, client);
}
public WkHtmlToPdfConverter()
{
bool useX11 = false;
try
{
useX11 = SysConvert.ToBoolean(ConfigurationManager.AppSettings["WkHtmlToXSharp.UseX11"]);
}
catch (Exception ex)
{
_Log.Error("Unable to parse 'WkHtmlToXSharp.UseX11' app. setting.", ex);
}
var ptr = wkhtmltopdf_version();
var version = Marshal.PtrToStringAnsi(ptr);
if (!wkhtmltopdf_init(useX11 ? 1 : 0))
{
throw new InvalidOperationException(string.Format("wkhtmltopdf_init failed! (version: {0}, useX11 = {1})", version, useX11));
}
_Log.DebugFormat("Initialized new converter instance (Version: {0}, UseX11 = {1})", version, useX11);
}
/// <summary>
/// Constructs an AsyncSocketClient.
/// </summary>
/// <param name="bufferSize">The size of the receive buffer.</param>
/// <param name="stateObject">The object to use for sending state
/// information.</param>
/// <param name="msgHandler">The user-defined message handling method.
/// </param>
/// <param name="closingHandler">The user-defined socket closing
/// handling method.</param>
/// <param name="errHandler">The user defined error handling method.
/// </param>
public AsyncSocketClient(Int32 bufferSize, object stateObject,
MessageHandler msgHandler, SocketClosingHandler closingHandler,
ErrorHandler errHandler)
{
_Log.DebugFormat("Initializing new instance ({0}).", this.GetHashCode());
_Buffer = new byte[BUFFER_SIZE];
_StateObject = stateObject;
//set handlers
_MessageHandler = msgHandler;
_SocketCloseHandler = closingHandler;
_ErrorHandler = errHandler;
//set the asynchronous method handlers
_CallbackReadMethod = new AsyncCallback(ReceiveComplete);
_CallbackWriteMethod = new AsyncCallback(SendComplete);
//haven't been disposed yet
_IsDisposed = false;
}
public void DebugFormat(IFormatProvider provider, String format, params Object[] args)
{
_log.DebugFormat(provider, format, args);
}
