void _socket_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
if (this.Message != null)
{
try
{
using (MemoryStream ms = new MemoryStream())
{
//Get the DataReader
using (var dataReader = new JsonTextReader(new StreamReader(ms)))
{
args.GetDataStream().AsStreamForRead().CopyTo(ms);
ms.Position = 0;
dataReader.SupportMultipleContent = true;
while (dataReader.Read())
{
var parsedMessage = JArray.Load(dataReader);
Message(this, new WampMessageEventArgs(parsedMessage));
}
}
}
}
catch (Exception ex)
{
var status = Windows.Networking.Sockets.WebSocketError.GetStatus(ex.HResult);
if (status != Windows.Web.WebErrorStatus.Unknown)
this.OnError(this, status);
}
}
}
private void socket_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
using (StreamReader streamReader = new StreamReader(args.GetDataStream().AsStreamForRead()))
{
using (JsonReader jsonReader = new JsonTextReader(streamReader))
{
JObject jmessage = JObject.Load(jsonReader);
}
}
}
private void WebSocket_MessageReceived(Windows.Networking.Sockets.MessageWebSocket sender, Windows.Networking.Sockets.MessageWebSocketMessageReceivedEventArgs args)
{
try
{
using (var datastr = args.GetDataStream().AsStreamForRead())
using (var ms = new MemoryStream())
{
datastr.CopyTo(ms);
ms.Position = 0;
byte[] data = new byte[ms.Length];
ms.Read(data, 0, (int)ms.Length);
int index = 0;
int count = data.Length;
using (var decompressed = new MemoryStream())
{
if (data[0] == 0x78)
{
_compressed.Write(data, index + 2, count - 2);
_compressed.SetLength(count - 2);
}
else
{
_compressed.Write(data, index, count);
_compressed.SetLength(count);
}
_compressed.Position = 0;
if (decompressed == null)
{
return;
}
_decompressor.CopyTo(decompressed);
_compressed.Position = 0;
decompressed.Position = 0;
using (var reader = new StreamReader(decompressed))
OnMessageReceived(reader.ReadToEnd());
}
}
}
catch (Exception)
{
FinishedTask = true;
UpdateLastRunStatus("There was a problem while decrypting a websocket message on the last run");
}
}
private async void Sck_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
//[email protected]("Message received " + args);
if (args.MessageType == SocketMessageType.Utf8)
{
Windows.Storage.Streams.DataReader messageReader = args.GetDataReader();
messageReader.UnicodeEncoding = UnicodeEncoding.Utf8;
string messageString = messageReader.ReadString(messageReader.UnconsumedBufferLength);
com.codename1.io.websocket.WebSocket.messageReceived(id, messageString);
} else
{
Windows.Storage.Streams.IInputStream readStream = args.GetDataStream();
byte[] readBuffer = new byte[4096];
try
{
while (true)
{
if (sender != sck)
{
return;
}
IBuffer res = await readStream.ReadAsync(readBuffer.AsBuffer(), (uint)readBuffer.Length, 0);
if (res.Length == 0)
{
return;
}
byte[] resArr = new byte[res.Length];
res.CopyTo(resArr);
com.codename1.io.websocket.WebSocket.messageReceived(1, resArr);
}
} catch (Exception ex)
{
com.codename1.io.websocket.WebSocket.errorReceived(id, ex.Message, ex.HResult);
}
}
}
private async void WebSocket_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
StreamReader reader = new StreamReader(args.GetDataStream().AsStreamForRead(), System.Text.Encoding.UTF8);
// get the result in and check if its of type message
string result = null;
result = await reader.ReadToEndAsync();
WriteToOutputBox(result);
JObject responseObject = JObject.Parse(result);
string responseType = (string)responseObject["type"];
if (responseType == "message")
{
// then check if it was from the general channel
string channel = (string)responseObject["channel"];
if (channel == generalChannelId)
{
// then try to pull the user
string sendingUser = (string)responseObject["user"];
if (string.IsNullOrEmpty(sendingUser))
{
return;
}
SlackUser user = GetSlackUser(sendingUser);
if (user == null)
{
return;
}
// and pull what they said
string messageText = (string)responseObject["text"];
// construct our output message
string outputMessage = "";
if (user.FirstName != null)
{
outputMessage += user.FirstName + ": ";
}
else if (user.RealName != null)
{
outputMessage += user.RealName + ": ";
}
else
{
outputMessage += user.Username + ": ";
}
SmsUser smsToUser = null;
string rest = null;
if (messageText.StartsWith("<@"))
{
// if they are an actual slack member then pull up their info using their id
int nextBracket = messageText.IndexOf('>');
if (nextBracket == -1)
{
return;
}
string userId = messageText.Substring(2, nextBracket - 2);
SlackUser slackToUser = GetSlackUser(userId);
if (slackToUser == null)
{
return;
}
// and then try to find their SMS info
smsToUser = GetSmsUserByName(slackToUser.Username);
if (smsToUser == null)
{
smsToUser = GetSmsUserByName(slackToUser.FirstName);
}
if (smsToUser == null)
{
return;
}
rest = messageText.Substring(nextBracket + 1);
}
foreach (SmsUser smsUser in Secrets.SmsUsers)
{
if (smsUser.RealName == null)
{
// SMS user needs to at least have a real name
return;
}
// if they arent a slack member then just match using their name
if (messageText.StartsWith("@" + smsUser.RealName.ToLower()))
{
smsToUser = smsUser;
rest = messageText.Substring(smsToUser.RealName.Length + 1);
break;
}
}
if (smsToUser == null)
{
return;
}
if (rest.StartsWith(":"))
{
rest = rest.Substring(1);
}
rest = rest.Trim();
outputMessage += rest;
// then send the message to them
Message sentMessage = null;
try
{
twilioClient = new TwilioRestClient(Secrets.TwilioSid, Secrets.TwilioAuthToken);
sentMessage = twilioClient.SendMessage(Secrets.TwilioNumber, smsToUser.PhoneNumber, outputMessage);
}
catch (Exception ex)
{
WriteToOutputBox("Twilio SendMessage Exception: " + ex.Message);
}
}
}
if (responseType == "team_migration_started")
{
// hold my socket we're going in
// server is going down: https://api.slack.com/events/team_migration_started
serverIsDead = true;
// we shoudn't probably call ConnectToWebSocket here because we need this method to exit
// because ConnectToWebSocket turns everything into null
// so I stuck it in the listener since that's separate
return;
}
}
private void webSocketClient_MessageReceivedV2(object sender, MessageWebSocketMessageReceivedEventArgs e)
{
try
{
var dataStream = e.GetDataStream();
using (DataReader reader = e.GetDataReader())
{
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
string read = reader.ReadString(reader.UnconsumedBufferLength);
IDictionary<string, object> e1 = AVClient.DeserializeJsonString(read);
if (this.m_onRecevied == null)
return;
this.m_onRecevied((object)this, e1);
}
}
catch (ArgumentException ex)
{
throw ex;
}
}
private string GetOnMessage(MessageWebSocketMessageReceivedEventArgs args)
{
try
{
var dataStream = args.GetDataStream();
using (DataReader reader = args.GetDataReader())
{
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
string read = reader.ReadString(reader.UnconsumedBufferLength);
return read;
}
}
catch (Exception ex)
{
WebErrorStatus status = WebSocketError.GetStatus(ex.GetBaseException().HResult);
}
return String.Empty;
}
private void WebSocketClient_MessageReceived(MessageWebSocket sender, MessageWebSocketMessageReceivedEventArgs args)
{
//OnOpen();
try
{
var dataStream = args.GetDataStream();
using (DataReader reader = args.GetDataReader())
{
reader.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf8;
string read = reader.ReadString(reader.UnconsumedBufferLength);
//GetOnMessage(read);
}
}
catch (Exception ex)
{
WebErrorStatus status = WebSocketError.GetStatus(ex.GetBaseException().HResult);
}
}
