public async Task <IActionResult> PutCompletedTaskAsync(Guid id)
{
var data = await _service.GetAsync(id);
if (data == null)
{
_loger.LogError("Bad request parameter");
var error = new BadRequest("Parameter is null", new { data });
return(error.ReturnResponse());
}
var fkTaskId = await _service.PutCompletedTaskAsync(id);
if (fkTaskId == null)
{
_loger.LogError("Bad request parameter");
var error = new BadRequest("Parameter is null", new { data });
return(error.ReturnResponse());
}
var result = new OK("Success completed task data", new { id });
return(result.ReturnResponse());
}
public IActionResult AddProduct([FromBody] AddProductRequest addProductRequest)
{
_logger.Info("Handling api request: create event subscription :" + addProductRequest);
IActionResult result = null;
try
{
if (RequestValidator.Validate <AddProductRequest>(Request, addProductRequest, new AddProductRequestValidator(), ref result))
{
var command = AddProductRequestMapper.ToCommand(addProductRequest);
_addProductCommandHandler.Handle(command);
}
}
catch (CommandNotValidException ex)
{
_logger.Warn("CommandNotValidException caught handling a AddProductCommand", ex);
result = new BadRequest(ex.ErrorMessages.ToList(), Request);
}
catch (CommandTimeoutException ex)
{
_logger.Warn("CommandTimeoutException caught handling a AddProductCommand", ex);
//result = new GatewayTimeout(new List<string>() { "Upstream Timeout", ex.Message },new HttpRequestMessage());
}
return(result);
}
public async Task <IActionResult> LoadDatatablesAsync([FromBody] DatatablesParameter param)
{
if (param == null)
{
_loger.LogError("Bad request parameter");
var error = new BadRequest("Parameter is null", new { param });
return(error.ReturnResponse());
}
var data = await _service.DatatablesAsync(param);
var items = new List <ClientApi>();
foreach (var item in data.Items)
{
item.ClientSecret = item.ClientSecret.ToBase64EncodeWithKey(_config["Security:EncryptKey"]);
items.Add(item);
}
data.Items = items.AsEnumerable();
var result = new OK("Success load datatables", data);
return(result.ReturnResponse());
}
public IActionResult Post([FromBody] ApkKeuringsVerzoekCommand command)
{
if (!ModelState.IsValid)
{
var badRequest = new BadRequest()
{
Message = $"Request bevat: {ModelState.ErrorCount} fouten", InvalidProperties = ModelState.Keys
};
_logger.Log(new LogMessage(badRequest.Message));
return(BadRequest(badRequest));
}
try
{
var result = _apkManager.HandleApkKeuringsVerzoek(command);
return(new JsonResult(result));
}
catch (Exception ex)
{
var badRequest = new BadRequest {
Message = "RDW niet bereikbaar", InvalidProperties = new List <string>()
};
_logger.LogException(new LogMessage($"{badRequest.Message}", ex.StackTrace));
return(BadRequest(badRequest));
}
}
public void SystemExceptionAuthenticationRequestTest()
{
var badRequest = new BadRequest();
badRequest.Message = "error";
var mockAuthenticationService = MockRepository.GenerateStub <IAuthenticationService>();
mockAuthenticationService.Stub(x => x.Authenticate("admin", "success-password")).Throw(new Exception());
mockAuthenticationService.Stub(x => x.ErrorRequest()).Return(badRequest);
// insert mock in the IoC container
var bootstrapper = new Bootstrapper();
var browser = new Browser(bootstrapper);
bootstrapper.Container.EjectAllInstancesOf <IAuthenticationService>();
bootstrapper.Container.Inject <IAuthenticationService>(mockAuthenticationService);
var bodyDyn = new { username = "******", password = "******" };
// When
var result = TestHelper.JsonBodyPost(RouterPattern.Security.Authenticate, bodyDyn, bootstrapper, browser);
// Then
mockAuthenticationService.AssertWasCalled(x => x.Authenticate("admin", "success-password"));
mockAuthenticationService.AssertWasCalled(x => x.ErrorRequest());
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
var badRequestResult = JsonConvert.DeserializeObject <BadRequest>(result.Body.AsString());
Assert.AreEqual("error", badRequestResult.Message);
}
public bool Validate <T>(HttpRequest httpRequest, T request, FluentValidation.IValidator <T> validator, ref IActionResult invalidResult) where T : class
{
bool result = false;
if (request == null)
{
_logger.Warn(typeof(T).FullName + " was passed null, request must contain data. Throwing ValidationException");
invalidResult = new BadRequest(new List <string>()
{
"Request must contain data"
}, httpRequest);
}
else
{
var validationResult = validator.Validate(request);
if (!validationResult.IsValid)
{
invalidResult = new BadRequest(validationResult.Errors.Select(x => x.ErrorMessage).ToList(), httpRequest);
string errors = string.Join(";", validationResult.Errors);
_logger.Warn(typeof(T).FullName + " failed validation, request invalid.");
}
else
{
result = true;
}
}
return(result);
}
public ValidationProblemDetails ValidationProblemDetails()
{
var problem = new ValidationProblemDetails(ValidationErrors);
BadRequest.CopyStandardFieldsTo(problem);
return(problem);
}
protected override void RaiseErrorEvent(WebsocketClientBase client, IWebSocketConnection session)
{
//fix: WebSocket4Net do not raise error event when server closed the WebSocket connection without completing the close handshake.
var badRequest = new BadRequest();
badRequest.ExecuteCommand((WebSocket)client.LiteClient.InnerClient,
new WebSocketCommandInfo(0x9.ToString(), ""));
}
public void ShouldSetStatusCode()
{
result = new BadRequest
{
MediaType = mediaType.Object
};
Assert.That(result.GetDecorators().Contains(typeof(StatusCode)));
}
public void ShouldSetResponseText()
{
result = new BadRequest(new { })
{
MediaType = mediaType.Object
};
Assert.That(result.Model, Is.Not.Null);
}
public void OnActionExecuting(ActionExecutingContext filterContext)
{
if (!filterContext.ModelState.IsValid)
{
// 400 Bad Request
foreach (var value in filterContext.ModelState.Values)
{
foreach (var error in value.Errors)
{
if (error.Exception != null || error.ErrorMessage.Contains("line ") && error.ErrorMessage.Contains("position "))
{
var errorResponse = new BadRequest(nameof(Application.Messages.ErrorMessage.BadRequest), Application.Messages.ErrorMessage.BadRequest);
filterContext.Result = new ObjectResult(errorResponse)
{
StatusCode = 400
};
return;
}
}
}
// 422 Unprocessable Entity
var errors = filterContext.ModelState.Where(x => x.Value.Errors.Count > 0).ToDictionary(
kvp => kvp.Key,
kvp => kvp.Value.Errors.Select(e => e.ErrorMessage).ToArray()
);
var validationErrorsResponse = new List <ValidationError>();
foreach (var error in errors)
{
foreach (var value in error.Value)
{
// Handle DataAnotations Required
if (value.Contains("field is required"))
{
validationErrorsResponse.Add(new ValidationError(nameof(Application.Messages.ErrorMessage.Required), error.Key, Application.Messages.ErrorMessage.Required));
}
else // Handle fluent validations
{
var index = value.IndexOf(" ", StringComparison.Ordinal);
var code = value.Substring(0, index);
var message = value.Substring(index + 1);
validationErrorsResponse.Add(new ValidationError(code, error.Key, message));
}
}
}
var validationsResponse = new ValidationFailed(nameof(Application.Messages.ErrorMessage.ValidationFailed), Application.Messages.ErrorMessage.ValidationFailed, validationErrorsResponse);
filterContext.Result = new ObjectResult(validationsResponse)
{
StatusCode = 422
};
}
}
public void SetUp()
{
var mediaType = new Mock <IMediaType>();
mediaType.SetupGet(mt => mt.Synonyms).Returns(new[] { "media-type" });
result = new BadRequest
{
MediaType = mediaType.Object
};
}
public CustomProblemDetails CustomProblemDetails()
{
var problem = new CustomProblemDetails
{
StringField = "string field value",
IntField = 20
};
BadRequest.CopyStandardFieldsTo(problem);
return(problem);
}
public MvcProblemDetails ProblemDetailsWithExtensions()
{
var problem = new MvcProblemDetails
{
Extensions =
{
{ "stringField", "string field value" },
{ "intField", 20 }
}
};
BadRequest.CopyStandardFieldsTo(problem);
return(problem);
}
public async Task <IActionResult> GetAsync(DataParameter param)
{
if (param.Start <= 0 || param.Length <= 0)
{
_loger.LogError("Bad request parameter");
var error = new BadRequest("Start page > 0 and page size > 0", new { param.Start, param.Length });
return(error.ReturnResponse());
}
var data = await _service.GetAsync(param);
var result = new OK("Success get data by paging", data);
return(result.ReturnResponse());
}
public async Task <IActionResult> LoadDatatablesAsync([FromBody] DatatablesParameter param)
{
if (param == null)
{
_loger.LogError("Bad request parameter");
var error = new BadRequest("Parameter is null", new { param });
return(error.ReturnResponse());
}
var data = await _service.DatatablesAsync(param);
var result = new OK("Success load datatables", data);
return(result.ReturnResponse());
}
public async Task <IActionResult> IsExistDataAsync([FromBody] IDictionary <string, object> whereData)
{
if (whereData == null)
{
_loger.LogError("Bad request parameter");
var error = new BadRequest("Bad request parameter", new { whereData });
return(error.ReturnResponse());
}
var exist = await _service.IsExistDataAsync(whereData);
var result = new OK("Success check exist data", new { exist });
return(result.ReturnResponse());
}
public CustomProblemDetails CustomProblemDetailsWithExtensions()
{
var problem = new CustomProblemDetails
{
StringField = "string field value",
IntField = 20,
Extensions =
{
{ "s2", "value 2" },
{ "i2", 30 }
}
};
BadRequest.CopyStandardFieldsTo(problem);
return(problem);
}
async Task <T> CallAPIAsync <T>(Type callingType, string methodName, Action <HttpRequestMessage> contentSetter = null,
string urlParameterName = null, string urlParameterValue = null)
{
try
{
// Get the method.
var method = callingType.GetMethod(methodName);
// Get the custom attribute.
var attribute = method.GetCustomAttribute <ApiCallAttribute>();
// Get the Http method.
var httpMethod = attribute.GetHttpMethod(method);
// Get the url pattern.
var urlPattern = attribute.UrlPattern;
// And the API version.
var apiVersion = attribute.ApiVersion;
// Build the url.
var url = BuildUrl(urlPattern, urlParameterName, urlParameterValue);
ApiCallSuccess = false;
using (var request = new HttpRequestMessage(httpMethod, apiVersion + "/" + url))
{
request.Headers.Authorization = _authHeader;
contentSetter?.Invoke(request);
using (var response = await _httpClient.SendAsync(request).ConfigureAwait(false))
{
var responseContent = await ReadAsStringAsync(response).ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
ApiCallSuccess = true;
var result = JsonSerializer.Deserialize <T>(responseContent, _options);
return(result);
}
else
{
BadRequest = GetBadRequest(responseContent);
return(default);
public void ValidTrailer_ArbitraryMessages()
{
var debugInfo = new DebugInfo
{
Detail = "This is some debugging information"
};
var requestInfo = new RequestInfo
{
RequestId = "request-id"
};
var badRequest = new BadRequest
{
FieldViolations = { new BadRequest.Types.FieldViolation {
Description = "Negative", Field = "speed"
} }
};
var status = new Status
{
Code = 123,
Message = "This is a message",
Details =
{
Any.Pack(debugInfo),
Any.Pack(requestInfo),
Any.Pack(badRequest)
}
};
var metadata = new Metadata();
metadata.Add("key-1", "value1");
metadata.Add(RpcExceptionExtensions.StatusDetailsTrailerName, status.ToByteArray());
metadata.Add("other-info-bin", new byte[] { 1, 2, 3 });
metadata.Add("key-2", "value2");
RpcException ex = new RpcException(s_status, metadata);
Assert.Equal(badRequest, ex.GetBadRequest());
Assert.Null(ex.GetErrorInfo());
Assert.Equal(debugInfo, ex.GetStatusDetail <DebugInfo>());
Assert.Equal(requestInfo, ex.GetStatusDetail <RequestInfo>());
Assert.Equal(badRequest, ex.GetStatusDetail <BadRequest>());
}
protected void CheckBadRequest(string reason, string message, Exception ex)
{
BadRequest badRequest = null;
try
{
badRequest = JsonConvert.DeserializeObject <BadRequest>(((RestResponse)ex.Data["res"]).Content);
}
catch (Exception) { }
if (badRequest == null ||
!badRequest.Reason.Equals(reason))
{
throw ex;
}
else
{
Assert.Inconclusive(message);
}
}
private async Task <HttpRequest> WriteBadRequest(StringSegment rline, StreamWriter writer, string reason, HttpStatus status = HttpStatus.BadRequest)
{
// If we reach this, something is weird/wrong.
// "Bye, have a great day!"
await writer.WriteLineAsync(StatusStrings[(int)status]);
await writer.WriteLineAsync(ServerHeader);
await writer.WriteLineAsync("Connection: close");
await writer.WriteLineAsync();
await writer.WriteLineAsync(reason);
await writer.FlushAsync();
BadRequest?.Invoke(new BadRequestEvent(rline.ToString(), reason));
return(null); // only returning this so we can chain it to a return statement in the method below
}
public IHttpActionResult GetImagesByDate([FromUri] NasaPhotoRequest photoRequest)
{
// Check model validity
if (!ModelState.IsValid)
{
var badRequestResponse = new BadRequest("Request is malformed", photoRequest);
return(Content(HttpStatusCode.BadRequest, badRequestResponse));
}
var imageRepo = new NasaPhotoRepository("https://api.nasa.gov/mars-photos/api/v1/");
// Get response from the service
var response = imageRepo.Get(photoRequest);
// Handle non-success states
if (!response.IsSuccessful)
{
var responseObject = JsonConvert.DeserializeObject(response.Content);
return(Content(response.StatusCode, responseObject));
}
// Get an object from the response content
var nasaImageResponse = JsonConvert.DeserializeObject <NasaPhotoResponse>(response.Content);
// build the image path
var imageFileService = new ImageFileService(photoRequest.savePath);
// Get the image response
try
{
return(Ok(imageFileService.HandleNasaResponse(nasaImageResponse)));
}
catch (Exception e)
{
var exception = new Exception("Unable to save photos. View InnerException for more details.", e);
return(InternalServerError(exception));
}
}
public async Task <IActionResult> IsExistDataWithKeyAsync([FromBody] ExistWithKeyModel model)
{
if (string.IsNullOrEmpty(model.FieldName) ||
string.IsNullOrEmpty(model.FieldName))
{
_loger.LogError("Bad Request Parameter");
var error = new BadRequest("Bad Request Parameter", new { model });
return(error.ReturnResponse());
}
else if (typeof(ClientApi).HasProperty(model.KeyName.ToLower()) && typeof(ClientApi).HasProperty(model.FieldName.ToLower()))
{
_loger.LogError("Property name does not exist");
var error = new BadRequest("Property name does not exist", new { model });
return(error.ReturnResponse());
}
var exist = await _service.IsExistDataWithKeyAsync(model);
var result = new OK("Success check exist data with key " + model.FieldName + " : " + model.FieldValue, new { exist });
return(result.ReturnResponse());
}
public async Task <IActionResult> PutAsync([FromBody] ClientApi data)
{
if (data == null)
{
_loger.LogError("Bad request parameter");
var error = new BadRequest("Parameter is null", new { data });
return(error.ReturnResponse());
}
var id = await _service.PutAsync(data);
if (id == null)
{
_loger.LogError("Duplicate data for client id : " + data.ClientId);
var error = new Forbidden("Duplicate data for client id : " + data.ClientId, new { data });
return(error.ReturnResponse());
}
var result = new OK("Success update data", new { id });
return(result.ReturnResponse());
}
public async Task <IActionResult> PostAsync([FromBody] Tasks data)
{
if (data == null)
{
_loger.LogError("Bad request parameter");
var error = new BadRequest("Parameter is null", new { data });
return(error.ReturnResponse());
}
var id = await _service.PostAsync(data);
if (id == null)
{
_loger.LogError("Duplicate data for Name : " + data.Name);
var error = new Forbidden("Duplicate data for Name : " + data.Name, new { data });
return(error.ReturnResponse());
}
var result = new OK("Success add data", new { id });
return(result.ReturnResponse());
}
public BadRequestException(BadRequest badRequest) : base(badRequest.RequestMessage, badRequest.ResponseMessage)
{
}
public BadRequestException(BadRequest badRequest, string message, Exception inner) : base(badRequest.RequestMessage, badRequest.ResponseMessage, message, inner)
{
}
public Error(BadRequest badrequest)
{
Message = badrequest.Message;
Code = 400;
}
private void Initialize(string uri, string subProtocol, List <KeyValuePair <string, string> > cookies, List <KeyValuePair <string, string> > customHeaderItems, string userAgent, string origin, WebSocketVersion version, EndPoint httpConnectProxy, int receiveBufferSize)
{
if (version == WebSocketVersion.None)
{
NotSpecifiedVersion = true;
version = WebSocketVersion.Rfc6455;
}
Version = version;
ProtocolProcessor = GetProtocolProcessor(version);
Cookies = cookies;
Origin = origin;
if (!string.IsNullOrEmpty(userAgent))
{
if (customHeaderItems == null)
{
customHeaderItems = new List <KeyValuePair <string, string> >();
}
customHeaderItems.Add(new KeyValuePair <string, string>("User-Agent", userAgent));
}
if (customHeaderItems != null && customHeaderItems.Count > 0)
{
CustomHeaderItems = customHeaderItems;
}
Handshake handshake = new Handshake();
m_CommandDict.Add(handshake.Name, handshake);
Text text = new Text();
m_CommandDict.Add(text.Name, text);
Binary binary = new Binary();
m_CommandDict.Add(binary.Name, binary);
Close close = new Close();
m_CommandDict.Add(close.Name, close);
Ping ping = new Ping();
m_CommandDict.Add(ping.Name, ping);
Pong pong = new Pong();
m_CommandDict.Add(pong.Name, pong);
BadRequest badRequest = new BadRequest();
m_CommandDict.Add(badRequest.Name, badRequest);
m_StateCode = -1;
SubProtocol = subProtocol;
Items = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
m_HttpConnectProxy = httpConnectProxy;
TcpClientSession tcpClientSession;
if (uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase))
{
tcpClientSession = CreateClient(uri);
}
else
{
if (!uri.StartsWith("wss://", StringComparison.OrdinalIgnoreCase))
{
throw new ArgumentException("Invalid uri", "uri");
}
tcpClientSession = CreateSecureClient(uri);
}
tcpClientSession.ReceiveBufferSize = ((receiveBufferSize > 0) ? receiveBufferSize : 4096);
tcpClientSession.Connected += client_Connected;
tcpClientSession.Closed += client_Closed;
tcpClientSession.Error += client_Error;
tcpClientSession.DataReceived += client_DataReceived;
Client = tcpClientSession;
EnableAutoSendPing = true;
}
