private void HandleResponseMessage(string message)
{
if (OnResponse != null)
{
OnResponse.Invoke(message);
}
}
/*Definition for Callback Methods*/
public async void Call <T>()
{
CheckExeptions();
HttpResponseDTO <object> responseDto = new HttpResponseDTO <object>();
string urlRequest = FullUrl ?? RequestUri;
HttpResponseMessage response = null;
try
{
response = GetHttpResponse(urlRequest);
}
catch (Exception e)
{
throw new Exception(e.Message, e);
}
string jsonString = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
responseDto.StatusCode = response.StatusCode;
if (response.StatusCode == (HttpStatusCode)401)
{
responseDto.Message = "You are not authorized to request this resource";
OnFailure?.Invoke(responseDto);
}
else
{
T dynamicObj = JsonConvert.DeserializeObject <T>(jsonString);
responseDto.Body = dynamicObj;
OnResponse?.Invoke(responseDto);
}
}
public async void Send(string input)
{
//this.micClient.EndMicAndRecognition();
if (!isStopped)
{
try
{
OnResponse?.Invoke(input, MessageType.History);
if (!string.IsNullOrEmpty(input))
{
Activity userMessage = new Activity
{
From = new ChannelAccount(fromUser),
Text = input,
Type = ActivityTypes.Message
};
await client.Conversations.PostActivityAsync(conversation.ConversationId, userMessage);
}
}
catch (Exception)
{
}
}
}
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (this._apiKey != null)
{
request.Headers.Add("X-Api-Key", this._apiKey);
}
IEndpoint endpoint = request.Properties.ContainsKey("Endpoint") ? (IEndpoint)request.Properties["Endpoint"] : null;
if (endpoint?.RequireAuth == true || (authInfo != null))
{
if (!request.Headers.Contains("Authorization"))
{
request.Headers.Add("Authorization", $"Bearer {authInfo.AccessToken}");
}
}
// Dispatch to on send listeners
OnSend?.Invoke(this, request, endpoint);
//
HttpResponseMessage response = await base.SendAsync(request, cancellationToken);
// Dispatch to on response listeners
OnResponse?.Invoke(this, response, endpoint);
return(response);
}
public void Response(string response)
{
OnResponse.Invoke(new HttpRerquestEventArgs
{
Response = response
});
}
private void OnMouseEvent(UIMouseEventType type, UpdateState state)
{
if (type == UIMouseEventType.MouseDown)
{
OnResponse?.Invoke(true);
}
}
public virtual object Complete(ProtoState state)
{
var res = state.Complete();
OnResponse?.Invoke(this, state);
AllDone.Reset();
return(res);
}
public MockVMController(IVMFactory vmFactory) : this()
{
_vmController = new VMController((connectionId, vmId, vmData) =>
{
_response.Handler(connectionId, vmId, vmData);
OnResponse?.Invoke(this, vmData);
}, vmFactory);
}
// OLD METHODS ------------------------------------------------------
public void StartClient(string toSend = "")
{
// Connect to a remote device.
try
{
// Establish the remote endpoint for the socket.
IPHostEntry ipHostInfo = Dns.GetHostEntry(Server);
Console.WriteLine("Host info:");
int i = 0;
for (i = 0; i < ipHostInfo.AddressList.Length; i++)
{
var item = ipHostInfo.AddressList[i].ToString();
Console.WriteLine(item);
if (item.Contains("."))
{
break;
}
}
IPAddress ipAddress = ipHostInfo.AddressList[i];
IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
// Create a TCP/IP socket.
Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// Connect to the remote endpoint.
client.BeginConnect(remoteEP,
new AsyncCallback(ConnectCallback), client);
connectDone.WaitOne();
// Send test data to the remote device.
Send(client, toSend + "<EOF>");
sendDone.WaitOne();
// Receive the response from the remote device.
Receive(client);
receiveDone.WaitOne();
// Write the response to the console.
//Console.WriteLine("Response received : {0}", response);
// Release the socket.
client.Shutdown(SocketShutdown.Both);
client.Close();
if (OnResponse != null)
{
OnResponse.Invoke(this, new StringBuilder(response));
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
internal Task SetReponseAsync(OicMessage message)
{
lock (_reponseLock)
_response = message;
_responseTcs.TrySetResult(true);
return(Task.Run(() => OnResponse?.Invoke(this, new OicRequestResponseEventArgs {
Message = message
})));
}
/// <summary>
/// Sends a command asynchronously. Uses standard Eventpattern. OnResponse will
/// be raised when the command has executed
/// </summary>
/// <param name="cmd"></param>
public void sendCommandAsync(Command cmd)
{
System.Threading.Thread t = new System.Threading.Thread((System.Threading.ThreadStart) delegate
{
var response = sendCommand(cmd);
OnResponse?.Invoke(this, new ResponseEventArgs <Command, Command.Response>(cmd, response));
});
t.IsBackground = true;
t.Start();
}
public string Receive()
{
// Receive the response from the remote device.
Receive(client);
receiveDone.WaitOne();
if (OnResponse != null)
{
OnResponse.Invoke(this, new StringBuilder(response));
}
return(response);
}
internal bool FireResponse(IncomingResponse response)
{
lock (Sync)
{
if (Responded)
{
return(false);
}
OnResponse?.Invoke(response);
return(Responded = true);
}
}
public async void Accept()
{
_guiDispatcher.Invoke(() =>
{
OnResponse?.Invoke(Room);
GameVM gameVm = new GameVM(Room);
GameRoom gameRoom = new GameRoom();
gameRoom.DataContext = gameVm;
gameRoom.Visibility = Visibility.Visible;
});
await gameBl.AcceptInvitation(Room, Sender);
}
public void ReadCallback(IAsyncResult ar)
{
String content = String.Empty;
// Retrieve the state object and the handler socket
// from the asynchronous state object.
StateObject state = (StateObject)ar.AsyncState;
Socket handler = state.workSocket;
// Read data from the client socket.
int bytesRead = handler.EndReceive(ar);
if (bytesRead > 0)
{
// There might be more data, so store the data received so far.
state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
// Check for end-of-file tag. If it is not there, read
// more data.
content = state.sb.ToString();
if (content.IndexOf("<EOF>") > -1)
{
// All the data has been read from the
// client. Display it on the console.
// but remove <EOF> tag
Console.WriteLine("Read {0} bytes from socket.", content.Length);
content = content.Substring(0, content.Length - 5);
// Echo the data back to the client.
// with modif event
var close = false;
if (content.IndexOf("close") > -1)
{
close = true;
}
state.sb.Clear();
state.sb.Append(content);
OnResponse.Invoke(this, state.sb);
content = state.sb.ToString();
Send(handler, content);
if (close)
{
CloseClient(handler);
}
}
else
{
// Not all data received. Get more.
handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
}
}
}
/// <inheritdoc />
public override void Respond(string message, string sender = null, string font = null)
{
if (sender == "Server")
{
sender = null;
font = null;
}
var msg = new TorchChatMessage(sender ?? TorchBase.Instance.Config.ChatName, message, font ?? TorchBase.Instance.Config.ChatColor);
Responses.Add(msg);
OnResponse?.Invoke(msg);
}
public MockVMController(IVMFactory vmFactory, string hubConnectionId = null, Action <string, string> responseDelegate = null) : this()
{
_connectionId = hubConnectionId ?? $"conn{IdCount++}";
_vmController = new VMController((connectionId, vmId, vmData) =>
{
_response.Handler(connectionId, vmId, vmData);
if (responseDelegate != null)
{
responseDelegate(connectionId, vmData);
}
else
{
OnResponse?.Invoke(this, vmData);
}
}, vmFactory);
}
private void SetText(MessageType type, string text)
{
OnResponse?.Invoke(text, type);
// Read Text
if (type == MessageType.History)
{
if (text.ToLower().Contains("code is"))
{
voice.Speak("I'm sorry. I could not hear you properly.");
}
else
{
voice.SpeakAsync(text);
}
}
}
public async Task <bool> TryResponse(SocketMessage msg)
{
ButtonResponse BR;
await _locker.WaitAsync().ConfigureAwait(false);
try
{
if (msg == null || msg.Author.IsBot || msg.Channel.Id != Game.Channel)
{
return(false);
}
int response = ResponseParse(msg.Content);
if (response == -1)
{
return(false);
}
var usr = msg.Author as IGuildUser;
if (usr == null)
{
return(false);
}
BR = new ButtonResponse()
{
UserID = msg.Author.Id,
Pushed = Convert.ToBoolean(response)
};
if (Game.Responses.Any(x => x.UserID == msg.Author.Id))
{
return(false);
}
if (!Game.Responses.Add(BR))
{
return(false);
}
var _ = OnResponse?.Invoke(msg as IUserMessage, usr);
}
finally { _locker.Release(); }
return(true);
}
private void InternalResponse(FormState formState)
{
OnResponse?.Invoke(Response);
if (Response.Succeed && Response.Response.Status.Succeeded())
{
Record = Response.Response.Data;
FormState = formState;
OnResponseSucceeded?.Invoke(Response);
}
else if (Response.HasException)
{
OnResponseException?.Invoke(Response);
}
else
{
OnResponseFailed?.Invoke(Response);
}
}
public MockVMController(TViewModel vmInstance = default(TViewModel))
{
if (vmInstance?.Equals(default(TViewModel)) == false)
{
VMController.CreateInstance = (type, args) => type == typeof(TViewModel) ? vmInstance : throw new InvalidOperationException();
}
else
{
VMController.CreateInstance = (type, args) => Activator.CreateInstance(type, args);
}
VMController.Register <TViewModel>();
_vmId = typeof(TViewModel).Name;
_vmController = new VMController((connectionId, vmId, vmData) =>
{
_response.Handler(connectionId, vmId, vmData);
OnResponse?.Invoke(this, vmData);
});
}
public override void Respond(string message, string sender = "Server", string font = "Blue")
{
_response.AppendLine(message);
if (_cancelToken != null)
{
_cancelToken.Cancel();
}
_cancelToken = new CancellationTokenSource();
var a = Task.Delay(500, _cancelToken.Token)
.ContinueWith((t) =>
{
string chunk;
lock (_response)
{
chunk = _response.ToString();
_response.Clear();
}
OnResponse.Invoke(ResponeChannel, chunk, sender, font);
});
}
protected void Execute()
{
var requestThread = new Thread(delegate()
{
try
{
var url = BackendUrl + Path + "?s=" + CurrentSessionId;
var data = "";
foreach (var i in Parameters)
{
var p = i.Split(new[] { "=" }, StringSplitOptions.None);
if (p.Length == 2)
{
data += "&" + HttpUtility.UrlEncode(p[0]) + "=" + HttpUtility.UrlEncode(p[1]);
}
}
if (Method == "GET")
{
url += data;
}
var request = (HttpWebRequest)HttpWebRequest.Create(url);
request.CookieContainer = new CookieContainer(3);
request.CookieContainer.Add(new Cookie("wcf_cookieHash", CurrentSessionId, "/", ".www.modapi.cc"));
request.CookieContainer.Add(new Cookie("wcf_userID", UserId + "", "/", ".www.modapi.cc"));
request.CookieContainer.Add(new Cookie("wcf_password", Hash, "/", ".www.modapi.cc"));
request.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => { return(true); };
request.UserAgent = "ModAPI";
if (Method == "POST")
{
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded";
if (data.Length > 1)
{
var postData = data.Substring(1);
var postBytes = Encoding.UTF8.GetBytes(postData);
request.ContentLength = postBytes.Length;
var dataStream = request.GetRequestStream();
dataStream.Write(postBytes, 0, postBytes.Length);
dataStream.Close();
}
}
var response = (HttpWebResponse)request.GetResponse();
var responseStream = response.GetResponseStream();
var serializer = new DataContractJsonSerializer(ResponseType);
var obj = (Response)serializer.ReadObject(responseStream);
if (obj.Header != null && obj.Header.SessionId != null)
{
CurrentSessionId = obj.Header.SessionId;
if (obj.Header.Status != null)
{
ResponseHandler.Invoke(obj);
RequestCompleted();
return;
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
ResponseHandler.Invoke(null);
RequestCompleted();
});
requestThread.Start();
}
public void Response(ZpiObject zpiObject)
{
OnResponse?.Invoke(this, zpiObject);
}
private void ProcessReceivingMessages()
{
Task.Run(async() =>
{
while (socket.State == WebSocketState.Open)
{
ArraySegment <byte> buffer;
WebSocketReceiveResult result = null;
try
{
buffer = new ArraySegment <byte>(new byte[1024]);
result = await socket.ReceiveAsync(buffer, ReceiveTokenSource.Token);
}
catch (Exception ex)
{
socket = null;
IsActive = false;
IsConnected = false;
return;
}
if (result == null || result.Count == 0)
{
continue;
}
Kaenx.Konnect.Remote.MessageCodes code = (Konnect.Remote.MessageCodes)buffer.Array[0];
Debug.WriteLine("Got Remote Message: " + code);
//Check if assemby from this genügt
var q = from t in Assembly.LoadFrom("Kaenx.Konnect.dll").GetTypes()
where t.IsClass && t.IsNested == false && t.Namespace == "Kaenx.Konnect.Remote"
select t;
IRemoteMessage message = null;
foreach (Type t in q.ToList())
{
IRemoteMessage down = (IRemoteMessage)Activator.CreateInstance(t);
if (down != null && code == down.MessageCode)
{
message = down;
break;
}
}
if (message == null)
{
Debug.WriteLine("Unbekannte Nachricht: " + code);
}
try
{
message.Parse(buffer.Array.Take(result.Count).ToArray());
}
catch (Exception ex)
{
}
if (message is TunnelRequest && (message as TunnelRequest).Type == TunnelTypes.Connect)
{
TunnelRequest req = message as TunnelRequest;
KnxRemote rem = new KnxRemote(Encoding.UTF8.GetString(req.Data), this);
await rem.Init(getUsbHandler);
int connId = await rem.ConnectToInterface(req);
Remotes.Add(connId, rem);
continue;
}
if (message.ToString().EndsWith("Response"))
{
Responses[message.SequenceNumber] = message;
OnResponse?.Invoke(message);
}
else
{
OnRequest?.Invoke(message);
}
}
Debug.WriteLine("Verbindung abgebrochen");
});
}
public void SetResponse(MnlMessage response)
{
Response = response;
OnResponse?.Invoke(response);
}
public void Handle(GetStatusResponse message)
{
OnResponse?.Invoke(message);
}
internal void DataReception()
{
while (ListeningForData)
{
ReceivedData data;
try {
data = ReceiveData();
}
catch (ObjectDisposedException) {
ListeningForData = false;
return;
}
catch (IOException e) {
if (e.InnerException is SocketException socketE)
{
if (socketE.SocketErrorCode == SocketError.Interrupted)
{
ListeningForData = false;
return;
}
}
continue;
}
if (!ListeningForData)
{
return;
}
if (data.DataType == typeof(SocketException))
{
ListeningForData = false;
return;
}
if (data.DataType == typeof(UndefinedPacketEventArgs))
{
OnUndefinedPacketReceived?.Invoke(this, new UndefinedPacketEventArgs(infoAboutOtherSide.ID, data.DataID, (byte[])data.ReceivedObject));
}
#region Primitives
if (data.DataID == 0)
{
if (OnStringReceived == null)
{
throw new NullReferenceException("Received a string packet, but the OnStringReceived event is not consumed!");
}
OnStringReceived(this, new PacketReceivedEventArgs <string>((string)data.ReceivedObject, data.SenderID));
}
else if (data.DataID == 1)
{
if (OnInt64Received == null)
{
throw new NullReferenceException("Received an Int64(long) packet, but the OnInt64Received event is not consumed!");
}
OnInt64Received(this, new PacketReceivedEventArgs <Int64>((Int64)data.ReceivedObject, data.SenderID));
}
#endregion
if (dataIDs.customIDs.ContainsKey(data.DataID))
{
dataIDs.customIDs[data.DataID].ActionCallback.Invoke(data.SenderID, data.ReceivedObject);
continue;
}
if (data.DataID == DataIDs.RESPONSE_RECEPTION_ID)
{
OnResponse?.Invoke(this, (TCPResponse)data.ReceivedObject);
}
else if (data.DataID != DataIDs.REQUEST_RECEPTION_ID)
{
HigherLevelDataReceived(data);
}
}
}
private void CancelButton_OnButtonClick(UIElement button)
{
OnResponse?.Invoke(false);
}
public void Response()
{
while (true)
{
try
{
byte[] receivebuffer = new byte[this.buffersize];
//this..Receive(receivebuffer, 0, receivebuffer.Length, 0);
//string response = Encoding.ASCII.GetString(receivebuffer);
StringBuilder messageData = new StringBuilder();
int bytes = -1;
do
{
bytes = sslStream.Read(receivebuffer, 0, receivebuffer.Length);
Decoder decoder = Encoding.UTF8.GetDecoder();
char[] messagepart = new char[decoder.GetCharCount(receivebuffer, 0, bytes)];
decoder.GetChars(receivebuffer, 0, bytes, messagepart, 0);
messageData.Append(messagepart);
if (messageData.ToString().IndexOf("<EOF>") != -1)
{
break;
}
} while (bytes != 0);
string response = messageData.ToString();
response = response.Substring(0, response.Length - 5);
Console.WriteLine(response);
JObject obj = JObject.Parse(response);
if (obj["action"] == null)
{
/*
* Error shit
* To do:
* Write a file with the logs
* Creating the MedicalProblems object
*
*
*/
Console.WriteLine("No action has been sent!");
return;
}
string action = (string)obj["action"];
switch (action)
{
case "response":
MedicalProblems problem = new MedicalProblems();
Console.WriteLine("yes");
Console.WriteLine(obj["rezultat"][0][0].GetType());
Console.WriteLine(obj["rezultat"][1][1]);
problem.Chanse_To_Have = obj["rezultat"][0][0].ToObject <double>();
problem.Chanse_To_Have_Nothing = obj["rezultat"][1][1].ToObject <double>();
//Console.WriteLine("Problem with invoke shit");
OnResponse?.Invoke(this, new OnReceiveMessageClientEventArgs {
Medical = problem
});
break;
case "regresponse":
Console.WriteLine("Receiving register response");
OnRegisterResponse?.Invoke(this, new OnReceiveRegisterMessageArgs {
errorcode = (int)obj["errorcode"], errormessage = (string)obj["errormessage"]
});
break;
case "loginresponse":
//Console.WriteLine("Receiving login response");
Console.WriteLine("Code..... \n");
string errorcodeestring = (string)obj["error"];
Console.WriteLine(errorcodeestring);
int errorcodee = Int32.Parse(errorcodeestring);
Console.WriteLine("Cod de eroare: " + errorcodee);
if (errorcodee == 0)
{
this.Cookie = (string)obj["cookie"];
this.isloged = true;
}
OnLoginResponse?.Invoke(this, new OnReceiveLoginMessageArgs {
errorcode = errorcodee, errormessage = (string)obj["errormessage"], username = (string)obj["username"]
});
break;
case "code_verify_response":
Console.WriteLine("Receiving code_verify response");
OnCodeVerifyResponse?.Invoke(this, new OnCodeVerifyResponseArgs {
errorcode = (int)obj["errorcode"], errormessage = (string)obj["errormessage"]
});
break;
case "results":
int errorcode = (int)obj["error"];
if (errorcode == 0)
{
OnReceiveResultArgs args = JsonConvert.DeserializeObject <OnReceiveResultArgs>(response);
OnReceiveResults?.Invoke(this, args);
}
else
{
}
break;
default:
/*
* Some error comming from server
* or maybe from client?
* IDK
*
* */
break;
}
}
catch (Exception ex)
{
OnConnectionLost?.Invoke(this, EventArgs.Empty);
Console.WriteLine("Wrong format " + ex.Message);
this.isloged = false;
break;
}
}
}