private static TestServer SetupTestServerForNode(NodeAddress serverNode)
{
SampleResponse serverResponse = new SampleResponse(serverNode.Id.ToString());
var testServer = new TestServer(serverNode, serverResponse);
return(testServer);
}
private void SendResponse()
{
foreach (Tuple <IPEndPoint, byte[]> requestPair in _sampleRequestCollection.GetConsumingEnumerable())
{
try
{
IPEndPoint endPoint = requestPair.Item1;
byte[] receiveBytes = requestPair.Item2;
SampleRequest request;
using (var memoryStream = new MemoryStream(receiveBytes))
{
memoryStream.Position = 0;
request = (SampleRequest)_formatter.Deserialize(memoryStream);
}
Logger.Debug(string.Format("deserilized {0} request", request._sampleType));
object sampleResult = ComputerStatistics.GetSample(request);
byte[] sendBytes = new SampleResponse(sampleResult).ToByteArray();
Logger.Debug(string.Format("Sending response to monitor - {0}, value {1}", endPoint, sampleResult));
_udpClient.Send(sendBytes, sendBytes.Length, endPoint);
}
catch (Exception e)
{
Logger.Error(e.Message);
}
}
}
public async Task <IActionResult> FunctionHandlerAsync([FromBody] SampleRequest request)
{
SampleResponse response = await _mediator.Send(request);
return(response.IsSuccessStatusCode
? Ok(response.Payload)
: (IActionResult)StatusCode(response.StatusCode));
}
public IActionResult GetMessage001()
{
var response = new SampleResponse();
response.AddNotification(_messageManager.GetMessage("AccountDoesntExists").GetNotification());
return(Ok(response));
}
public IActionResult GetMessage002()
{
var response = new SampleResponse();
response.AddNotification(_messageManager.GetMessage("AccountAmountNotTheSame").FormatValue("BRL", "EUR").GetNotification(true));
return(Ok(response));
}
public void Throws_when_invalid_number_of_locations(string filename)
{
var xml = SampleResponse.GetXDocument(filename);
var request = new Mock <GetLastPositionRequest>(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
request.CallBase = true;
request.Setup(x => x.MakeRequest()).Returns(xml);
Assert.Throws <UnexpectedResponseException>(() => request.Object.Request());
}
public override Task <SampleResponse> Ping(SampleRequest request, ServerCallContext context)
{
var response = new SampleResponse
{
Conteudo = $"{request.Conteudo}:{string.Join("", request.Conteudo.ToArray().Reverse())}",
Id = 7
};
return(Task.FromResult(response));
}
public IActionResult GetAllMessages()
{
var response = new SampleResponse();
response.AddNotification(_messageManager.GetMessage("AccountDoesntExists").GetNotification());
response.AddNotification(_messageManager.GetMessage("AccountAmountNotTheSame").FormatValue("BRL", "EUR").GetNotification(true));
response.AddNotification(_messageManager.GetMessage("AccountCurrencyDifferentCompensationCurrency").FormatValue("BRL", "USD").GetNotification());
return(Ok(response));
}
public async Task <IActionResult> Post([FromBody] SampleRequest request)
{
//Sample Business Error
if (request.ClientNo == 0)
{
return(BadRequest(new ApiErrorResponse()
{
ErrorIdentifier = AiOperationId,
ErrorDetails = new Error()
{
ErrorCode = "1001", ErrorKey = "Id", ErrorMessage = "Invalid Id Passed"
}.ToErrorList(),
ErrorType = ErrorTypeCode.BusinessError
}));
}
// Sample Validation and return errors
var requestValidation = await _validator.ValidateAsync(request, ruleSet : "ValidateForPost");
if (!requestValidation.IsValid)
{
return(BadRequest(new ApiErrorResponse()
{
ErrorIdentifier = AiOperationId,
ErrorDetails = requestValidation.Errors.Select(x => new Error()
{
ErrorMessage = x.ErrorMessage,
ErrorKey = x.PropertyName,
ErrorCode = x.ErrorCode
}).ToList(),
ErrorType = ErrorTypeCode.ValidationError
}));
}
//Sample Error Handling with Sub methods
(string result, Error error) = SampleSubMethod(request.ClientNo);
if (error != null)
{
return(BadRequest(new ApiErrorResponse()
{
ErrorIdentifier = AiOperationId,
ErrorDetails = error.ToErrorList(),
ErrorType = ErrorTypeCode.BusinessError
}));
}
var response = new SampleResponse()
{
CarrierCode = "Test Code",
CarrierName = "Test Name",
Prefix = "Test Prefix"
};
return(Ok(response));
}
public void PopulateResponses()
{
foreach (var resp in responses)
{
GameObject newResponse = Instantiate(sampleResponse) as GameObject;
SampleResponse sampleRespons0 = newResponse.GetComponent <SampleResponse>();
sampleRespons0.userName.text = resp.userName;
sampleRespons0.userTotalVotes.text = resp.userTotalVotes.ToString();
sampleRespons0.favIcon.sprite = resp.favIcon;
sampleRespons0.plusIcon.sprite = resp.plusIcon;
sampleRespons0.totalVotesForThisResponse.text = resp.numVotes.ToString();
sampleRespons0.transform.SetParent(contentPanel);
}
}
/// <summary>
/// Simulated network fetch
/// Error every third call
/// </summary>
public void GetFakeNetworking()
{
//Check if request is not already pending
if (FakeNetworkingLiveData.Value?.Status != RxStatus.Pending)
{
//Notify UI that request is pending
FakeNetworkingLiveData.PostValue(RxWrapper <SampleResponse> .Pending());
//Fake request latency 0.5-2s
Task.Delay(_randomGen.Next(500, 2000)).ContinueWith(task =>
{
switch (_fakeNetworkSequence)
{
case 0:
var model1 = new SampleResponse
{
Id = 1,
Name = "Ok response 1"
};
//Post fake fetch data to UI
FakeNetworkingLiveData.PostValue(RxWrapper <SampleResponse> .Ok(model1));
break;
case 1:
var model2 = new SampleResponse
{
Id = 2,
Name = "Ok response 2"
};
//Post fake fetch data to UI
FakeNetworkingLiveData.PostValue(RxWrapper <SampleResponse> .Ok(model2));
break;
case 2:
//Fake error has occured during network call
FakeNetworkingLiveData.PostValue(RxWrapper <SampleResponse> .Error(new Exception("No network")));
break;
}
++_fakeNetworkSequence;
if (_fakeNetworkSequence > 2)
{
_fakeNetworkSequence = 0;
}
});
}
}
public async Task <IActionResult> Put(int id, [FromBody] SampleRequest request)
{
if (id == 0)
{
throw new Exception("Client 0 not allowed");
}
var response = new SampleResponse()
{
CarrierCode = "Test Code",
CarrierName = "Test Name",
Prefix = "Test Prefix"
};
return(Ok(response));
}
internal static MainResponseModel GetSimpleResp(SqlMapper.GridReader objDetails)
{
var obj = new SampleResponse();
try
{
obj.Sample = objDetails.Read <Sample>().ToList();
}
catch (Exception)
{
obj.Sample = new List <Sample>();
}
return(obj);
}
public async Task <SampleResponse> GetAllSamples()
{
var response = new SampleResponse()
{
MetadataHeader = "something"
};
var query = cosmosClient.GetContainer("mydb", "mycontainer").GetItemQueryIterator <Sample>("SELECT * FROM c");
List <Sample> results = new List <Sample>();
while (query.HasMoreResults)
{
results.AddRange((await query.ReadNextAsync()).ToList());
}
response.Samples = results;
return(response);
}
public void Consume(SampleRequest message)
{
Console.WriteLine("Mensagem com ID {0} recebida.", message.CorrelationId);
Console.WriteLine("Enviando resposta...");
var sampleResponse = new SampleResponse
{
CorrelationId = message.CorrelationId,
Subscriber = "Second Subscriber",
Message =
string.Format(
"Resposta da mensagem {0}",
message.CorrelationId)
};
_serviceBus.Publish(sampleResponse);
Console.WriteLine("Resposta enviada!");
}
public override async Task <IMessage <SampleResponse> > GetValue(IMessage <SampleRequest> request, ServerCallContext context)
{
var key = request.Payload.Deserialize().Key;
var task = Task.Run(() =>
{
Task.Delay(1000);
return(10);
});
var value = await task;
var response = new SampleResponse()
{
Key = key,
Value = value
};
return(Message.From(response));
}
protected override void RunClient(int repeatedCount, ref bool bStop, int responseSize, out int successful)
{
successful = 0;
using (SampleService client = new SampleService(Connect(Iid)))
{
for (int count = 0; !bStop && count < repeatedCount; count++)
{
SampleResponse response = client.Test(
SampleRequest.CreateBuilder()
.AddRangeData(CreateSampleData(responseSize))
.Build()
);
GC.KeepAlive(response);
successful++;
}
}
}
public static void Main(string[] args)
{
ExceptionHandler.Execute(() =>
{
var dataForStep1 = new SampleResponse {
Name = "Data for step one"
};
new StepFlow()
.AddStep(new StepOne()).WithData(dataForStep1)
.AddStep(new StepTwo())
.AddStep(new StepThree())
.AddStep(new StepFour())
.Run <AnotherSampleResponse>(response =>
{
Console.WriteLine($"Executed OK: {response.LastName}");
}, OnError);
});
}
public override async Task GetValues(IAsyncStreamReader <SampleRequest> requestStream, IServerStreamWriter <SampleResponse> responseStream, ServerCallContext context)
{
var rand = new Random();
await foreach (var req in requestStream.ReadAllAsync())
{
var mask = (1 << req.Bits) - 1;
var len = req.Length;
var res = new SampleResponse();
for (int i = 0; i < len; i++)
{
res.Values.Add(rand.Next() & mask);
}
await responseStream.WriteAsync(res);
}
}
public void ShouldBeAbleToUnicastAMessageAndReceiveAResponse()
{
var sampleClusterConfiguration = BuildSampleClusterConfiguration();
// Start a test server to listen for requests
SampleResponse serverResponse = new SampleResponse("test response");
var testServer = new TestServer(sampleClusterConfiguration.Nodes[0], serverResponse);
testServer.Start();
var sut = new NetMqRpcChannel(sampleClusterConfiguration, TimeSpan.FromMilliseconds(200));
var sampleRequest = new SampleRequest("test");
var responseReturned = sut.Unicast <SampleRequest, SampleResponse>(sampleClusterConfiguration.Nodes[0].Id, sampleRequest);
Assert.IsNotNull(responseReturned);
Assert.AreEqual(serverResponse, responseReturned);
Assert.AreEqual(sampleRequest, testServer.GetLastReceivedMessageObject <SampleRequest>());
}
public async Task <SampleResponse> SendAsync(SampleRequest request, CancellationToken ct)
{
_logger.LogInformation("Received request with value {requestValue}", request.Value);
_logger.LogInformation("Simulating slow operation with a delay for request value {requestValue}", request.Value);
await Task.Delay(1000, ct);
var response = new SampleResponse
{
Value = request.Value + RandomSource.Next()
};
_logger.LogInformation(
"Random response to request with value {requestValue} will be {responseValue}",
request.Value,
response.Value
);
return(response);
}
public static SampleResponse Unmarshall(UnmarshallerContext context)
{
SampleResponse sampleResponse = new SampleResponse();
sampleResponse.HttpResponse = context.HttpResponse;
sampleResponse.RequestId = context.StringValue("Sample.RequestId");
sampleResponse.SecurityIps = context.StringValue("Sample.SecurityIps");
List <SampleResponse.Sample_SecurityIpGroup> sampleResponse_securityIpGroups = new List <SampleResponse.Sample_SecurityIpGroup>();
for (int i = 0; i < context.Length("Sample.SecurityIpGroups.Length"); i++)
{
SampleResponse.Sample_SecurityIpGroup securityIpGroup = new SampleResponse.Sample_SecurityIpGroup();
securityIpGroup.SecurityIpGroupName = context.StringValue("Sample.SecurityIpGroups[" + i + "].SecurityIpGroupName");
securityIpGroup.SecurityIpGroupAttribute = context.StringValue("Sample.SecurityIpGroups[" + i + "].SecurityIpGroupAttribute");
securityIpGroup.SecurityIpList = context.StringValue("Sample.SecurityIpGroups[" + i + "].SecurityIpList");
sampleResponse_securityIpGroups.Add(securityIpGroup);
}
sampleResponse.SecurityIpGroups = sampleResponse_securityIpGroups;
return(sampleResponse);
}
public override void ChannelRead(IChannelHandlerContext ctx, object message)
{
if (message is IFullHttpRequest httpRequest)
{
var succeeded = false;
if (httpRequest.Method == HttpMethod.Post && restfulRoute.Equals(httpRequest.Uri, StringComparison.OrdinalIgnoreCase))
{
try
{
if (httpRequest.Content.HasArray)
{
String jsonStr = Encoding.UTF8.GetString(httpRequest.Content.Array, httpRequest.Content.ArrayOffset, httpRequest.Content.ReadableBytes);
SampleRequest request = JsonConvert.DeserializeObject <SampleRequest>(jsonStr);
SampleResponse sampleResponse = new SampleResponse()
{
Response = request.Request
};
var bytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(sampleResponse));
WriteResponse(ctx, Unpooled.WrappedBuffer(bytes), AsciiString.Cached("application/json"), new AsciiString(bytes.Length.ToString()));
}
}
catch (Exception)
{
ReturnInternalServerError(ctx);
}
}
if (!succeeded)
{
ReturnBadRequest(ctx);
}
}
else
{
ctx.FireChannelRead(message);
}
}
protected bool Equals(SampleResponse other)
{
return(string.Equals(ResponseString, other.ResponseString));
}
public SampleResponse Test(SampleRequest sampleRequest)
{
return(SampleResponse.CreateBuilder()
.AddRangeData(CreateSampleData(_responseSize))
.Build());
}
protected bool Equals(SampleResponse other)
{
return string.Equals(ResponseString, other.ResponseString);
}
private TableCell GetTable(bool IgnoreGeneration, RatePeriod[] ratePeriods, IEnumerable <SampleResponse> samples, String title, ref Decimal totalCost, Decimal generationRate, Decimal fuelSurcharge)
{
SampleResponse prevSample = samples.First();
Dictionary <Decimal, RatePeriodTotal> totalsByRatePeriod = ratePeriods.Select(x => x.rate + fuelSurcharge).Distinct().ToDictionary(x => x, x => new RatePeriodTotal());
foreach (var sample in samples)
{
var ratePeriod = ratePeriods.FirstOrDefault(x => x.days != null && x.days.Contains(prevSample.intervalTS.DayOfWeek) && x.months.Contains(prevSample.intervalTS.Month) && x.startHour <= prevSample.intervalTS.Hour && x.endHour >= prevSample.intervalTS.Hour);
if (ratePeriod == null)
{
ratePeriod = ratePeriods.First();
}
totalsByRatePeriod[ratePeriod.rate + fuelSurcharge].addValues(sample.consumption - prevSample.consumption, sample.generation - prevSample.generation);
prevSample = sample;
}
TableRow tr;
var table = new Table();
tr = new TableHeaderRow {
HorizontalAlign = HorizontalAlign.Center
};
tr.Cells.Add(new TableHeaderCell {
Text = title
});
table.Rows.Add(tr);
var tbl = new Table {
GridLines = GridLines.Both, CellPadding = 4
};
tr = new TableRow {
HorizontalAlign = HorizontalAlign.Center,
};
tr.Cells.Add(new TableHeaderCell {
Text = "Rate<br />(Cost/Net Usage)"
});
tr.Cells.Add(new TableHeaderCell {
Text = "Consumption"
});
if (!IgnoreGeneration)
{
tr.Cells.Add(new TableHeaderCell {
Text = "Generation"
});
tr.Cells.Add(new TableHeaderCell {
Text = "Net Usage"
});
tr.Cells.Add(new TableHeaderCell {
Text = "Effective Rate<br />(Cost/Consumption)"
});
}
tr.Cells.Add(new TableHeaderCell {
Text = "Cost"
});
tbl.Rows.Add(tr);
decimal totalConsumption = 0;
decimal totalGeneration = 0;
totalCost = 0;
foreach (var result in totalsByRatePeriod.Where(x => (x.Value.Consumption + x.Value.Generation) > 0))
{
var Generation = (IgnoreGeneration ? 0 : result.Value.Generation);
totalConsumption += result.Value.Consumption;
totalGeneration += Generation;
var netConsumption = (result.Value.Consumption - Generation);
var cost = netConsumption * (netConsumption < 0 ? generationRate : result.Key);
totalCost += cost;
if (ratePeriods.Count() > 1)
{
tr = new TableRow {
HorizontalAlign = HorizontalAlign.Right
};
tr.Cells.Add(new TableCell {
Text = result.Key.ToString("$.00")
});
tr.Cells.Add(new TableCell {
Text = result.Value.Consumption.ToString("0.00")
});
if (!IgnoreGeneration)
{
tr.Cells.Add(new TableCell {
Text = Generation.ToString("0.00")
});
tr.Cells.Add(new TableCell {
Text = netConsumption.ToString("0.00")
});
tr.Cells.Add(new TableCell {
Text = (cost / (result.Value.Consumption)).ToString("$.000")
});
}
tr.Cells.Add(new TableCell {
Text = cost.ToString("$0.00")
});
tbl.Rows.Add(tr);
}
}
var netUsage = totalConsumption - totalGeneration;
tr = new TableFooterRow {
HorizontalAlign = HorizontalAlign.Right, BackColor = Color.LightGray
};
tr.Cells.Add(new TableCell {
Text = ((totalCost / netUsage) >= 0 ? (totalCost / netUsage).ToString("$.000") : " --- ")
});
tr.Cells.Add(new TableCell {
Text = totalConsumption.ToString("0.00")
});
if (!IgnoreGeneration)
{
tr.Cells.Add(new TableCell {
Text = totalGeneration.ToString("0.00")
});
tr.Cells.Add(new TableCell {
Text = netUsage.ToString("0.00")
});
tr.Cells.Add(new TableCell {
Text = (totalCost / totalConsumption).ToString("$.000")
});
}
tr.Cells.Add(new TableCell {
Text = (totalCost).ToString("$0.00")
});
tbl.Rows.Add(tr);
tr = new TableRow();
var tc = new TableCell();
tc.Controls.Add(tbl);
tr.Cells.Add(tc);
table.Rows.Add(tr);
tc = new TableCell();
tc.Controls.Add(table);
return(tc);
}
