private static void _p2p_onRecieve(Recieved r)
{
Console.WriteLine(r.id);
Console.WriteLine(Encoding.UTF8.GetString(r.data));
_p2p.StartSendToClient(r.id, r.data);
}
private void Message_Recieved(object sender, MessageRecievedEventArgs <TMessage> args)
{
//只处理服务端返回的请求，而不处理客户端发送的请求
if (args.Message.InvokeMessageType != InvokeMessageType.Request)
{
Recieved?.Invoke(sender, args);
}
}
public Task ReceiveAsync(RpcResponse response)
{
if (Recieved != null)
{
return(Task.Factory.StartNew(() => { Recieved.Invoke(this, new RecievedMessageEventArgs(response)); }));
}
else
{
return(Task.CompletedTask);
}
}
private void Message_Recieved(object sender, MessageRecievedEventArgs <TMessage> args)
{
// 只处理服务端返回的请求，而不处理客户端发送的请求
// 收到了消息然后冒泡到 上层
if (args.Message.InvokeMessageType != InvokeMessageType.Request)
{
Logger.LogDebug("收到消息返回");
Recieved?.Invoke(sender, args);
}
}
public Task ReceiveAsync(IRpcContext <TMessage> context, TMessage message)
{
if (Recieved != null)
{
return(Task.Factory.StartNew(() =>
{
Recieved.Invoke(this, new MessageRecievedEventArgs <TMessage>(context, message));
}
));
}
else
{
return(Utils.TaskUtils.CompletedTask);
}
}
private void ListenLoop()
{
Connection = Ear.Accept();
byte[] messageSizeBytes = new byte[sizeof(int)];
Connection.Receive(messageSizeBytes);
int messageSize = BitConverter.ToInt32(messageSizeBytes, 0);
byte[] messageBytes = new byte[messageSize];
Connection.Receive(messageBytes);
RecieveEventArgs args = new RecieveEventArgs(Connection.RemoteEndPoint, messageBytes);
Recieved?.Invoke(Connection, args);
Connection.Shutdown(SocketShutdown.Both);
Connection.Close();
ListenLoop();
}
void callback(IAsyncResult ar)
{
try
{
sck.EndReceive(ar);
byte[] buf = new byte[8192];
int rec = sck.Receive(buf, buf.Length, 0);
if (rec < buf.Length)
{
Array.Resize(ref buf, rec);
}
Recieved?.Invoke(this, buf);
sck.BeginReceive
(new byte[] { 0 }, 0, 0, 0, callback, null);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Close();
Disconnected?.Invoke(this);
}
}
private void Message_Recieved(object sender, MessageRecievedEventArgs <TMessage> args)
{
Recieved?.Invoke(sender, args);
}
private void RaiseReceivedEvent(IRpcContext <TMessage> context, TMessage message)
{
Recieved?.Invoke(this, new MessageRecievedEventArgs <TMessage>(context, message));
}
protected virtual void OnRecieved(string command)
{
Recieved?.Invoke(this, command);
}
private static void Gsm_SmsRecievedEvent(object sender, ParseSms e)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(e.Sender + ":\r\n" + e.Message);
Console.ForegroundColor = ConsoleColor.Gray;
#region SMS-Empfang in Datenbank protokollieren
int fromId = GetSmsSenderID(e.Sender, e.Message);
int messageId = MelBoxSql.Tab_Message.SelectOrCreateMessageId(e.Message);
Recieved recieved1 = new Recieved()
{
FromId = fromId,
ContentId = messageId,
RecTime = DateTime.UtcNow
};
MelBoxSql.Tab_Recieved.Insert(recieved1);
#endregion
#region Weiterleiten per EMail oder SMS
MailAddressCollection emailRecievers = new MailAddressCollection();
string emailSuffix = string.Empty;
Random ran = new Random();
int emailId = ran.Next(256, 9999); // Pseudo-Id für Sendungsverfolgung
if (e.Message.ToLower().Trim() == SmsWayValidationTrigger.ToLower()) // SmsAbruf?
{
#region Meldelinientest 'SmsAbruf'
MelBoxGsm.Gsm.Ask_SmsSend(e.Sender, e.Message.Trim() + " um " + DateTime.Now.ToString("HH:mm:ss") + " Uhr.");
Sent sent = new Sent(fromId, messageId, Tab_Contact.Communication.Sms)
{
SentTime = DateTime.UtcNow
};
MelBoxSql.Tab_Sent.Insert(sent);
#endregion
}
else if (Tab_Message.IsMessageBlockedNow(messageId)) // Nachricht zum jetzigen Zeitpunkt gesperrt?
{
emailSuffix += Environment.NewLine + "Keine Weiterleitung an Bereitschaftshandy da SMS zur Zeit gesperrt.";
}
else // An Bereitschaft senden
{
#region An Bereitschaft senden
//Bereitschaft ermitteln
List <MelBoxSql.Shift> currentShifts = MelBoxSql.Tab_Shift.SelectOrCreateCurrentShift();
Console.WriteLine("Aktuelle Bereitschaft: ");
//an Bereitschaft weiterleiten
foreach (var shift in currentShifts)
{
Contact to = MelBoxSql.Tab_Contact.SelectContact(shift.ContactId);
Console.WriteLine($"Id [{shift.Id}] >{to.Name}< von >{shift.Start}< bis >{shift.End}<");
//Email freigegeben und gültig?
if ((to.Via & Tab_Contact.Communication.Email) > 0 && Tab_Contact.IsEmail(to.Email))
{
emailRecievers.Add(new MailAddress(to.Email, to.Name));
Sent sent = new Sent(shift.ContactId, messageId, Tab_Contact.Communication.Email)
{
Confirmation = Tab_Sent.Confirmation.AwaitingRefernece,
Reference = emailId,
SentTime = DateTime.UtcNow
};
MelBoxSql.Tab_Sent.Insert(sent);
}
//SMS?
if ((to.Via & Tab_Contact.Communication.Sms) > 0)
{
Sent sent = new Sent(shift.ContactId, messageId, Tab_Contact.Communication.Sms)
{
Confirmation = Tab_Sent.Confirmation.NaN,
SentTime = DateTime.UtcNow
};
MelBoxSql.Tab_Sent.Insert(sent);
MelBoxGsm.Gsm.Ask_SmsSend("+" + to.Phone.ToString(), e.Message);
}
}
if (currentShifts.Count == 0)
{
Console.WriteLine("z.Zt. keine aktive Bereitschaft");
emailSuffix += Environment.NewLine + "Keine Weiterleitung an Bereitschaftshandy während der Geschäftszeit.";
}
else
{
emailSuffix += Environment.NewLine + "Weiterleitung an Bereitschaftshandy außerhalb Geschäftszeiten ist erfolgt.";
}
#endregion
}
//Emails an Bereitschaft und ständige Empfänger senden.
string subject = $"SMS-Eingang >{MelBoxSql.Tab_Contact.SelectName_Company_City(fromId)}<, Text >{e.Message}<";
string body = $"Absender >{e.Sender}<\r\nText >{e.Message}<\r\nSendezeit >{e.TimeUtc.ToLocalTime().ToLongTimeString()}<\r\n" + emailSuffix;
Email.Send(emailRecievers, body, subject, emailId);
#endregion
}
private void NotifyRecieved(TData data)
{
Recieved?.Invoke(this, data);
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <param name="parameter"></param>
public void Send(object message = null, object parameter = null)
{
Recieved?.Invoke(this, new MessengerEventArgs(message, parameter));
}
/// <summary>
/// <para>Note : delegate method handle raise event</para>
/// </summary>
protected virtual void OnReveived(CoinEvent e)
{
Recieved?.Invoke(this, e);
}
public void Receive(IRpcContext <TMessage> context, TMessage message)
{
Recieved?.Invoke(this, new MessageRecievedEventArgs <TMessage> (context, message));
}
private void Message_Recieved(object sender, RecievedMessageEventArgs e)
{
Recieved?.Invoke(sender, e);
}
