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); }