public override Task <DivisionResponse> Divide(DivisionRequest request, ServerCallContext context)
{
return(Task.FromResult(new DivisionResponse
{
Result = request.Dividend / request.Divisor
}));
}
public override Task <DivisionResponse> Divide(DivisionRequest request, ServerCallContext context)
{//purposely not checking division by 0
return(Task.FromResult(new DivisionResponse
{
Result = request.Op1 / request.Op2
}));
}
public DivisionResult Div([FromBody] DivisionRequest divtRequest)
{
var headers = this.Request.Headers.ToList();
string trackingDiv = headers[headers.Count - 1].Value.First().ToString();
return(CalculatorBusiness.Div(divtRequest, trackingDiv));
}
public void TestDivision(int dividend, int divisor)
{
var request = new DivisionRequest(dividend, divisor);
var response = PluginContext.Operations.CallExternalOperation <DivisionRequest, DivisionResponse>("CalculatorServer", "Divide", request, CustomBinder.Instance);
PluginContext.Log.Info($"{dividend} = {divisor} * {response.Quotient} + {response.Remainder}");
}
public override Task <DivisionResponse> Divide(DivisionRequest request, ServerCallContext context)
{
var result = new DivisionResponse();
result.Cociente = request.Dividendo / request.Divisor;
result.Residuo = request.Dividendo % request.Divisor;
return(Task.FromResult(result));
}
/// <summary>
/// Metodo que realiza la División
/// </summary>
/// <param name="r"></param>
/// <returns></returns>
public async Task <DivisionResponse> Dividir(DivisionRequest r)
{
var result = await Task.Run(() => new KeyValuePair <double, double>(r.Dividendo / r.Divisor, r.Dividendo % r.Divisor));
await GuardarDiario(r, $"{result.Key},{result.Value}");
return(new DivisionResponse {
Cociente = result.Key, Resto = result.Value
});
}
public async Task <ActionResult <DivisionResponse> > DividirAsync([FromBody] DivisionRequest r)
{
r.IdSeguimiento = Request.Headers[IdHeader] == StringValues.Empty ? string.Empty : Request.Headers[IdHeader].ToString();
var response = await _calculatorService.Dividir(r);
Log.Information(r.ToRegistroDiario($"{response.Cociente},{response.Resto}").ToString());
return(Ok(response));
}
public override Task <OperationResponse> Calculate(DivisionRequest request, ServerCallContext context)
{
var result = request.FirstOperand / request.SecondOperand;
System.Console.WriteLine("Division request -> {0} / {1} = {2}", request.FirstOperand, request.SecondOperand, request.FirstOperand / request.SecondOperand);
return(Task.FromResult(new OperationResponse()
{
Result = result
}));
}
/// <summary>
/// processes a division of two integer arguments
/// using a specialized request argument
/// </summary>
/// <param name="divisionRequest">request providing dividend, divisor and a delegate to send back the response</param>
public void Divide(DivisionRequest divisionRequest)
{
var operands = divisionRequest.RequestData;
var results = new DivisionRequest.Results
{
Quotient = (double)operands.Dividend / (double)operands.Divisor,
IntegerQuotient = operands.Dividend / operands.Divisor,
IntegerRemainder = operands.Dividend % operands.Divisor
};
divisionRequest.Response(results);
}
public CalculatorResponse MakePostRequest(DivisionRequest divisionRequest)
{
string url = "http://api.mathjs.org/v4/";
string json = JsonConvert.SerializeObject(divisionRequest);
var data = new StringContent(json, Encoding.UTF8, "application/json");
var client = new HttpClient();
var response = client.PostAsync(url, data).Result;
string result = response.Content.ReadAsStringAsync().Result;
CalculatorResponse calculatorResponse = JsonConvert.DeserializeObject <CalculatorResponse>(result);
return(calculatorResponse);
}
/// <summary>
/// processes a division of two integer arguments
/// using a specialized request argument
/// </summary>
/// <param name="divisionRequest">request providing dividend, divisor and a delegate to send back the response</param>
public void Divide(DivisionRequest divisionRequest)
{
var operands = divisionRequest.RequestData;
var results = new DivisionRequest.Results
{
Quotient = (double)operands.Dividend / (double)operands.Divisor,
IntegerQuotient = operands.Dividend / operands.Divisor,
IntegerRemainder = operands.Dividend % operands.Divisor
};
divisionRequest.Response(results);
}
public ValueTask <DivisionResult> DivisionAsync(DivisionRequest request, CallContext context = default)
{
if (request.Y == 0.0D)
{
throw new RpcException(new Status(StatusCode.InvalidArgument, $"Divider Y is zero"));
}
return(new ValueTask <DivisionResult>(new DivisionResult
{
Result = request.X / request.Y
}));
}
public void DigitsDivision_DigitsFromFile_ResultsMatchToValidationFile()
{
foreach (var testData in _testData)
{
var divisionRequest = new DivisionRequest {
Expr = new List <string> {
$"{testData.FirstExpression}/{testData.SecondExpression}"
}
};
CalculatorResponse divisionResult = _mathjsProxy.MakePostRequest(divisionRequest);
Assert.AreEqual(testData.IsToFail, divisionResult.HasFailed);
Assert.AreEqual(testData.ExpectedResult, divisionResult.Result?.First());
}
}
/// <summary>
/// Implementación de llamado al servicio de dividir de la calculadora
/// </summary>
/// <param name="r"></param>
/// <returns></returns>
public async Task <DivisionResponse> Dividir(DivisionRequest r)
{
var client = new RestClient(_apiUrl);
var request = new RestRequest($"{CalculatorApiResource}/Div", Method.POST, DataFormat.Json);
if (!string.IsNullOrEmpty(r.IdSeguimiento))
{
request.AddHeader(IdHeader, r.IdSeguimiento);
}
request.AddParameter("application/json; charset=utf-8", JsonConvert.SerializeObject(r), ParameterType.RequestBody);
return(await client.PostAsync <DivisionResponse>(request));
}
/// <summary>
/// Group the Division operations.
/// </summary>
static public void DivisionMethod()
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("DIVISION");
Console.ForegroundColor = ConsoleColor.White;
int Dividendo = int.Parse(ValidarNumero("Ingrese el dividendo:"));
int Divisor = int.Parse(ValidarNumero("Ingrese divisor:"));
string logDiv = ValidarNumeroEspacio("\nIngrese el identificador del Log OPCIONAL:");
DivisionRequest divtRequest = new DivisionRequest();
divtRequest.Dividend = Dividendo;
divtRequest.Divisor = Divisor;
ManagementCalculator.Division(divtRequest, logDiv);
}
internal static async Task Main(string[] args)
{
Channel channel = new Channel("127.0.0.1:50050", ChannelCredentials.Insecure);
var client = new Calculator.CalculatorClient(channel);
var operands = new double[5] {
1D, 2D, 3D, 4D, 5D
};
var addRequest = new OperationRequest();
addRequest.Operands.AddRange(operands);
var subtractRequest = new OperationRequest();
subtractRequest.Operands.AddRange(operands);
var multiplicationRequest = new OperationRequest();
multiplicationRequest.Operands.AddRange(operands);
var divisionRequest = new DivisionRequest
{
Dividend = 45,
Divisor = 5
};
var sum = await client.AddAsync(addRequest);
var difference = await client.SubtractAsync(subtractRequest);
var product = await client.MultiplyAsync(multiplicationRequest);
var division = await client.DivideAsync(divisionRequest);
Console.WriteLine($"Sum: {sum.Result}, Difference: {difference.Result}, Product: {product.Result}, Division: {division.Result}");
await channel.ShutdownAsync();
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
public ContentResult Dividir([FromBody] DivisionRequest request)
{
try
{
decimal resultado = Calculadora.Dividir(request.V1, request.V2);
return(new ContentResult
{
StatusCode = 200,
Content = resultado.ToString()
});
}
catch (Exception ex)
{
return(new ContentResult
{
StatusCode = 500,
Content = ex.Message
});
}
}
/// <summary>
/// Example 2: divide two integers
/// </summary>
/// <param name="service">an instance of the IService to use</param>
private static void Example2(IService service)
{
// buffer variable for receiving the result
DivisionRequest.Results divisionResults = null;
// build the specialized request with the dividend, the divisor
// and the lambda expression for the callback with the resulting quotient
var divisionRequest = new DivisionRequest(
26, 10,
res => divisionResults = res
);
// send the request to the service
service.Divide(divisionRequest);
// output the result
Console.WriteLine();
Console.WriteLine("Requested the division of {0} by {1}", divisionRequest.RequestData.Dividend, divisionRequest.RequestData.Divisor);
Console.WriteLine("Returned the resulting quotient: {0}", divisionResults.Quotient);
Console.WriteLine(" integer quotient: {0}", divisionResults.IntegerQuotient);
Console.WriteLine(" integer remainder: {0}", divisionResults.IntegerRemainder);
}
/// <summary>
/// Method that connects to the Web API service to perform the division operation.
/// </summary>
/// <param name="values"></param>
/// <param name="logDiv"></param>
internal static void Division(DivisionRequest values, string logDiv)
{
try
{
var clientRest = new RestClient(urlWebAPI);
var requestRest = new RestRequest("Div", Method.POST);
if (logDiv == "")
{
logDiv = "0";
}
requestRest.AddHeader("x-evi-tracking-id", logDiv);
requestRest.AddParameter("application/json", new JavaScriptSerializer().Serialize(values), ParameterType.RequestBody);
IRestResponse responseRest = clientRest.Execute(requestRest);
Console.WriteLine();
if (responseRest.StatusCode == HttpStatusCode.OK)
{
DivisionResult result = (new JavaScriptSerializer()).Deserialize <DivisionResult>(responseRest.Content);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("\n\nRESULTADO, COCIENTE: " + result.Quotient + " - RESTO: " + result.Remainder + "." + (logDiv != "0" ? " La operacion fue registrada en el log." : ""));
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Error al realizar la operación: " + responseRest.ErrorMessage);
}
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("Operación finalizada.");
Console.WriteLine();
}
catch (Exception)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("\n\nError al conectarse con el servicio que realiza la operacion de división. ");
throw;
}
}
/// <summary>
/// Implementation of division method.
/// </summary>
/// <param name="divisionRequest"></param>
/// <param name="logDiv"></param>
/// <returns></returns>
public static DivisionResult Div(DivisionRequest divisionRequest, string logDiv)
{
try
{
DivisionResult divisionResult = new DivisionResult();
divisionResult.Quotient = divisionRequest.Dividend / divisionRequest.Divisor;
divisionResult.Remainder = divisionRequest.Dividend % divisionRequest.Divisor;
string calculation = divisionRequest.Dividend + "%" + divisionRequest.Divisor.ToString();
if (int.Parse(logDiv) != 0)
{
SaveLog(int.Parse(logDiv), "División ", calculation, divisionResult.Quotient);
}
return(divisionResult);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Example 2: divide two integers
/// </summary>
/// <param name="service">an instance of the IService to use</param>
private static void Example2(IService service)
{
// buffer variable for receiving the result
DivisionRequest.Results divisionResults = null;
// build the specialized request with the dividend, the divisor
// and the lambda expression for the callback with the resulting quotient
var divisionRequest = new DivisionRequest(
26, 10,
res => divisionResults = res
);
// send the request to the service
service.Divide(divisionRequest);
// output the result
Console.WriteLine();
Console.WriteLine("Requested the division of {0} by {1}", divisionRequest.RequestData.Dividend, divisionRequest.RequestData.Divisor);
Console.WriteLine("Returned the resulting quotient: {0}", divisionResults.Quotient);
Console.WriteLine(" integer quotient: {0}", divisionResults.IntegerQuotient);
Console.WriteLine(" integer remainder: {0}", divisionResults.IntegerRemainder);
}
public HttpResponseMessage Post([FromBody] DivisionRequest request)
{
var jsonFormatter = new JsonMediaTypeFormatter();
string trackingId = null;
if (Request.Headers.Contains("X-Evi-Tracking-Id"))
{
trackingId = Request.Headers.GetValues("X-Evi-Tracking-Id").First();
}
try
{
var response = new HttpResponseDto <DivisionResponse>
{
Status = HttpStatusCode.OK.ToString(),
Code = (int)HttpStatusCode.OK,
Message = repository
.Divide(new int[] { request.Dividend, request.Divisor }, trackingId)
};
// In case of success, return a Json with the corresponding calculation total
return(Request.CreateResponse(HttpStatusCode.OK, response, jsonFormatter));
}
catch (Exception ex)
{
var response = new HttpResponseDto <string>
{
Status = HttpStatusCode.BadRequest.ToString(),
Code = (int)HttpStatusCode.BadRequest,
Message = ex.Message
};
// In case of error, return a Json with the corresponding message to be shown
return(Request.CreateResponse(HttpStatusCode.BadRequest, response, jsonFormatter));
}
}
static async Task Main(string[] args)
{
RegisterServices();
var apiConsumerService = _serviceProvider.GetService <IApiConsumerService>();
//Valores estaticos
const string idSeguimiento = "operaciones123";
//Llamado al API para realizar una SUMA
var sumaRequest = new SumaRequest
{
Sumandos = new List <double>()
{
4, 5, 6, 10
},
IdSeguimiento = idSeguimiento
};
var sumaResponse = await apiConsumerService.Sumar(sumaRequest);
Console.WriteLine(sumaResponse);
//Llamado al API para realizar una resta
var restaRequest = new RestaRequest
{
Minuendo = 10,
Sustraendo = 6,
IdSeguimiento = "operaciones123"
};
var restaResponse = await apiConsumerService.Restar(restaRequest);
Console.WriteLine(restaResponse);
//Llamado al API para realizar una multiplicacion
var multiRequest = new MultiplicacionRequest
{
Factores = new List <double>()
{
4, 5
},
IdSeguimiento = "operaciones123"
};
var multiResponse = await apiConsumerService.Multiplicar(multiRequest);
Console.WriteLine(multiResponse);
//Llamado al API para realizar una division
var divRequest = new DivisionRequest
{
Dividendo = 4,
Divisor = 20,
IdSeguimiento = "operaciones123"
};
var divResponse = await apiConsumerService.Dividir(divRequest);
Console.WriteLine(divResponse);
//Llamado al API para realizar una raiz cuadrada
var raizRequest = new RaizCuadradaRequest
{
Numero = 9,
IdSeguimiento = "operaciones123"
};
var raizResponse = await apiConsumerService.CalcularRaizCuadrada(raizRequest);
Console.WriteLine(raizResponse);
//Llamado al API para consultar el diario
var consultaDiarioRequest = new ConsultaDiarioRequest
{
IdSeguimiento = idSeguimiento
};
var consultaDiarioResponse = await apiConsumerService.CosultarDiario(consultaDiarioRequest);
Console.WriteLine(consultaDiarioResponse);
Console.WriteLine("-----------------------------------------------------------------");
Console.WriteLine("Aplicación Finalizada");
Console.ReadKey();
}
public static DivisionResult Div(DivisionRequest divisionRequest, string tracking_ID)
{
return(CalculatorDataAccess.Div(divisionRequest, tracking_ID));
}
private DivisionResponse Divide(DivisionRequest request)
{
return(new DivisionResponse(request.Dividend / request.Divisor, request.Dividend % request.Divisor));
}
public async Task <DivisionResponse> Division([FromBody] DivisionRequest request)
{
return(await _calculator.Quotient(request.Dividend, request.Divisor));
}
