public ObjectResult ApiBattleShipPost(int boardId,
BattleShipToBeCreatedRequest battleShipToBeCreatedRequest)
{
logger.LogDebug("Start - Request for new battle ship");
ObjectResult result = null;
var battleShip = BattleShipFactory(boardId, battleShipToBeCreatedRequest);
// prep board to ask question
var board = boardRepo.Get(boardId);
// ask board whether given battle ship can be added
var battleShipAssociation = board.CanAddBattleShip(battleShip);
// if can be associated save the battle ship to database
if (battleShipAssociation.Status == true)
{
var battleShipFromRepo = battleShipService
.SaveBattleShip(boardId, battleShip.BattleShipBlocks);
var successResponse = ResponseFactory.Create(battleShipFromRepo);
result = CreatedAtAction(nameof(ApiBattleShipGet),
new { boardId, id = successResponse.Id }, successResponse);
}
else
{
// 404 Error
result = new BadRequestObjectResult(battleShipAssociation);
}
logger.LogDebug("End - Request for new battle ship");
return(result);
}
static void Main(string[] args)
{
var responseList = new List <string>
{
"TABLE|10|Item Id 10",
"ARTICLE|ABCCDEE|true|2,5",
"TABLE|15|Item Id 15",
"TABLE|20|Item Id 20",
"CALENDAR|01/05/2016 14:00|Meeting",
"ARTICLE|9388d99|false|0,20",
"CALENDAR|06/02/2017 17:00|Buy more Redbull"
};
Console.WriteLine("Processing list: ");
Console.WriteLine();
var responses = responseList.Select(responseString => ResponseFactory.Create(responseString));
// If you want to process the responses
ProcessTableResponses(responses.OfType <TableResponse>());
ProcessArticleResponses(responses.OfType <ArticleResponse>());
ProcessCalendarResponses(responses.OfType <CalendarResponse>());
// If you just want the DTOs
var tableDtos = responses.OfType <TableResponse>().Select(r => r.GetValue());
var articleDtos = responses.OfType <ArticleResponse>().Select(r => r.GetValue());
var calendarDtos = responses.OfType <CalendarResponse>().Select(r => r.GetValue());
Console.WriteLine();
Console.Write("Press any key to exit...");
Console.ReadKey();
}
public ObjectResult ApiBoardPost()
{
logger.LogDebug("Start - Request for new board");
var board = new Board();
var boardFromRepo = boardRepo.Create(board);
var blocks = Enumerable.Range(
boardFromRepo.FirstBlockNumber,
boardFromRepo.LastBlockNumber)
.Select(n => new Block
{
BoardId = boardFromRepo.Id,
Number = n
})
.ToList();
var blocksFromRepo = blockRepo.CreateBlocksForBoard(blocks);
boardFromRepo = boardRepo.Get(boardFromRepo.Id);
var response = ResponseFactory.Create(boardFromRepo);
logger.LogDebug("End - Request for new board");
return(CreatedAtAction(nameof(ApiBoardGet),
new { id = boardFromRepo.Id }, response));
}
// 1400.02.14
// send encrypted message and get encrypted message
public async static Task <Response <TResponse> > EncryptedHttpPostAsync <TResponse>(string url, object parameter, WebProxy proxy, string encPubKey, string decPriKey) where TResponse : class
{
try
{
var message = EncryptedMessage.Create(parameter, encPubKey);
//var response = await NetHelper.HttpPostAsync<EncryptedMessage>(url, message, null, proxy);
var response = await NetHelper.HttpPostAsync <EncryptedMessage>(new HttpParameters()
{
Address = url, Data = message, Proxy = proxy
});
if (response.HasNotNullResult())
{
return(ResponseFactory.Create <TResponse>(response.Result.Decrypt <TResponse>(decPriKey)));
}
else
{
return(ResponseFactory.CreateError <TResponse>(response.ErrorMessage));
}
}
catch (Exception ex)
{
return(ResponseFactory.CreateError <TResponse>(ex.Message));
}
}
public static Response <string> HttpGetString(string address, string contentType = contentTypeJson, WebProxy proxy = null)
{
try
{
//WebClient client = new WebClient();
//client.Headers.Add(HttpRequestHeader.ContentType, contentType);
//client.Headers.Add(HttpRequestHeader.UserAgent, "application!");
//client.Encoding = Encoding.UTF8;
//if (proxy?.Address != null)
//{
// client.Proxy = proxy;
//}
var client = CreateWebClient(contentType, Encoding.UTF8, proxy, bearer: null);
var stringResult = client.DownloadString(address);
return(ResponseFactory.Create(stringResult));
}
catch (Exception ex)
{
return(ResponseFactory.CreateError <string>(ex.Message));
}
}
public static Response <T> HttpGet <T>(string address, Encoding encoding = null, WebProxy proxy = null, string bearer = null, string contentType = contentTypeJson) where T : class
{
try
{
//WebClient client = new WebClient();
//client.Headers.Add(HttpRequestHeader.ContentType, contentType);
//client.Headers.Add(HttpRequestHeader.UserAgent, "application!");
//client.Encoding = encoding;
//if (proxy?.Address != null)
//{
// client.Proxy = proxy;
//}
var client = CreateWebClient(contentType, encoding, proxy, bearer);
var stringResult = client.DownloadString(address);
return(ResponseFactory.Create(Newtonsoft.Json.JsonConvert.DeserializeObject <T>(stringResult)));
}
catch (Exception ex)
{
return(ResponseFactory.CreateError <T>(ex.Message));
}
}
public void AddServiceVersion_DoesNotAddServiceVersion_IfResponseStatusCodeIsOtherThanNoContent()
{
// Arrange
var response = ResponseFactory.Create(StatusCodes.Status200OK);
// Act
ResultHelpers.AddServiceVersion(response, () => _version);
// Assert
Assert.False(response.Headers.ContainsKey(ODataVersionConstraint.ODataServiceVersionHeader));
}
public void AddEntityId_DoesNotAddEntityId_IfResponseStatusCodeIsOtherThanNoContent()
{
// Arrange
var response = ResponseFactory.Create(StatusCodes.Status200OK);
// Act
ResultHelpers.AddEntityId(response, () => _entityId);
// Assert
Assert.False(response.Headers.ContainsKey(ResultHelpers.EntityIdHeaderName));
}
public IActionResult ApiBoardGet(int id)
{
logger.LogDebug($"Start - Request for board {id}");
var board = boardRepo.Get(id);
var response = ResponseFactory.Create(board);
logger.LogDebug($"End - Request for board {id}");
return(Ok(response));
}
public void Promises_are_kept()
{
var stream = new Subject <Response>();
var factory = new ResponseFactory(stream, NullLogger <ResponseFactory> .Instance);
var future1 = factory.Create <int>();
var future2 = factory.Create <int>();
var future3 = factory.Create <int>();
stream.OnNext(new Response <int>(future1.Id, new[] { 123 }));
stream.OnNext(new Response <int>(future2.Id, new[] { 234, 345 }));
future1.Task.IsCompleted.Should().BeTrue();
future1.Task.Result.Result.Should().BeEquivalentTo(new[] { 123 });
future2.Task.IsCompleted.Should().BeTrue();
future2.Task.Result.Result.Should().BeEquivalentTo(new[] { 234, 345 });
future3.Task.IsCompleted.Should().BeFalse();
}
public IActionResult ApiAttackGet(int boardId, int id)
{
logger.LogDebug($"Start - Request for attack {id}");
var attack = attackRepo.Get(boardId, id);
var response = ResponseFactory.Create(attack);
logger.LogDebug($"End - Request for attack {id}");
return(Ok(response));
}
protected virtual DataResponse <T> CreateResponse()
{
if (ResponseFactory != null)
{
return(ResponseFactory.Create <T>());
}
else
{
return(new DataResponse <T>());
}
}
public IActionResult ApiBattleShipGet(int boardId, int id)
{
logger.LogDebug($"Start - Request for battle ship {id}");
var battleShip = battleShipRepo.Get(boardId, id);
var response = ResponseFactory.Create(battleShip);
logger.LogDebug($"End - Request for battle ship {id}");
return(Ok(response));
}
public async Task <IActionResult> GetShorted([FromBody] UrlContract contract)
{
if (!_validator.Validate(contract.Url))
{
return(Ok(ResponseFactory.Create(false, "Wrong url format")));
}
var hashedValue = _hashProvider.GetHashed(contract.Url);
await _linkRepository.AddEntry(hashedValue, contract.Url);
return(Ok(ResponseFactory.Create(true, $"{Request.Scheme}://{Request.Host}/{hashedValue}")));
}
public static Response <T> HttpPost <T>(HttpParameters parameters) where T : class
{
try
{
var result = HttpPostString(parameters);
return(ResponseFactory.Create <T>(Newtonsoft.Json.JsonConvert.DeserializeObject <T>(result.Result)));
}
catch (Exception ex)
{
return(ResponseFactory.CreateError <T>(ex.GetFullMessage()));
}
}
public void Shoud_Create_FailedResponse_WithOut_Data(string message)
{
// Arrange
// Act
var factory = new ResponseFactory();
var response = factory.Create(message);
// Assert
response.Success.Should().Be(false);
response.Message.Should().Be(message);
response.As <SuccessfulResponse <object> >().Should().Be(default);
public void AddEntityId_AddsEntityId_IfResponseStatusCodeIsNoContent()
{
// Arrange
var response = ResponseFactory.Create(StatusCodes.Status204NoContent);
// Act
ResultHelpers.AddEntityId(response, () => _entityId);
// Assert
var entityIdHeaderValues = response.Headers[ResultHelpers.EntityIdHeaderName].ToList();
Assert.Single(entityIdHeaderValues);
Assert.Equal(_entityId.ToString(), entityIdHeaderValues.Single());
}
public void AddServiceVersion_AddsODataVersion_IfResponseStatusCodeIsNoContent()
{
// Arrange
var response = ResponseFactory.Create(StatusCodes.Status204NoContent);
// Act
ResultHelpers.AddServiceVersion(response, () => _version);
// Assert
var versionHeaderValues = response.Headers[ODataVersionConstraint.ODataServiceVersionHeader].ToList();
Assert.Single(versionHeaderValues);
Assert.Equal(_version, versionHeaderValues.Single());
}
public static async Task <Response <string> > HttpPostXmlAsync(string address, string xmlData, Encoding encoding, WebProxy proxy = null)
{
try
{
var client = CreateWebClient(contentTypeXml, encoding, proxy);
var stringResult = await client.UploadStringTaskAsync(address, xmlData);
return(ResponseFactory.Create <string>(stringResult));
}
catch (Exception ex)
{
return(ResponseFactory.CreateError <string>(ex.Message));
}
}
public void AddEntityId_DoesNotAddEntityId_IfResponseStatusCodeIsOtherThanNoContent()
{
// Arrange
var response = ResponseFactory.Create(HttpStatusCode.OK);
// Act
ResultHelpers.AddEntityId(response, () => _entityId);
// Assert
#if NETCORE
Assert.False(response.Headers.ContainsKey(ResultHelpers.EntityIdHeaderName));
#else
Assert.False(response.Headers.Contains(ResultHelpers.EntityIdHeaderName));
#endif
}
public static Response <bool> HttpDelete(string address, string contentType = contentTypeJson, WebProxy proxy = null, string bearerToken = null)
{
try
{
var client = CreateWebClient(contentType, Encoding.UTF8, proxy, bearer: bearerToken);
var stringResult = client.UploadData(address, "DELETE", new byte[0]);
return(ResponseFactory.Create(true));
}
catch (Exception ex)
{
return(ResponseFactory.CreateError <bool>(ex.Message));
}
}
public void Ids_are_allocated_quickly()
{
var stream = new Subject <Response>();
var factory = new ResponseFactory(stream, NullLogger <ResponseFactory> .Instance);
var sw = Stopwatch.StartNew();
for (var i = 0; i < 10000; i++)
{
factory.Create <Response <int> >();
}
var ms = sw.Elapsed.TotalMilliseconds;
(ms / 10000).Should().BeLessThan(0.1);
}
public async Task SendAsync_ReturnsOriginalResponseIfNoObjectContent()
{
// Arrange
var originalResponse = ResponseFactory.Create(HttpStatusCode.OK, "test");
ODataNullValueMessageHandler handler = CreateHandler(originalResponse);
var request = RequestFactory.Create(HttpMethod.Get, "http://localhost/any");
request.ODataContext().Path = new ODataPath(new EntitySetSegment(_entitySet));
// Act
var response = await SendToHandler(handler, request);
// Assert
Assert.Same(originalResponse, response);
}
public void Receiving_errors_should_trigger_task_failure()
{
var stream = new Subject <Response>();
var factory = new ResponseFactory(stream, NullLogger <ResponseFactory> .Instance);
var future = factory.Create <int>();
stream.OnNext(new ErrorResponse(future.Id, new(234, "Foobar") ));
future.Task.IsFaulted.Should().BeTrue();
var exception = future.Task.Exception?.InnerException;
exception.Should().NotBeNull()
.And.BeOfType <YeelightException>()
.Which.Message.Should().Be("Foobar");
}
public void Ids_are_created_without_apparent_collisions()
{
var stream = new Subject <Response>();
var factory = new ResponseFactory(stream, NullLogger <ResponseFactory> .Instance);
var ids = new HashSet <int>();
bool result = true;
for (var i = 0;
i < 100000 && result;
i++, result = ids.Add(factory.Create <Response <int> >().Id))
{
;
}
result.Should().BeTrue("collision if already in set");
}
public void AddEntityId_AddsEntityId_IfResponseStatusCodeIsNoContent()
{
// Arrange
var response = ResponseFactory.Create(HttpStatusCode.NoContent);
// Act
ResultHelpers.AddEntityId(response, () => _entityId);
// Assert
#if NETCORE
var entityIdHeaderValues = response.Headers[ResultHelpers.EntityIdHeaderName].ToList();
#else
var entityIdHeaderValues = response.Headers.GetValues(ResultHelpers.EntityIdHeaderName).ToList();
#endif
Assert.Single(entityIdHeaderValues);
Assert.Equal(_entityId.ToString(), entityIdHeaderValues.Single());
}
public void AddServiceVersion_AddsODataVersion_IfResponseStatusCodeIsNoContent()
{
// Arrange
var response = ResponseFactory.Create(HttpStatusCode.NoContent);
// Act
ResultHelpers.AddServiceVersion(response, () => _version);
// Assert
#if NETCORE
var versionHeaderValues = response.Headers[ODataVersionConstraint.ODataServiceVersionHeader].ToList();
#else
var versionHeaderValues = response.Headers.GetValues(ODataVersionConstraint.ODataServiceVersionHeader).ToList();
#endif
Assert.Single(versionHeaderValues);
Assert.Equal(_version, versionHeaderValues.Single());
}
public void GivenDynamicTemplate_WhenCreatingResponseFromObject_ThenCreatesExpectedResponse()
{
var mockRequest = CreateMockRequestObject();
var mockTemplate = new Mock <ITemplate>();
mockTemplate.Setup(x => x.Response)
.Returns("{ \"Message\": \"Captured : {{a}}, {{b}}, {{c}}\" }");
var expectedResponse = "{ \"Message\": \"Captured : 1, 2, 3\" }";
var factory = new ResponseFactory();
var response = factory.Create(mockRequest.Object, mockTemplate.Object);
Assert.That(expectedResponse, Is.EqualTo(response.Content));
}
public void GivenDynamicTemplate_WhenCreatingResponseFromObjectUsingIndexes_ThenCreatesResponse()
{
var mockRequest = CreateMockRequestArray();
var expected = "{ \"Message\": \"Captured : b, c, a\" }";
var mockTemplate = new Mock <ITemplate>();
mockTemplate.Setup(x => x.Response)
.Returns("{ \"Message\": \"Captured : {{1}}, {{2}}, {{0}}\" }");
var factory = new ResponseFactory();
var response = factory.Create(mockRequest.Object, mockTemplate.Object);
Assert.That(response.Content, Is.EqualTo(expected));
}
public void GivenDynamicTemplate_WhenCreatingResponseFromNestedObject_ThenCreatesResponse()
{
var mockRequest = CreateNestedMockRequestObject();
var mockTemplate = new Mock <ITemplate>();
mockTemplate.Setup(x => x.Response)
.Returns("{ \"Message\": \"Captured : {{String}}, {{Number}}, {{Bool}}, {{Array[1]}}, {{Nested.String}}, {{Nested.Number}}, {{Nested.Bool}}, {{Nested.Array[1]}}\" }");
var factory = new ResponseFactory();
var response = factory.Create(mockRequest.Object, mockTemplate.Object);
var expected = "{ \"Message\": \"Captured : String-0, Number-0, Bool-0, Array-0, Nested-String-0, Nested-Number-0, Nested-Bool-0, Nested-Array-0\" }";
Assert.That(response.Content, Is.EqualTo(expected));
}
