public void RaiseCalculateResponseEventWithArgs(CalculateResponse response)
{
CalculateResponseEventWithArgs?.Invoke(this, new CalculateResponseEventArgs()
{
Response = response
});
}
private void BrowseClick(object sender, RoutedEventArgs e)
{
OpenFileDialog fileDialog = new OpenFileDialog();
if (fileDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
FilePathText.Text = fileDialog.FileName;
String hands = File.ReadAllText(fileDialog.FileName);
CalculateRequest calculateRequest = new CalculateRequest();
calculateRequest.Api = "1";
calculateRequest.HackData = hands;
if (AuthCheckbox.IsChecked.GetValueOrDefault())
{
calculateRequest.Token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJIYXBweVNhaWxhIn0.IIDVkUYHojF8Uy2xi3JtS8I5GBHX2vKNZNx8awegNt8";
}
else
{
calculateRequest.Token = "";
}
CalculateResponse calculateResponse = MaltaBEClient.Calculate(calculateRequest);
OutputText.Text = calculateResponse.Data;
}
}
public void Calculate_ValidChange_Test()
{
ChangeCalculator changeCalculator = new ChangeCalculator();
CalculateRequest request = new CalculateRequest();
request.ProductAmount = 1000;
request.PaidAmount = 2576;
//uint expected100Bills = 0;
//uint expected50Bills = 0;
//uint expected20Bills = 0;
uint expected10Bills = 1;
uint expected5Bills = 1;
//uint expected2Bills = 0;
//uint expected100Coins = 15;
uint expected50Coins = 1;
uint expected25Coins = 1;
uint expected1Coins = 1;
CalculateResponse response = changeCalculator.Calculate(request);
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsFalse(response.ErrorReportCollection.Any());
Assert.AreEqual(5, response.Change.Count());
Assert.AreEqual(expected10Bills, response.Change[1000]);
Assert.AreEqual(expected5Bills, response.Change[500]);
Assert.AreEqual(expected50Coins, response.Change[50]);
Assert.AreEqual(expected25Coins, response.Change[25]);
Assert.AreEqual(expected1Coins, response.Change[1]);
}
public async Task <IActionResult> Calculate([FromBody] CalculateRequest request)
{
try
{
if (ModelState.IsValid)
{
ForecastRequestDto requestDto = _requestMapper.MapCalculation(request);
ForecastResponseDto responseDto = await _orchestrator.Orchestration(requestDto);
CalculateResponse response = _responseMapper.MapCalculationResponse(responseDto);
return(Ok(response));
}
var errors = MapModelValidationErrors(ModelState);
return(BadRequest(new CalculateResponse(errors)));
}
catch (Exception ex)
{
//logging
return(BadRequest(new CalculateResponse(new List <string>()
{
"Exception"
})));
}
}
public async Task <Response <CalculateResponse> > CalculateTotal(StoreRequest storeRequest, string role)
{
if (string.IsNullOrEmpty(role))
{
throw new ApiException(ErrorMessages.RoleCanNotBeEmpty);
}
if (storeRequest.Weigth <= 0 || storeRequest.Price <= 0)
{
throw new ApiException(ErrorMessages.WeightCanNotBeZero);
}
if (storeRequest.Discount > 100)
{
throw new ApiException(ErrorMessages.DiscountCanNotBe100);
}
if (storeRequest.Discount > 0 && role != Roles.Privileged.ToString())
{
throw new ApiException(ErrorMessages.NotAPrivilegedCustomer);
}
CalculateResponse calculateResponse = new CalculateResponse();
// use automapper to map the objects here.
calculateResponse.Price = storeRequest.Price;
calculateResponse.Weigth = storeRequest.Weigth;
calculateResponse.Discount = storeRequest.Discount;
int totalAmount = storeRequest.Price * storeRequest.Weigth;
calculateResponse.Total = totalAmount - (double)(totalAmount * storeRequest.Discount) / 100;
return(new Response <CalculateResponse>(calculateResponse));
}
public async Task <IActionResult> Calculate([FromBody] CalculateRequest request)
{
try
{
if (ModelState.IsValid)
{
RequestDTO requestDto = MapForecastRequestViewModel(request);
IEnumerable <ForecastResponseDTO> responseDto = await _orchestrator.Orchestration(requestDto);
CalculateResponse response = MapForecastResponseDto(responseDto);
return(Ok(response));
}
var errors = ModelState.Values
.SelectMany(x => x.Errors)
.Select(x => x.ErrorMessage).ToList();
return(BadRequest(new CalculateResponse(errors)));
}
catch (Exception ex)
{
//logging
return(BadRequest("Exception"));
}
}
public static CalculateResponse Calculate(CalculateRequest request)
{
CalculateResponse response = new CalculateResponse();
switch (request.Operation)
{
case EnumOperation.Sum:
response.Result = request.ValueX + request.ValueY;
break;
case EnumOperation.Sub:
response.Result = request.ValueX - request.ValueY;
break;
case EnumOperation.Div:
response.Result = request.ValueX / request.ValueY;
break;
case EnumOperation.Mult:
response.Result = request.ValueX * request.ValueY;
break;
default:
break;
}
return(response);
}
public void Send_And_Receive_Standard_Request_With_Encryption()
{
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.CryptographyConfiguration.Enabled = true;
t2.CryptographyConfiguration.Enabled = true;
t1.Connect();
t2.Connect();
t2.RequestReceived += (s, e) =>
{
CalculateRequest receivedRequest = e.Message.Object as CalculateRequest;
t2.SendResponse(new CalculateResponse()
{
Sum = receivedRequest.A + receivedRequest.B
}, e.Message.Token);
};
t1.RequestReceived += (s, e) =>
{
CalculateRequest receivedRequest = e.Message.Object as CalculateRequest;
t1.SendResponse(new CalculateResponse()
{
Sum = receivedRequest.A + receivedRequest.B
}, e.Message.Token);
};
var request = new CalculateRequest()
{
A = 10, B = 15
};
CalculateResponse response1 = null;
CalculateResponse response2 = null;
Task.Factory.StartNew(() =>
{
response1 = t2.SendRequest <CalculateRequest, CalculateResponse>(request);
response1 = t2.SendRequest <CalculateRequest, CalculateResponse>(request);
}).GetAwaiter().GetResult();
Task.Factory.StartNew(() =>
{
response2 = t1.SendRequest <CalculateRequest, CalculateResponse>(request);
response2 = t1.SendRequest <CalculateRequest, CalculateResponse>(request);
}).GetAwaiter().GetResult();
Thread.Sleep(4000);
t1.Dispose(true);
t2.Dispose(true);
Assert.AreEqual(response1.Sum, request.A + request.B);
Assert.AreEqual(response2.Sum, request.A + request.B);
}
public async Task <CalculateResponse> Calculate(Operation operation)
{
var result = new CalculateResponse
{
Result = operation.Calculate()
};
return(await Task.FromResult(result));
}
public InvalidOperation()
{
result = new CalculateResponse()
{
Success = false,
Value = 0,
Message = "Invalid operation"
};
}
public InvalidParameter()
{
result = new CalculateResponse()
{
Success = false,
Value = 0,
Message = "Invalid parameter"
};
}
[ProducesResponseType(typeof(int), StatusCodes.Status400BadRequest)] // Tells swagger that the response format will be an int for a BadRequest (400)
public ActionResult <ExecuteMoveResponse> ExecuteMoveResponse([FromBody] ExecuteMove inputPayload)
{
if (PayloadValidation.ValidatePayload(inputPayload) == false)
{
return(BadRequest(4));
}
ExecuteMoveResponse response = CalculateResponse.CalculateMoveResponse(inputPayload);
return(response);
}
private void Calculate()
{
this.UxTxtProcessorResult.Clear();
this.UxTxtResult.Clear();
long productAmount = Convert.ToInt64(this.UxTxtProductValue.Text);
long paidAmount = Convert.ToInt64(this.UxTxtPaidValue.Text);
CadeMeuTrocoManager manager = new CadeMeuTrocoManager();
manager.OnProcessorExecuted += manager_OnProcessorExecuted;
CalculateRequest request = new CalculateRequest();
request.PaidAmountInCents = paidAmount;
request.ProductAmountInCents = productAmount;
ILog log = new FileLog();
log.Save("Calculate", "IT'S DONE M**********R!", CategoryType.Exception);
CalculateResponse response = manager.Calculate(request);
if (response.Success == false)
{
StringBuilder stringBuilder = new StringBuilder();
foreach (Report report in response.ReportCollection)
{
stringBuilder.AppendLine(string.Format("{0}: {1}", report.Field, report.Message));
}
this.UxTxtResult.Text = stringBuilder.ToString();
}
else
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine(string.Format("Valor total: {0}", response.ChangeAmount.Value));
//Percorre a lista de moedas e exibe a resposta
foreach (ChangeData data in response.ChangeCollection)
{
foreach (KeyValuePair <int, long> change in data.ChangeDictionary.Where(p => p.Value > 0))
{
stringBuilder.AppendLine(string.Format("{0}: {1} | Quantidade: {2}", data.Name, change.Key, change.Value));
}
}
this.UxTxtResult.Text = stringBuilder.ToString();
}
}
public void WriteToLog_Test()
{
ChangeCalculator changeCalculator = new ChangeCalculator();
CalculateRequest request = new CalculateRequest();
request.ProductAmount = 100;
request.PaidAmount = 150;
CalculateResponse response = changeCalculator.Calculate(request);
}
public void Calculate_ChangeAmountZero_Test()
{
ChangeCalculator changeCalculator = new ChangeCalculator();
CalculateRequest request = new CalculateRequest();
request.ProductAmount = 1000;
request.PaidAmount = 1000;
CalculateResponse response = changeCalculator.Calculate(request);
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsFalse(response.ErrorReportCollection.Any());
}
public CalculateResponse Post(InputPayload payload)
{
CalculateResponse response = null;
//Log all requests
log.Info(string.Format("HttpPost requested {0}", new JavaScriptSerializer().Serialize(payload)));
Operators.Calculator Calculator = null;
try
{
switch (payload.Operation)
{
case "add":
log.Info("Add operation executed");
Calculator = new Operators.Calculator(new Operators.Add());
break;
case "subtract":
log.Info("Subtract operation executed");
Calculator = new Operators.Calculator(new Operators.Subtract());
break;
case "multiply":
log.Info("Multiply operation executed");
Calculator = new Operators.Calculator(new Operators.Multiply());
break;
case "divide":
log.Info("Divide operation executed");
Calculator = new Operators.Calculator(new Operators.Divide());
break;
default:
log.Error(string.Format("Invalid operation {0}", payload.Operation));
Calculator = new Operators.Calculator(new Operators.InvalidOperation());
break;
}
}
catch (Exception ex)
{
//log invalid paramter passing
log.Error(string.Format("Exception error occur {0}", ex.Message));
Calculator = new Operators.Calculator(new Operators.InvalidParameter());
}
response = Calculator.Compute(payload);
log.Info(string.Format("HttpPost response {0}", new JavaScriptSerializer().Serialize(response)));
return(response);
}
public ResponseData GetCostCalculationResult([FromBody] RequestData request)
{
CalculateResponse cost = new CalculateResponse();
string message = string.Empty;
try
{
ValidationData validResponse = validator.ValidateTimestamp(this.HttpContext, request.TimeStampValue);
if (!validResponse.ResponseStatus)
{
return(core.GetResponseData(validResponse.ResponseCode, validResponse.Message));
}
validResponse = core.ValidateGivenMessage(request.MailText);
if (!validResponse.ResponseStatus)
{
return(core.GetResponseData(validResponse.ResponseCode, validResponse.Message));
}
double GSTPercent = Convert.ToDouble(config.GetSection("AppSettings")["GSTPercentage"].ToString());
if (!string.IsNullOrEmpty(request.GSTPercentage.ToString()) && request.GSTPercentage > 0)
{
GSTPercent = request.GSTPercentage;
}
double total = core.GetTotalCost(validResponse.Data);
if (total <= 0)
{
return(core.GetResponseData(1002, Messages.Error.TotalIsZero));
}
cost.CostExcludingGST = core.GetCostExclGST(total, GSTPercent);
cost.GSTCost = core.GetGSTAdded(total, cost.CostExcludingGST);
message = Messages.Success.PrdtCostResult.Replace("{totalCost}", total.ToString()).Replace("{gstPercent}", GSTPercent.ToString())
.Replace("{gstadded}", cost.GSTCost.ToString()).Replace("{costExclGST}", cost.CostExcludingGST.ToString());
string InputText = validResponse.Data.ToString().Replace("<", "<").Replace(">", ">");
return(core.GetResponseData(2000, message, InputText, cost));
}
catch (Exception e)
{
message = Messages.Error.UnExpectedError + ", Exception :" + e.ToString();
return(core.GetResponseData(1001, message));
}
}
private void UxBtnCalculate_Click(object sender, EventArgs e)
{
ulong productAmount = ulong.Parse(UxTxtProductAmount.Text);
DilmaProcessor dp = new DilmaProcessor();
ulong paidAmount = ulong.Parse(UxTxtPaidAmount.Text);
ChangeMachine.Core.ChangeCalculator changeCalculator = new Core.ChangeCalculator();
changeCalculator.OnProcessorCompleted += changeCalculator_OnProcessorCompleted;
CalculateRequest request = new CalculateRequest();
request.ProductAmount = productAmount;
request.PaidAmount = paidAmount;
CalculateResponse response = changeCalculator.Calculate(request);
if (response.Success == false)
{
StringBuilder errorMessage = new StringBuilder();
foreach (ErrorReport error in response.ErrorReportCollection)
{
errorMessage.AppendFormat("{0}: {1}", error.FieldName, error.Message).AppendLine();
}
MessageBox.Show(errorMessage.ToString(), "Deu Ruim, Brother!", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
StringBuilder result = new StringBuilder();
foreach (ChangeData changeData in response.Change)
{
foreach (KeyValuePair <uint, ulong> changeItem in changeData.ChangeCollection)
{
result.AppendFormat("{0} {1} de {2}", changeItem.Value, changeData.MoneyDescription, changeItem.Key).AppendLine();
}
}
UxTxtChangeResult.Text = result.ToString();
}
}
/// <summary>
/// Calcula o valor do troco.
/// </summary>
/// <param name="productValue">Valor do produto</param>
/// <param name="paidAmountInCents">Valor pago pelo produto</param>
/// <returns></returns>
public CalculateResponse Calculate(CalculateRequest request)
{
CalculateResponse response = new CalculateResponse();
string serializedRequest = Serializer.JsonSerialize(request);
try {
this.LogManager.Save("Calculate", string.Format("Nome do método: {0} | Objeto: {1} | JSON: {2}", "Calculate", "CalculateRequest", serializedRequest), CategoryType.Request);
// Verifica se todos os dados recebidos são validos.
if (request.IsValid == false)
{
response.ReportCollection = request.ReportCollection;
return(response);
}
// Calcula o valor do troco.
long changeAmount = request.PaidAmountInCents - request.ProductAmountInCents;
response.ChangeCollection = CalculateEntities(changeAmount);
response.ChangeAmount = changeAmount;
response.Success = true;
}
catch (Exception ex) {
this.LogManager.Save("Calculate", string.Format("Erro: {0} | Nome do método: {1} | Objeto: {2} | JSON: {3}", ex.ToString(), "Calculate", "CalculateRequest", serializedRequest), CategoryType.Exception);
Report report = new Report();
report.Field = null;
report.Message = "Ocorreu um erro ao processar sua requisição. Por favor, tente novamente mais tarde.";
response.ReportCollection.Add(report);
}
finally {
string serializedResponse = Serializer.JsonSerialize(response);
this.LogManager.Save("Calculate", string.Format("Nome do método: {0} | Objeto: {1} | JSON: {2}", "Calculate", "CalculateResponse", serializedResponse), CategoryType.Response);
}
return(response);
}
static void Main(string[] args)
{
Console.WriteLine("Entre com o valor do produto: ");
ulong productAmount = ulong.Parse(Console.ReadLine());
Console.WriteLine("Entre com o valor pago: ");
ulong paidAmount = ulong.Parse(Console.ReadLine());
ChangeMachine.Core.ChangeCalculator changeCalculator = new Core.ChangeCalculator();
CalculateRequest request = new CalculateRequest();
request.ProductAmount = productAmount;
request.PaidAmount = paidAmount;
CalculateResponse response = changeCalculator.Calculate(request);
if (response.Success == false)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Ocorreram um ou mais erros:");
foreach (ErrorReport error in response.ErrorReportCollection)
{
Console.WriteLine("{0}: {1}", error.FieldName, error.Message);
}
}
else
{
Console.WriteLine("Troco:");
foreach (ChangeData changeData in response.Change)
{
foreach (KeyValuePair <uint, ulong> changeItem in changeData.ChangeCollection)
{
Console.WriteLine("{0} {1} de {2}", changeItem.Value, changeData.MoneyDescription, changeItem.Key);
}
}
}
Console.ReadKey();
}
public void Calculate_GetChangeDataWithCoinsOnly_Test()
{
ConfigurationUtilityMock mock = new ConfigurationUtilityMock();
mock.LogPath = "C:\\Logs\\Test";
IocFactory.Register(
Component.For <IConfigurationUtility>().Instance(mock),
Component.For <ILog>().ImplementedBy <FileLog>().IsDefault()
);
CadeMeuTrocoManager manager = new CadeMeuTrocoManager();
CalculateRequest request = new CalculateRequest();
request.ProductAmountInCents = 100;
request.PaidAmountInCents = 140;
CalculateResponse response = manager.Calculate(request);
Assert.IsNotNull(response);
Assert.IsTrue(response.Success == true);
Assert.IsTrue(response.ChangeAmount == 40);
Assert.IsTrue(response.ChangeCollection.Count() == 1);
ChangeData changeData = response.ChangeCollection.First();
Assert.IsTrue(changeData.Name == "Coin");
Assert.IsTrue(changeData.ChangeDictionary.Count() == 3);
Assert.IsTrue(changeData.ChangeDictionary.ContainsKey(25) == true);
Assert.IsTrue(changeData.ChangeDictionary.ContainsKey(10) == true);
Assert.IsTrue(changeData.ChangeDictionary.ContainsKey(5) == true);
Assert.AreEqual(1, changeData.ChangeDictionary[25]);
Assert.AreEqual(1, changeData.ChangeDictionary[10]);
Assert.AreEqual(1, changeData.ChangeDictionary[5]);
}
public CalculateResponse Calculate(CostingRates costingRates,
IList <JewelTransaction> jewelTransactions)
{
var response = new CalculateResponse();
var lookupKey = Guid.NewGuid();
foreach (var tran in jewelTransactions)
{
decimal _metalAmount = 0M, _diamondAmount = 0M, _cstoneAmount = 0M, _certAmount = 0M, _laborAmount = 0M, _stampingAmount = 0M;
var transactionDetails = tran.Properties.ItemDetails;
// Metal Net Amount
var rate = costingRates.CostingItems.Single(x => x.ProductCategory == ProductCategory.Metal && x.Particulars == transactionDetails.MetalDetail.MetalKT);
_metalAmount = Math.Max(transactionDetails.MetalDetail.MetalNetWt * rate.Amount, 0);
transactionDetails.MetalDetail.MetalNetAmount = _metalAmount;
// Labour Detail
var labourCosting = costingRates.CostingItems.Single(x =>
x.Particulars == transactionDetails.ItemDescription &&
x.ProductCategory == ProductCategory.Labour
);
if (Convert.ToDecimal(transactionDetails.MetalDetail.MetalNetWt) * labourCosting.Amount <= labourCosting.MinimumAmount)
{
_laborAmount = Math.Max(labourCosting.MinimumAmount, 0);
}
else
{
_laborAmount = Convert.ToDecimal(transactionDetails.MetalDetail.MetalNetWt) * labourCosting.Amount;
}
transactionDetails.LabourCharges = _laborAmount;
// Diamond Net Amount
if (tran.StonePcs > 0)
{
var diamondDetails = transactionDetails.StoneDetail.StoneChart.StoneMetaDetailList;
diamondDetails.ForEach(dia =>
{
var diaCosting = costingRates.CostingItems.Single(x =>
x.Particulars == transactionDetails.StoneDetail.StoneType &&
x.ConfigurationValue == dia.StoneSieveSz &&
x.ProductCategory == ProductCategory.Stone
);
dia.StoneValue = dia.StoneWt * diaCosting.Amount;
_diamondAmount += dia.StoneValue;
});
transactionDetails.StoneDetail.StoneNetAmount = _diamondAmount;
if (tran.JewelItemCategory == JewelItemCategory.Gold)
{
if (
costingRates.CertificateRate.Items.Any(
x => x.RangeMinValue <= tran.StoneWeight && x.RangeMaxValue >= tran.StoneWeight))
{
var certCosting = costingRates.CertificateRate.Items.Single(x => x.RangeMinValue <= tran.StoneWeight && x.RangeMaxValue >= tran.StoneWeight);
_certAmount = certCosting.Amount * tran.StoneWeight;
transactionDetails.CertificateCharges = _certAmount;
}
else
{
response.AddValidationError("CertificateCosting", "Certificate costing is not defined for weight." + tran.StoneWeight);
}
}
_stampingAmount = tran.Properties.ItemDetails.StampingCharges;
}
// ColorStone Net Amount
if (tran.CStonePcs > 0)
{
var colorStoneDetails = transactionDetails.ColorStoneDetail;
var csCosting = costingRates.CostingItems.Single(x =>
x.Particulars == colorStoneDetails.ColorStoneType &&
x.ProductCategory == ProductCategory.ColorStone
);
_cstoneAmount = colorStoneDetails.ColorStoneNetWt * csCosting.Amount;
transactionDetails.ColorStoneDetail.ColorStoneNetAmount = _cstoneAmount;
_stampingAmount = tran.Properties.ItemDetails.StampingCharges;
}
tran.CostingDetail = new CostingDetail {
Properties = costingRates
};
tran.Properties = new TransactionDetails {
ItemDetails = transactionDetails
};
tran.TotalAmount = Math.Max(_metalAmount + _diamondAmount + _cstoneAmount + _certAmount + _laborAmount + _stampingAmount, 0);
tran.JewelTransactionRowId = lookupKey;
}
return(response);
}
private static void Main(string[] args)
{
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
//criando a conexao
using (var connection = factory.CreateConnection())
//criando o canal e declarando a fila
using (var channel = connection.CreateModel()) {
channel.QueueDeclare(queue: "rpc_queue",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
//o segundo parametro usado no BaicQos, serve para criarmos quantos server process quisermos.
channel.BasicQos(0, 1, false);
//criando um basic consumer para acessar a fila
var consumer = new QueueingBasicConsumer(channel);
channel.BasicConsume(queue: "rpc_queue",
noAck: false,
consumer: consumer);
Console.WriteLine(" [x] Awaiting RPC requests");
//usado para ficar pegando os requests e criando os responses
while (true)
{
CalculateResponse response = null;
//pegando o request
var ea = (BasicDeliverEventArgs)consumer.Queue.Dequeue();
//pegando as informações do request
var body = ea.Body;
var props = ea.BasicProperties;
var replyProps = channel.CreateBasicProperties();
replyProps.CorrelationId = props.CorrelationId;
try {
var message = Encoding.UTF8.GetString(body);
var calculateRequest = JsonConvert.DeserializeObject <CalculateRequest>(message);
Console.WriteLine("--------------------Processing a new request!--------------------");
Console.WriteLine();
Console.WriteLine("Fila:{0}", ea.BasicProperties.ReplyTo);
Console.WriteLine();
Console.WriteLine(" [Request] - ValueX:{0}, ValueY:{1}, Operation:{2}", calculateRequest.ValueX, calculateRequest.ValueY, calculateRequest.Operation.ToString());
//preenchendo o response
response = CalculateProcessor.Calculate(calculateRequest);
Console.WriteLine(" [Response] - Result:{0}", response.Result);
} catch (Exception e) {
Console.WriteLine(" [Exception] " + e.Message);
response = new CalculateResponse()
{
Result = 0
};
} finally {
//Convertendo o response
var responseJson = JsonConvert.SerializeObject(response);
//publicando o response na fila de resposta para o cliente
var responseBytes = Encoding.UTF8.GetBytes(responseJson);
channel.BasicPublish(exchange: "",
routingKey: props.ReplyTo,
basicProperties: replyProps,
body: responseBytes);
channel.BasicAck(deliveryTag: ea.DeliveryTag,
multiple: false);
}
}
}
}
public void Handshake_With_Different_Encryption_Configuration_And_Conditions()
{
if (IsRunningOnAzurePipelines)
{
return;
}
for (int i = 0; i < 10; i++)
{
ResonanceTransporter t1 = new ResonanceTransporter(new InMemoryAdapter("TST"));
ResonanceTransporter t2 = new ResonanceTransporter(new InMemoryAdapter("TST"));
t1.CryptographyConfiguration.Enabled = i % 2 == 0;
t2.CryptographyConfiguration.Enabled = i % 3 == 0;
t1.Connect();
t2.Connect();
t2.RequestReceived += (s, e) =>
{
CalculateRequest receivedRequest = e.Message.Object as CalculateRequest;
t2.SendResponse(new CalculateResponse()
{
Sum = receivedRequest.A + receivedRequest.B
}, e.Message.Token);
};
t1.RequestReceived += (s, e) =>
{
CalculateRequest receivedRequest = e.Message.Object as CalculateRequest;
t1.SendResponse(new CalculateResponse()
{
Sum = receivedRequest.A + receivedRequest.B
}, e.Message.Token);
};
var request = new CalculateRequest()
{
A = 10, B = 15
};
CalculateResponse response1 = null;
CalculateResponse response2 = null;
if (i % 2 == 0)
{
Task.Factory.StartNew(() =>
{
response1 = t2.SendRequest <CalculateRequest, CalculateResponse>(request);
});
Task.Factory.StartNew(() =>
{
response2 = t1.SendRequest <CalculateRequest, CalculateResponse>(request);
});
}
else
{
response1 = t2.SendRequest <CalculateRequest, CalculateResponse>(request);
response2 = t1.SendRequest <CalculateRequest, CalculateResponse>(request);
}
Thread.Sleep(1000);
Assert.IsNotNull(response1);
Assert.IsNotNull(response2);
if (t1.CryptographyConfiguration.Enabled && t2.CryptographyConfiguration.Enabled)
{
Assert.IsTrue(t1.IsChannelSecure);
Assert.IsTrue(t2.IsChannelSecure);
}
else
{
Assert.IsFalse(t1.IsChannelSecure);
Assert.IsFalse(t2.IsChannelSecure);
}
t1.Dispose(true);
t2.Dispose(true);
Assert.IsNotNull(response1);
Assert.IsNotNull(response2);
Assert.AreEqual(response1.Sum, request.A + request.B);
Assert.AreEqual(response2.Sum, request.A + request.B);
}
}
public void RaiseCalculateResponseEvent(CalculateResponse response)
{
CalculateResponseEvent?.Invoke(this, response);
}
public Add()
{
result = new CalculateResponse();
}
public Multiply()
{
result = new CalculateResponse();
}
public Subtract()
{
result = new CalculateResponse();
}
public async Task <IHttpActionResult> Calculate(CalculateRequest request)
{
//Definindo response
CalculateResponse response = null;
//Serializando o request
var jsonCalculateRequest = JsonConvert.SerializeObject(request);
var guidGeneratedInRequest = Guid.NewGuid().ToString();
//Criando conexão, canal do rabbit
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
connection = factory.CreateConnection();
channel = connection.CreateModel();
//declarando a fila de callback do rabbit, usando como nome, o guid gerado no request
channel.QueueDeclare(guidGeneratedInRequest, true, false, true, arguments: null);
//Criando um Header
var corrId = Guid.NewGuid().ToString();
var props = channel.CreateBasicProperties();
//preenchendo o header
props.ReplyTo = guidGeneratedInRequest;
props.CorrelationId = corrId;
//transformando o json do request em bytes
var bytesCalculateRequest = Encoding.UTF8.GetBytes(jsonCalculateRequest);
//PUBLICANDO NA FILA, passando os props para poder acontecer o reply
channel.BasicPublish(exchange: "", //enviando para o exchange default
routingKey: "rpc_queue",
basicProperties: props,
body: bytesCalculateRequest);
try {
var taskCompletionSource = new TaskCompletionSource <bool>();
await Task.Factory.StartNew(() => {
//CRIANDO CONSUMER na fila de callback
var consumer = new EventingBasicConsumer(channel);
channel.BasicConsume(queue: guidGeneratedInRequest,
noAck: true,
consumer: consumer);
//Obtem a resposta da requisição
consumer.Received += (model, ea) => {
//Verifica o identificador de correlação
OnMessageReceived?.Invoke(ea.Body, ea.Body.Length, ea.BasicProperties);
//if (ea.BasicProperties.CorrelationId == corrId) {
var responseFromRPC = Encoding.UTF8.GetString(ea.Body);
response = JsonConvert.DeserializeObject <CalculateResponse>(responseFromRPC);
taskCompletionSource.SetResult(true);
//}
};
});
await taskCompletionSource.Task;
if (response != null)
{
return(Ok(response));
}
return(BadRequest());
//while (true) {
// var ea = (BasicDeliverEventArgs)consumer.Queue.Dequeue();
// //verifica se a chave do response, é igual a chave passada no request
// if (ea.BasicProperties.CorrelationId == corrId) {
// //return Encoding.UTF8.GetString(ea.Body);
// var responseFromRPC = Encoding.UTF8.GetString(ea.Body);
// response = JsonConvert.DeserializeObject<CalculateResponse>(responseFromRPC);
// if (response != null) {
// return Ok(response);
// }
// return BadRequest();
// }
//}
#region Consumindo com Evento
//var consumerTag = string.Empty;
//var consumer = new EventingBasicConsumer(channel);
//consumer.Received += (model, ea) => {
// var body = ea.Body;
// //OnMessageReceived?.Invoke(body, body.Length, ea.BasicProperties);
// //todo:Eduardo Souza testando ack(noAck: de true para false)
// channel.BasicAck(ea.DeliveryTag, false);
// if (ea.BasicProperties.CorrelationId == corrId) {
// // //return Encoding.UTF8.GetString(ea.Body);
// // }
// var responseFromRPC = Encoding.UTF8.GetString(ea.Body);
// response = JsonConvert.DeserializeObject<CalculateResponse>(responseFromRPC);
// }
//};
//consumerTag = channel.BasicConsume(queue: QueueName, noAck: false, consumer: consumer);
//manualResetEvent.WaitOne();
#endregion
} catch (Exception ex) {
//Channel.BasicCancel(consumerTag);
return(BadRequest(ex.Message));
}
}
// Passar para o projeto do producer depois
// E refatorar o código
public async Task <CalculateResponse> SendToQueue(CalculateRequest calculateRequest)
{
var resultResponse = new CalculateResponse();
var taskCompletionSource = new TaskCompletionSource <bool>();
// Host
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
// Cria uma conxão específica para o endpoint
using (var connection = factory.CreateConnection()) {
// Abre um canal e cria a fila
using (var channel = connection.CreateModel()) {
// Nome da fila temporária
var queueName = Guid.NewGuid().ToString();
var replyToQueueName = channel.QueueDeclare(queue: queueName,
durable: false,
exclusive: false,
autoDelete: true,
arguments: null).QueueName;
// Fair Dispatch
//channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
// Preparando o envio
var props = channel.CreateBasicProperties();
props.ReplyTo = replyToQueueName;
//props.CorrelationId = correlationId;
var headerDictionary = new Dictionary <string, object>();
headerDictionary.Add(calculateRequest.ValorX.ToString(), calculateRequest.ValorY);
props.Headers = headerDictionary; // operação e valor
// Mensage a ser passada
var messageBytes = Encoding.UTF8.GetBytes(calculateRequest.Operation.ToString());
// Publicando msg
channel.BasicPublish(exchange: "",
routingKey: "input_api",
basicProperties: props,
body: messageBytes);
// =========================================== CONSUMER
//await Task.Factory.StartNew(() => {
// Configura as propriedades do model
var consumer = new EventingBasicConsumer(channel);
// Consumo básico com reconhecimento de mensagem
channel.BasicConsume(queue: replyToQueueName,
noAck: true,
consumer: consumer);
//while (true) {
//var ea = consumer.Queue.Dequeue();
consumer.Received += (model, ea) => {
OnMessageReceived?.Invoke(ea.Body, ea.Body.Length, ea.BasicProperties);
// Se a fila (com GUID) que criei, for igual a que o consumer respondeu
//if (ea.BasicProperties.ReplyTo == replyToQueueName) {
// Msg de retorno
var eaBody = Encoding.UTF8.GetString(ea.Body);
// Se deu algum erro no Cálculo
if (eaBody.ToLower().Contains("wrong"))
{
resultResponse.Error = eaBody;
}
else
{
resultResponse.Result = Convert.ToInt32(eaBody);
taskCompletionSource.SetResult(true);
}
//return result;
//}
};
//});// task
//}
}
}
await taskCompletionSource.Task;
return(resultResponse);
}
