protected async Task <T> EnsureApiResult <T>(HttpResponseMessage result)
{
if (result.StatusCode != HttpStatusCode.OK)
{
if (result.StatusCode == HttpStatusCode.NotFound)
{
var apiException =
new AdminApiException
{
ErrorMessage = "Method not found"
};
throw new AdminApiProxyException(apiException, result.StatusCode);
}
else if (result.StatusCode == HttpStatusCode.Unauthorized || result.StatusCode == HttpStatusCode.BadRequest)
{
var details = result.Content.ReadAsAsync <UnauthorizedDetails>().Result;
var apiException = JsonConvert.DeserializeObject <AdminApiException>(details.error_description);
throw new AdminApiProxyException(apiException, result.StatusCode);
}
else
{
var apiException = result.Content.ReadAsAsync <AdminApiException>().Result;
throw new AdminApiProxyException(apiException, result.StatusCode);
}
}
var response = await result.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <T>(response));
//return await result.Content.ReadAsAsync<T>();
}
public static void HandleWebException(WebException e)
{
var webResponse = e.Response as HttpWebResponse;
if (webResponse != null)
{
HttpWebResponse response = webResponse;
if (response.StatusCode != HttpStatusCode.OK)
{
if (response.StatusCode == HttpStatusCode.NotFound)
{
var apiException =
new AdminApiException
{
ErrorMessage = "Method not found"
};
throw new AdminApiProxyException(apiException, response.StatusCode);
}
var responseText = "";
var responseStream = response.GetResponseStream();
if (responseStream != null)
{
using (var reader = new StreamReader(responseStream))
{
responseText = reader.ReadToEnd();
}
}
if (responseText.Contains(HttpStatusCode.Forbidden.ToString().ToLower()))
{
throw new HttpException(403, "Access forbidden");
}
if (response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.BadRequest)
{
var apiException = JsonConvert.DeserializeObject <AdminApiException>(responseText);
throw new AdminApiProxyException(apiException, response.StatusCode);
}
else
{
var apiException =
new AdminApiException
{
ErrorMessage = "Unhandled exception: " + responseText
};
throw new AdminApiProxyException(apiException, response.StatusCode);
}
}
}
}
public override Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
AdminApiException exception;
try
{
var admin = _container.Resolve <IAdminQueries>().GetAdminByName(context.UserName);
if (admin == null)
{
throw new Exception("Admin not found");
}
var authQueries = _container.Resolve <IAuthQueries>();
if (!authQueries.GetValidationResult(new LoginActor {
ActorId = admin.Id, Password = context.Password
}).IsValid)
{
throw new Exception("Incorrect username or password");
}
var identity = _container.Resolve <ClaimsIdentityProvider>().GetActorIdentity(admin.Id, context.Options.AuthenticationType);
context.Validated(identity);
context.Request.Context.Authentication.SignIn(identity);
return(Task.FromResult(0));
}
catch (Exception ex)
{
exception = new AdminApiException
{
ErrorCode = ex.Message,
ErrorMessage = ex.Message,
Violations = new[]
{
new ValidationErrorField
{
ErrorCode = ex.Message,
ErrorMessage = ex.Message,
FieldName = string.Empty
}
}
};
}
context.Rejected();
var sError = JsonConvert.SerializeObject(exception);
context.SetError("Login error", sError);
context.Response.Headers.Add(InvalidLoginOwinMiddleware.InvalidLoginHeader, new[] { sError });
return(Task.FromResult(0));
}
public override void Handle(ExceptionHandlerContext context)
{
base.Handle(context);
if (context.Exception is HttpException)
{
return;
}
var content = new AdminApiException
{
ErrorCode = HttpStatusCode.InternalServerError.ToString(),
ErrorMessage = context.Exception.Message,
StackTrace = context.Exception.StackTrace
};
context.Result = new ErrorResult
{
Request = context.ExceptionContext.Request,
Content = JsonConvert.SerializeObject(content)
};
}
public AdminApiProxyException(AdminApiException exception, HttpStatusCode code) : base(exception.ErrorMessage)
{
StatusCode = code;
Exception = exception;
}
