public HttpResponseMessage getAllSites(int city_id)
{
using (smart_trip_dbEntities se = new smart_trip_dbEntities())
{
var sites = se.sites.Where(s => s.city_id != null && s.city_id == city_id).ToList();
return(rh.HandleResponse(new { city_sites = sites }));
}
}
public HttpResponseMessage getRoute(int routeId)
{
using (smart_trip_dbEntities se = new smart_trip_dbEntities())
{
var route = se.routes.Where(s => s.id == routeId).ToList();
return(rh.HandleResponse(new { route = route }));
}
}
public HttpResponseMessage getAll()
{
using (smart_trip_dbEntities se = new smart_trip_dbEntities())
{
var cities = se.cities.ToList();
return(rh.HandleResponse(new { cities = cities }));
}
}
public async Task HandleUserResponse()
{
// Arrange
var responseHandler = new ResponseHandler(new Serializer());
var hrm = new HttpResponseMessage()
{
Content = new StringContent(@"{
""id"": ""123"",
""givenName"": ""Joe"",
""surName"": ""Brown"",
""@odata.type"":""test""
}", Encoding.UTF8, "application/json")
};
hrm.Headers.Add("test", "value");
// Act
var user = await responseHandler.HandleResponse <User>(hrm);
//Assert
Assert.Equal("123", user.Id);
Assert.Equal("Joe", user.GivenName);
Assert.Equal("Brown", user.Surname);
Assert.Equal("OK", user.AdditionalData["statusCode"]);
var headers = (JObject)(user.AdditionalData["responseHeaders"]);
Assert.Equal("value", (string)headers["test"][0]);
}
public RootResponse Root()
{
ResponseHandler <RootResponse> responseHandler = new ResponseHandler <RootResponse>();
var response = HttpClient.GetAsync(_serverUri).Result;
return(responseHandler.HandleResponse(response).Result);
}
private async Task RetryRequestWithTransientFaultAsync(IGraphServiceClient client, BatchRequestContent batchRequestContent, Dictionary <string, HttpResponseMessage> responses, List <SignIn> signIns, int retryCount)
{
BatchRequestContent retryBatchRequestContent = new BatchRequestContent();
BatchResponseContent batchResponseContent;
Random random;
double delta;
client.AssertNotNull(nameof(client));
batchRequestContent.AssertNotNull(nameof(batchRequestContent));
responses.AssertNotNull(nameof(responses));
if (responses.Any(r => IsTransient(r.Value)))
{
if (retryCount <= 3)
{
foreach (KeyValuePair <string, HttpResponseMessage> item in responses.Where(r => IsTransient(r.Value)))
{
retryBatchRequestContent.AddBatchRequestStep(batchRequestContent.BatchRequestSteps[item.Key]);
}
random = new Random();
delta = (Math.Pow(2.0, retryCount) - 1.0) *
random.Next((int)(DefaultClientBackoff.TotalMilliseconds * 0.8), (int)(DefaultClientBackoff.TotalMilliseconds * 1.2));
await Task.Delay((int)Math.Min(DefaultMinBackoff.TotalMilliseconds + delta, DefaultMaxBackoff.TotalMilliseconds), CancellationToken).ConfigureAwait(false);
batchResponseContent = await client.Batch.Request().PostAsync(retryBatchRequestContent, CancellationToken).ConfigureAwait(false);
await ParseBatchResponseAsync(client, retryBatchRequestContent, batchResponseContent, signIns, retryCount).ConfigureAwait(false);
}
else
{
ErrorResponse errorResponse;
List <ServiceException> exceptions = new List <ServiceException>();
ResponseHandler responseHandler = new ResponseHandler(new Serializer());
string rawResponseBody;
foreach (KeyValuePair <string, HttpResponseMessage> item in responses.Where(item => !item.Value.IsSuccessStatusCode))
{
rawResponseBody = null;
if (item.Value.Content?.Headers.ContentType.MediaType == "application/json")
{
rawResponseBody = await item.Value.Content.ReadAsStringAsync().ConfigureAwait(false);
}
errorResponse = await responseHandler.HandleResponse <ErrorResponse>(item.Value).ConfigureAwait(false);
exceptions.Add(new ServiceException(errorResponse.Error, item.Value.Headers, item.Value.StatusCode, rawResponseBody));
}
throw new AggregateException(exceptions);
}
}
}
private static async Task GraphBatchingSequential(GraphServiceClient graphClient)
{
// Create a batch request content "container"
var batchRequestContent = new BatchRequestContent();
// Prepare some requests to add to the batch
var userRequest = graphClient.Users["*****@*****.**"].Request().Select("Id,DisplayName");
var userDriveRequest = graphClient.Users["*****@*****.**"].Drive.Request().Select("Id,WebUrl");
var userHttpRequest = new HttpRequestMessage(HttpMethod.Get, userRequest.RequestUrl);
var userDriveHttpRequest = new HttpRequestMessage(HttpMethod.Get, userDriveRequest.RequestUrl);
var userRequestId = batchRequestContent.AddBatchRequestStep(new BatchRequestStep("1", userHttpRequest));
var userDriveRequestId = batchRequestContent.AddBatchRequestStep(new BatchRequestStep("2", userDriveHttpRequest,
(new string[] { "1" }).ToList()));
// Execute the batch request
var returnedResponse = await graphClient.Batch.Request().PostAsync(batchRequestContent);
// Process batch responses
var responseHandler = new ResponseHandler(new Serializer());
// Now process the dependencies
var userResponse = await returnedResponse
.GetResponseByIdAsync("1");
if (userResponse.IsSuccessStatusCode)
{
var user = await responseHandler.HandleResponse <User>(userResponse);
Console.WriteLine($"{user.Id} - {user.DisplayName}");
}
var userDriveResponse = await returnedResponse
.GetResponseByIdAsync("2");
if (userDriveResponse.IsSuccessStatusCode)
{
var drive = await responseHandler.HandleResponse <Drive>(userDriveResponse);
Console.WriteLine($"{drive.Id} - {drive.WebUrl}");
}
}
public async Task <IActionResult> Index()
{
var request = this._graphServiceClient.Me.Request().GetHttpRequestMessage();
request.Properties["User"] = HttpContext.User;
var response = await this._graphServiceClient.HttpProvider.SendAsync(request);
var handler = new ResponseHandler(new Serializer());
var user = await handler.HandleResponse <User>(response);
return(View(user));
}
public async Task <object> Call(IHttpHandler httpHandler, string baseUrl, HttpApiArguments arguments, HttpApiInstrumenter apiInstrumenter = null)
{
async void ApplyArguments(Func <IHttpArgumentHandler, string, object, Task> applier)
{
foreach (var item in ArgumentHandlers)
{
var name = item.Key;
if (arguments.TryGetValue(name, out var argument))
{
var handler = item.Value;
await applier(handler, name, argument);
}
}
}
HttpApiRequest GetRequest()
{
var request = new HttpApiRequest {
Url = Url.CreateUrl(baseUrl), Method = HttpMethod, Headers = Headers.ToList()
};
ApplyArguments(async(handler, name, argument) => await handler.ApplyArgument(request, name, argument));
if (!request.Headers.Exists(x => x.Name == "Content-Type") && request.Body != null)
{
var contentType = request.Body.Accept(new ContentTypeCalculator());
request.Headers.Add(new HttpHeader("Content-Type", contentType));
}
return(request);
}
async Task <HttpHandlerResponse> GetResponse(HttpApiRequest request)
{
return(await httpHandler.Call(request));
}
async Task <object> GetResult(HttpApiRequest request, HttpHandlerResponse response)
{
ApplyArguments(async(handler, name, argument) => await handler.ApplyArgument(response.ApiResponse, name, argument));
return(await ResponseHandler.HandleResponse(request, response.ApiResponse));
}
IHttpApiInstrumentation instrumentation = new DefaultHttpApiInstrumentation(GetRequest, GetResponse, GetResult);
if (apiInstrumenter != null)
{
instrumentation = apiInstrumenter(this, arguments, instrumentation);
}
return(await MakeCall(instrumentation));
}
public HttpResponseMessage login(UserConnection user)
{
using (smart_trip_dbEntities se = new smart_trip_dbEntities())
{
var user_ = getUserIfExists(se, user.userName, user.password, user.deviceToken);
if (user_ == null)
{
user_ = new users();
user_.uname = user.userName;
user_.password = user.password;
user_.device_token = user.deviceToken;
se.users.Add(user_);
se.SaveChanges();
}
var cities = se.cities.ToList();
var sites = se.sites.Where(s => s.city_id == 1).ToList();
var categories = se.sites_types.ToList();
var recommandedRoutes = se.routes.Where(s => s.rate != null && s.rate >= 4).ToList();
return(rh.HandleResponse(new { user = user_, sites = sites, cities = cities, categories = categories, recommanded_routes = recommandedRoutes }));
}
}
/// <summary>
/// The next page of results or null when there is no more results
/// </summary>
/// <returns></returns>
public async Task <Page <T> > NextPage()
{
if (Links.Next == null)
{
return(null);
}
var responseHandler = new ResponseHandler <Page <T> >();
var uri = new Uri(Links.Next.Href);
using (var httpClient = new HttpClient())
{
var response = await httpClient.GetAsync(uri);
return(await responseHandler.HandleResponse(response));
}
}
/// <summary>
/// Executes a request using the default context and processes the
/// response using the given response handler.
/// </summary>
/// <remarks>
/// Executes a request using the default context and processes the
/// response using the given response handler. The content entity associated
/// with the response is fully consumed and the underlying connection is
/// released back to the connection manager automatically in all cases
/// relieving individual
/// <see cref="Apache.Http.Client.ResponseHandler{T}">Apache.Http.Client.ResponseHandler<T>
/// </see>
/// s from having to manage
/// resource deallocation internally.
/// </remarks>
/// <param name="target">
/// the target host for the request.
/// Implementations may accept <code>null</code>
/// if they can still determine a route, for example
/// to a default target or by inspecting the request.
/// </param>
/// <param name="request">the request to execute</param>
/// <param name="responseHandler">the response handler</param>
/// <param name="context">
/// the context to use for the execution, or
/// <code>null</code> to use the default context
/// </param>
/// <returns>the response object as generated by the response handler.</returns>
/// <exception cref="System.IO.IOException">in case of a problem or the connection was aborted
/// </exception>
/// <exception cref="Apache.Http.Client.ClientProtocolException">in case of an http protocol error
/// </exception>
public virtual T Execute <T, _T1>(HttpHost target, IHttpRequest request, ResponseHandler
<_T1> responseHandler, HttpContext context) where _T1 : T
{
Args.NotNull(responseHandler, "Response handler");
HttpResponse response = Execute(target, request, context);
T result;
try
{
result = responseHandler.HandleResponse(response);
}
catch (Exception t)
{
HttpEntity entity = response.GetEntity();
try
{
EntityUtils.Consume(entity);
}
catch (Exception t2)
{
// Log this exception. The original exception is more
// important and will be thrown to the caller.
this.log.Warn("Error consuming content after an exception.", t2);
}
if (t is RuntimeException)
{
throw (RuntimeException)t;
}
if (t is IOException)
{
throw (IOException)t;
}
throw new UndeclaredThrowableException(t);
}
// Handling the response was successful. Ensure that the content has
// been fully consumed.
HttpEntity entity_1 = response.GetEntity();
EntityUtils.Consume(entity_1);
return(result);
}
public void GetMessages(IEventAggregator _eventAggregator)
{
ResponseHandler._eventAggregator = _eventAggregator;
String response = "";
// Bytes Array to receive Server Response.
Byte[] data = new Byte[512];
Task.Run(async() =>
{
// Read the Tcp Server Response Bytes.
try
{
Int32 bytes;
while ((bytes = await networkStream.ReadAsync(data, 0, data.Length)) != 0)
{
//Int32 bytes = await networkStream.ReadAsync(data, 0, data.Length);
response = System.Text.Encoding.UTF8.GetString(data, 0, bytes);
_eventAggregator?.GetEvent <UpdateUserConsole>().Publish(response);
if (response.Contains("BYE"))
{
ResponseHandler.Bye();
Disconnect();
break;
}
var responseTokens = response.Split(Environment.NewLine);
responseTokens = responseTokens.Where(i => i != "").ToArray();
if (responseTokens.Last().Split(' ')[0] == outgoingTag)
{
//Here we can handle a server result (it means that the command execution is finished
//on server side and we can start handle its result on the server).
wholeServerResponse += response;
ResponseHandler.HandleResponse(outgoingCommand, response);
wholeServerResponse += "";
}
else if (response.Split(' ')[0] == "*" || response.Split(' ')[0] == "+")
{
//Over here we can add a condition for a currently occuring command
//for an instance, sending encryption keys if the server response is "+",
//or when we want to read the information a bit by a bit.
wholeServerResponse += response;
}
else
{
//Illegal server response. Should usually not be the case.
}
}
}
catch (Exception ex)
{
System.Windows.MessageBox.Show("You are now disconnected from the server.");
Disconnect();
ResponseHandler.Bye();
//System.Windows.MessageBox.Show(ex.Message);
//break;
}
});
}