public void GetInformations()
{
// Get the test source
var testSource = Profile.FindSource( ConfigurationManager.AppSettings["Station"] )[0];
// Activate
ServerImplementation.EndRequest( CardServer.BeginSelect( testSource.SelectionKey ) );
// Create request helper
var requestor = new RequestInformation( CardServer );
// Remember
var sources = ((GenericInformationResponse) requestor.BeginGetGroupInformation().Result).Strings.Select( s => SourceIdentifier.Parse( s ) ).ToArray();
// Request data
foreach (var group in ((NetworkInformationResponse) requestor.BeginGetNetworkInformation().Result).Groups)
Console.WriteLine( group );
// Resolve names
var names = ((GenericInformationResponse) requestor.BeginGetSourceInformation( sources ).Result).Strings;
// Report
for (int i = 0, imax = Math.Max( sources.Length, names.Length ); i < imax; i++)
Console.WriteLine( "{0} => {1}", sources[i], names[i] );
}
/// <summary>
/// Update the navigation property exportJobs in deviceManagement
/// <param name="body"></param>
/// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
/// </summary>
public RequestInformation CreatePatchRequestInformation(DeviceManagementExportJob body, Action <DeviceManagementExportJobItemRequestBuilderPatchRequestConfiguration> requestConfiguration = default)
{
_ = body ?? throw new ArgumentNullException(nameof(body));
var requestInfo = new RequestInformation {
HttpMethod = Method.PATCH,
UrlTemplate = UrlTemplate,
PathParameters = PathParameters,
};
requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
if (requestConfiguration != null)
{
var requestConfig = new DeviceManagementExportJobItemRequestBuilderPatchRequestConfiguration();
requestConfiguration.Invoke(requestConfig);
requestInfo.AddRequestOptions(requestConfig.Options);
requestInfo.AddHeaders(requestConfig.Headers);
}
return(requestInfo);
}
/// <summary>
/// Update media content for the navigation property photos in groups
/// <param name="body">Binary request body</param>
/// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
/// </summary>
public RequestInformation CreatePutRequestInformation(Stream body, Action <ContentRequestBuilderPutRequestConfiguration> requestConfiguration = default)
{
_ = body ?? throw new ArgumentNullException(nameof(body));
var requestInfo = new RequestInformation {
HttpMethod = Method.PUT,
UrlTemplate = UrlTemplate,
PathParameters = PathParameters,
};
requestInfo.SetStreamContent(body);
if (requestConfiguration != null)
{
var requestConfig = new ContentRequestBuilderPutRequestConfiguration();
requestConfiguration.Invoke(requestConfig);
requestInfo.AddRequestOptions(requestConfig.Options);
requestInfo.AddHeaders(requestConfig.Headers);
}
return(requestInfo);
}
/// <summary>
/// Create new navigation property to extensions for me
/// <param name="body"></param>
/// <param name="requestConfiguration">Configuration for the request such as headers, query parameters, and middleware options.</param>
/// </summary>
public RequestInformation CreatePostRequestInformation(Extension body, Action <ExtensionsRequestBuilderPostRequestConfiguration> requestConfiguration = default)
{
_ = body ?? throw new ArgumentNullException(nameof(body));
var requestInfo = new RequestInformation {
HttpMethod = Method.POST,
UrlTemplate = UrlTemplate,
PathParameters = PathParameters,
};
requestInfo.SetContentFromParsable(RequestAdapter, "application/json", body);
if (requestConfiguration != null)
{
var requestConfig = new ExtensionsRequestBuilderPostRequestConfiguration();
requestConfiguration.Invoke(requestConfig);
requestInfo.AddRequestOptions(requestConfig.Options);
requestInfo.AddHeaders(requestConfig.Headers);
}
return(requestInfo);
}
public void RequestInformationConstructorTest()
{
string expected = "TaekyuKimrequeststatusJhon50";
string firstName = "Taekyu"; // TODO: Initialize to an appropriate value
string lastName = "Kim"; // TODO: Initialize to an appropriate value
string request = "request"; // TODO: Initialize to an appropriate value
string status = "status"; // TODO: Initialize to an appropriate value
string assignment = "Jhon"; // TODO: Initialize to an appropriate value
double grade = 50; // TODO: Initialize to an appropriate value
RequestInformation target = new RequestInformation(firstName, lastName, request, status, assignment, grade); // TODO: Initialize to an appropriate value
string b = target.getFirstName;
string c = target.getLastName;
string d = target.getRequest;
string e = target.getStatus;
string a = target.getAssignment;
string f = target.getGrade.ToString();
string actual = b + c + d + e + a + f;
Assert.AreEqual(expected, actual);
}
public async Task <int> UpdateRequestInfo(int id, TaskTypeViewModel taskTypeViewModel)
{
if (_db != null)
{
RequestInformation existItem = _db.RequestInformation.Where(f => f.IdrequestInformation == id).FirstOrDefault();
if (existItem != null)
{
existItem.SenderId = taskTypeViewModel.reqInfo.SenderId;
existItem.RecieverId = taskTypeViewModel.reqInfo.RecieverId;
existItem.Notes = taskTypeViewModel.reqInfo.Notes;
existItem.FileId = taskTypeViewModel.reqInfo.FileId;
existItem.TaskId = taskTypeViewModel.reqInfo.TaskId;
}
_db.RequestInformation.Update(existItem);
await _db.SaveChangesAsync();
return(1);
}
return(0);
}
public async Task ExponentialRetryRetriesOnBatchException()
{
TimeSpan interval = TimeSpan.FromSeconds(5);
const int maxRetries = 10;
ExponentialRetry exponentialRetry = new ExponentialRetry(interval, maxRetries);
RequestInformation reqInfo = new RequestInformation()
{
HttpStatusCode = HttpStatusCode.InternalServerError
};
BatchException batchException = new BatchException(reqInfo, "Message", null);
OperationContext context = new OperationContext();
context.RequestResults.Add(new RequestResult(new RequestInformation(), batchException));
RetryDecision retryDecision = await exponentialRetry.ShouldRetryAsync(batchException, context);
Assert.Equal(interval, retryDecision.RetryDelay);
Assert.Equal(true, retryDecision.ShouldRetry);
}
public async Task ExponentialRetryHonorsRetryAfter()
{
TimeSpan interval = TimeSpan.FromSeconds(60);
TimeSpan retryAfter = TimeSpan.FromSeconds(10);
const int maxRetries = 10;
ExponentialRetry exponentialRetry = new ExponentialRetry(interval, maxRetries);
RequestInformation reqInfo = new RequestInformation()
{
HttpStatusCode = (HttpStatusCode)429,
RetryAfter = retryAfter
};
BatchException batchException = new BatchException(reqInfo, "Message", null);
OperationContext context = new OperationContext();
context.RequestResults.Add(new RequestResult(new RequestInformation(), batchException));
RetryDecision retryDecision = await exponentialRetry.ShouldRetryAsync(batchException, context);
Assert.Equal(retryAfter, retryDecision.RetryDelay);
Assert.True(retryDecision.ShouldRetry);
}
public object AfterReceiveRequest(ref Message request,
IClientChannel channel, InstanceContext instanceContext)
{
if (OperationContext.Current.OutgoingMessageProperties.ContainsKey(
HttpRequestInformationProperty))
{
return(null);
}
var info = new RequestInformation();
var contentLengthHeader =
WebOperationContext.Current.IncomingRequest.Headers[HttpRequestHeader.ContentLength];
long contentLength;
if (!string.IsNullOrEmpty(contentLengthHeader))
{
long.TryParse(contentLengthHeader, out contentLength);
}
else
{
contentLength = -1;
}
info.ContentLength = contentLength;
info.Uri = OperationContext.Current.IncomingMessageHeaders.To;
info.Method = WebOperationContext.Current.IncomingRequest.Method;
info.ContentType = WebOperationContext.Current.IncomingRequest.ContentType;
info.Accept = WebOperationContext.Current.IncomingRequest.Accept;
info.UserAgent = WebOperationContext.Current.IncomingRequest.UserAgent;
info.Headers = WebOperationContext.Current.IncomingRequest.Headers;
OperationContext.Current.OutgoingMessageProperties.Add(
HttpRequestInformationProperty, info);
return(null);
}
public void WebAppChainingTest19()
{
HttpWebRequest request = CreateRequest1();
request.Headers.Add("X-Version", "1.9");
request.Headers.Add("X-AUTHENTICATE-participantId", "UnitTest");
request.Headers.Add("X-AUTHENTICATE-UserID", "WebAppChainingTest");
Exception e = null;
HttpWebResponse response = GetResponse(request, out e);
Assert.IsNotNull(response, "Response");
responseStream = response.GetResponseStream();
string errorPage;
if (e != null)
{
errorPage = new StreamReader(responseStream).ReadToEnd();
}
Assert.IsNull(e);
XmlSerializer serializer = new XmlSerializer(typeof(RequestInformation));
RequestInformation info = (RequestInformation)serializer.Deserialize(responseStream);
Assert.IsNotNull(info, "RequestInformation");
Assert.AreEqual("1.9", info.GetHeader("X-01-Version"));
Assert.IsNotNull(info.GetHeader("X-AUTHENTICATE-cn"), "X-AUTHENTICATE-cn");
Assert.AreEqual("common name", info.GetHeader("X-AUTHENTICATE-cn"));
Assert.IsNotNull(info.GetHeader("X-01-AUTHENTICATE-participantId"), "X-01-AUTHENTICATE-participantId");
Assert.AreEqual("UnitTest", info.GetHeader("X-01-AUTHENTICATE-participantId"));
Assert.IsNotNull(info.GetHeader("X-01-AUTHENTICATE-UserID"), "X-01-AUTHENTICATE-UserID");
Assert.AreEqual("WebAppChainingTest", info.GetHeader("X-01-AUTHENTICATE-UserID"));
}
private static void InternalHandleError(Exception error)
{
var behavior = GetWebErrorHandlerConfiguration();
if (behavior == null || behavior.LogHandler == null)
{
return;
}
RequestInformation info;
if (OperationContext.Current.OutgoingMessageProperties.ContainsKey(
ErrorHandlerBehavior.HttpRequestInformationProperty))
{
info = (RequestInformation)OperationContext.Current.OutgoingMessageProperties[
ErrorHandlerBehavior.HttpRequestInformationProperty];
}
else
{
info = new RequestInformation();
}
behavior.LogHandler.Write(error, info);
}
public void RequestType_Success_Should_BeQuery()
{
IRequestInformation <TestQuery> requestInformation = new RequestInformation <TestQuery>();
requestInformation.RequestType.Should().Be(ERequestType.Query);
}
/// <summary>
/// Executes the request.
/// </summary>
/// <returns>An asynchronous operation of return type <typeparamref name="TResponse"/>.</returns>
public async Task <TResponse> ExecuteRequestAsync()
{
this.hasRequestExecutionStarted = true;
bool shouldRetry;
do
{
shouldRetry = false; //Start every request execution assuming there will be no retry
Task <TResponse> serviceRequestTask = null;
Exception capturedException;
//Participate in cooperative cancellation
this.CancellationToken.ThrowIfCancellationRequested();
try
{
this.ApplyClientRequestIdBehaviorToParams();
serviceRequestTask = this.ExecuteRequestWithCancellationAsync(this.ServiceRequestFunc);
TResponse response = await serviceRequestTask.ConfigureAwait(continueOnCapturedContext : false);
//TODO: It would be nice if we could add to OperationContext.RequestResults here
return(response);
}
catch (Exception e)
{
//If the caught exception was a BatchErrorException, we wrap it in the object model exception type
BatchException batchException = null;
if (e is BatchErrorException)
{
batchException = new BatchException(e as BatchErrorException);
}
Exception wrappedException = batchException ?? e;
if (this.RetryPolicy != null &&
//If cancellation is requested at this point, just skip calling the retry policy and throw
//This is the most honest thing to do since we will not be issuing another request on the users behalf
//(since the cancellation token has already been set) and thus calling their retry policy would just
//be confusing.
!this.CancellationToken.IsCancellationRequested)
{
RequestInformation requestInformation;
if (batchException != null)
{
//If there is a BatchException, extract the RequestInformation and capture it
requestInformation = batchException.RequestInformation;
}
else
{
requestInformation = new RequestInformation()
{
ClientRequestId = this.Options.ClientRequestId
};
}
this.OperationContext.RequestResults.Add(new RequestResult(requestInformation, wrappedException)
{
Task = serviceRequestTask
});
capturedException = wrappedException;
}
else
{
if (batchException != null)
{
throw batchException; //Just forward the wrapped exception if there was one
}
else
{
throw;
}
}
}
if (capturedException != null)
{
//On an exception, invoke the retry policy
RetryDecision retryDecision = await this.RetryPolicy.ShouldRetryAsync(capturedException, this.OperationContext).ConfigureAwait(continueOnCapturedContext: false);
shouldRetry = retryDecision.ShouldRetry;
if (!shouldRetry)
{
//Rethrow the exception and explicitly preserve the stack trace
ExceptionDispatchInfo.Capture(capturedException).Throw();
}
else
{
if (retryDecision.RetryDelay.HasValue)
{
await Task.Delay(retryDecision.RetryDelay.Value).ConfigureAwait(continueOnCapturedContext: false);
}
else
{
Debug.Assert(false, "RetryDecision.ShouldRetry = true but RetryDelay has no value");
}
}
}
} while (shouldRetry);
//Reaching here is a bug, by now the request should have either thrown or returned
const string errorMessage = "Exited ExecuteRequestAsync without throwing or returning";
Debug.Assert(false, errorMessage);
throw new InvalidOperationException(errorMessage);
}
public override Task <SkillResponse> Handle(RequestInformation information)
{
throw new InvalidOperationException("You shouldn't have done that");
}
/// <summary>Sends an UDP message to a given node.</summary>
/// <param name="message">The message to be sent.</param>
/// <param name="target">The address of the target node.</param>
/// <param name="targetNodeId">The target node ID.</param>
internal void SendUdpMessage(UdpMessage message, IPEndPoint target, KademliaId targetNodeId)
{
message.RequestId = Random.UInt64();
message.SenderNodeId = Id;
var requestIdentifier = new RequestIdentifier {EndPoint = target, RequestId = message.RequestId};
var requestInformation = new RequestInformation {OutgoingMessage = message, SecondAttempt = false, NodeId = targetNodeId};
if (message.IsRequest)
{
lock (outstandingRequests)
{
outstandingRequests.Add(requestIdentifier, requestInformation);
}
}
SendUdp(message, target);
}
public override bool CanHandle(RequestInformation information)
{
return(information.SkillRequest.Request is LaunchRequest);
}
public override SkillResponse HandleSyncRequest(RequestInformation information)
{
return(ResponseBuilder.Tell("okay, I hope you found it interesting"));
}
private void socketHelper_SocketDataReceived(string data)
{
if (socketHelper.IsHandshake)
{
BaseResponse <AccountInformation> response = JsonConvert.DeserializeObject <BaseResponse <AccountInformation> >(data);
if (response != null && response.Status == 200)
{
this.accountInfo = response.Data;
this.contacts = WebConnector.GetContactsData(accountInfo.Id);
this.requests = WebConnector.GetAvailableRequests(accountInfo.Id);
this.DisplayContactsAndRequests();
this.socketHelper.IsHandshake = false;
this.socketHelper.IsAuthorized = true;
this.UpdateClientMenu(true);
}
else
{
MessageBox.Show("An error occurred: " + response.ErrorMessage, "Error logging in", MessageBoxButtons.OK, MessageBoxIcon.Error);
this.socketHelper.CloseConnection();
this.UpdateClientMenu(false);
}
return;
}
Message message = Message.CreateMessageObject(data);
bool isCallContent = false;
if (message == null || (message.Command.Equals("/disconnect") && message.Content.Equals("OK")))
{
socketHelper.CloseConnection();
UpdateClientOnDisconnect();
return;
}
else if (message.Command.Equals(@"/online"))
{
string username = message.Content;
ChangeOnlineStatus(username);
return;
}
else if (message.Command.Equals(@"/request"))
{
RequestInformation request = null;
try
{
//Console.WriteLine(message.Content);
request = JsonConvert.DeserializeObject <RequestInformation>(message.Content);
}
catch (Exception ex)
{
Console.WriteLine("An error occurred while parsing request command: " + ex.Message);
}
if (request != null)
{
this.requests.Add(request);
this.FillRequestsList();
}
return;
}
else if (message.Command.Equals(@"/accept"))
{
AccountInformation contact = null;
try
{
contact = JsonConvert.DeserializeObject <AccountInformation>(message.Content);
}
catch (Exception ex)
{
Console.WriteLine("An error occurred while parsing accept command: " + ex.Message);
}
if (contact != null)
{
this.contacts.ContactsList.Add(contact);
this.AppendContact(contact);
this.ChangeOnlineStatus(contact.Username);
socketHelper.SendMessage(contact.Username, this.accountInfo.Username, this.accountInfo.Username, @"/online");
}
return;
}
else if (message.Command.Equals(@"/offline"))
{
string username = message.Content;
ChangeOnlineStatus(username);
return;
}
else if (message.Command.Contains("call"))
{
isCallContent = true; // We set it to true to avoid dumping call ID's into the message box
if (message.Command.Equals("/call"))
{
this.callSoundPlayer.PlayLooping();
MessengerContainer msgWindow = GetActiveMessengerContainer(message.Sender);
if (msgWindow != null)
{
msgWindow.CreateCallDialog(message.Sender);
msgWindow.callDialog.CallStateChanged += callDialog_CallStateChanged;
}
}
else if (message.Command.Contains("/accept"))
{
MessengerContainer msgWindow = GetActiveMessengerContainer(message.Sender);
if (msgWindow != null)
{
msgWindow.InitiatingCall = false;
}
this.socketHelper.EstablishCall(this.accountInfo.Username);
}
else if (message.Command.Contains("/close"))
{
if (this.socketHelper.CallHelper != null)
{
this.socketHelper.CloseCall();
}
MessengerContainer msgWindow = GetActiveMessengerContainer(message.Sender);
if (msgWindow != null)
{
msgWindow.InitiatingCall = false;
msgWindow.UpdateCallState();
msgWindow.callDialog.CallStateChanged -= callDialog_CallStateChanged;
}
}
}
if (message.Content != string.Empty && !isCallContent)
{
if (message.Sender == this.accountInfo.Username)
{
this.DumpMessage(message, true);
}
else
{
this.DumpMessage(message);
this.notificationSoundPlayer.Play();
SetContainerNotification(message.Sender);
}
}
}
public override async Task <SkillResponse> Handle(RequestInformation information, Exception exception)
{
Console.WriteLine(exception.ToString());
return(ResponseBuilder.Tell("So sorry, but something appears to have gone wrong"));
}
public void RequestType_Success_Should_BeCommand()
{
IRequestInformation <TestCommand> requestInformation = new RequestInformation <TestCommand>();
requestInformation.RequestType.Should().Be(ERequestType.Command);
}
public override SkillResponse HandleSyncRequest(RequestInformation information)
{
return(ResponseBuilder.Ask(response, new Reprompt(reprompt)));
}
public void RequestType_Success_Should_BeNotification()
{
IRequestInformation <AfterSaveETO> requestInformation = new RequestInformation <AfterSaveETO>();
requestInformation.RequestType.Should().Be(ERequestType.Notification);
}
public override SkillResponse HandleSyncRequest(RequestInformation information)
{
return(ResponseBuilder.Ask(
"Hi there, thanks for wanting to learn more about Alexa dot net. What feature would you like to find out about?",
new Reprompt("What feature would you like to find out about?")));
}
public void RequestType_Success_Should_BeRequest()
{
IRequestInformation <TestRequest> requestInformation = new RequestInformation <TestRequest>();
requestInformation.RequestType.Should().Be(ERequestType.Request);
}
