Esempio n. 1
0
        private void OnWebSocketMessageReceived(object sender, WebSocketMessageReceivedEventArgs e)
        {
            var requestMessage = JObject.Parse(((WebSocketTextMessage)e.Message).Text);
            var apiRequest     = requestMessage.ToObject <ApiRequest>();

            var context = new ApiCall(apiRequest.Action, apiRequest.Parameter, apiRequest.ResultHash);

            var eventArgs = new ApiRequestReceivedEventArgs(context);

            RequestReceived?.Invoke(this, eventArgs);

            if (!eventArgs.IsHandled)
            {
                context.ResultCode = ApiResultCode.ActionNotSupported;
            }

            var apiResponse = new ApiResponse
            {
                ResultCode = context.ResultCode,
                Result     = context.Result,
                ResultHash = context.ResultHash
            };

            var jsonResponse = JObject.FromObject(apiResponse);

            jsonResponse["CorrelationId"] = requestMessage["CorrelationId"];

            e.WebSocketClientSession.SendAsync(jsonResponse.ToString()).Wait();
        }
Esempio n. 2
0
 private static void WebSocketMessageReceived(object sender, WebSocketMessageReceivedEventArgs e)
 {
     //Console.WriteLine();
     //Console.ForegroundColor = ConsoleColor.Green;
     //Console.WriteLine($"You've got message: {e.MessageId}\n{e.MessageHeader.Sender}\n{ e.MessageBody}");
     //Console.ResetColor();
 }
        private void DispatchWebSocketMessage(object sender, WebSocketMessageReceivedEventArgs e)
        {
            var requestMessage = JObject.Parse(((WebSocketTextMessage)e.Message).Text);

            var correlationId = (string)requestMessage["CorrelationId"];
            var uri           = (string)requestMessage["Uri"];
            var request       = (JObject)requestMessage["Content"] ?? new JObject();

            var context   = new ApiContext(uri, request, new JObject());
            var eventArgs = new ApiRequestReceivedEventArgs(context);

            RequestReceived?.Invoke(this, eventArgs);

            if (!eventArgs.IsHandled)
            {
                context.ResultCode = ApiResultCode.UnknownUri;
            }

            var responseMessage = new JObject
            {
                ["CorrelationId"] = correlationId,
                ["ResultCode"]    = context.ResultCode.ToString(),
                ["Content"]       = context.Response
            };

            e.WebSocketClientSession.SendAsync(responseMessage.ToString()).Wait();
        }
Esempio n. 4
0
 private async void CreatioUtils_WebSocketMessageReceived(object sender, WebSocketMessageReceivedEventArgs e)
 {
     await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
         CoreDispatcherPriority.Normal,
         () => { WebSocketMessages.Add(e); }
         );
 }
Esempio n. 5
0
        public async void ConectWebSocket()
        {
            ClientWebSocket wss = new ClientWebSocket();

            wss.Options.Cookies = Instance.Auth;
            foreach (Cookie c in Instance.Auth.GetCookies(new Uri(domain)))
            {
                if (c.Name == "BPMCSRF" && !String.IsNullOrEmpty(c.Value))
                {
                    wss.Options.SetRequestHeader(c.Name, c.Value);
                    wss.Options.KeepAliveInterval = TimeSpan.FromSeconds(60);
                }
            }

            string socketDomain;

            if (domain.StartsWith("https://", StringComparison.Ordinal))
            {
                socketDomain = domain.Replace("https://", "wss://");
            }
            else
            {
                socketDomain = domain.Replace("http://", "ws://");
            }

            await wss.ConnectAsync(new Uri($"{socketDomain}/0/Nui/ViewModule.aspx.ashx"), CancellationToken.None).ConfigureAwait(false);

            while (wss.State == WebSocketState.Open)
            {
                ArraySegment <Byte>    buffer = new ArraySegment <byte>(new Byte[8192]);
                WebSocketReceiveResult result = null;
                using (var ms = new MemoryStream())
                {
                    do
                    {
                        result = await wss.ReceiveAsync(buffer, CancellationToken.None).ConfigureAwait(false);

                        ms.Write(buffer.Array, buffer.Offset, result.Count);
                    }while (!result.EndOfMessage);

                    ms.Seek(0, SeekOrigin.Begin);

                    if (result.MessageType == WebSocketMessageType.Text)
                    {
                        using (var reader = new StreamReader(ms, Encoding.UTF8))
                        {
                            string txt = reader.ReadToEnd();
                            WebSocketMessageReceivedEventArgs e = JsonConvert.DeserializeObject <WebSocketMessageReceivedEventArgs>(txt);
                            Instance.OnWebSocketMessageReceived(e);
                        }
                    }
                }
            }
            wss.Dispose();
        }
Esempio n. 6
0
 /// <summary>
 /// Event handler receives the system performance updates and sets the CPULoad property
 /// </summary>
 /// <param name="sender">The DevicePortal that originated the event</param>
 /// <param name="args">The event data</param>
 private void OnSystemPerfReceived(DevicePortal sender, WebSocketMessageReceivedEventArgs <DevicePortal.SystemPerformanceInformation> args)
 {
     this.cpuLoad = args.Message.CpuLoad;
     this.OnPropertyChanged("CPULoad");
 }
Esempio n. 7
0
        private void OnWebSocketMessageReceived(WebSocketMessageReceivedEventArgs e)
        {
            EventHandler <WebSocketMessageReceivedEventArgs> handler = WebSocketMessageReceived;

            handler?.Invoke(this, e);
        }