private static void Sqrt(Channel channel)
{
Console.WriteLine("Sqrt service");
var sqrtClient = new SqrtService.SqrtServiceClient(channel);
var number = new Sqrt.Number
{
A = -1
};
try
{
var sqrtRequest = new SqrtRequest()
{
Number = number
};
var sqrtResponse = sqrtClient.SquareRoot(sqrtRequest);
Console.WriteLine(sqrtResponse.Result);
Console.WriteLine("");
}
catch (RpcException e)
{
Console.WriteLine("Error : " + e.Status.Detail);
}
}
public SqrtResult Sqrt([FromBody] SqrtRequest sqrtRequest)
{
var headers = this.Request.Headers.ToList();
string tracking_ID = headers[headers.Count - 1].Value.First().ToString();
return(CalculatorBL.Sqrt(sqrtRequest, tracking_ID));
}
internal static void Sqrt(SqrtRequest sqrtRequest, string eviTrackingIDSqrt)
{
var client = new RestClient(urlBase);
var request = new RestRequest("Sqrt", Method.POST);
if (eviTrackingIDSqrt != "")
{
request.AddHeader("x-evi-tracking-id", eviTrackingIDSqrt);
}
else if (eviTrackingIDSqrt == "")
{
request.AddHeader("x-evi-tracking-id", "0");
}
request.AddParameter("application/json", new JavaScriptSerializer().Serialize(sqrtRequest), ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
Console.WriteLine();
if (response.StatusCode == HttpStatusCode.OK)
{
SqrtResult result = (new JavaScriptSerializer()).Deserialize <SqrtResult>(response.Content);
Console.WriteLine("Resultado: Cuadrado: " + result.Square + ". " + (eviTrackingIDSqrt != "" ? "y se guardo en el log." : ""));
}
else
{
Console.WriteLine("Ha ocurrido un error: " + response.ErrorMessage);
}
Console.WriteLine("Fin del programa, va a volver al menu");
Console.WriteLine();
}
public SqrtResponse Sqrt(SqrtRequest request, string trakingId)
{
log.Trace("this is the service -> Sqrt");
SqrtResponse sqrt = new SqrtResponse();
try
{
sqrt.Square = (int)Math.Sqrt(request.Number);
log.Trace(HttpStatusCode.OK);
if (trakingId != null)
{
var op = new Operation()
{
name = "Sqrt",
date = DateTime.Now,
calculation = string.Join("^", request.Number)
};
JournalList.Add(new KeyValuePair <string, Operation>(trakingId, op));
}
}
catch (Exception e)
{
log.Error("Error in the controller Sqrt " + e);
log.Error(HttpStatusCode.InternalServerError);
throw new Exception();
}
return(sqrt);
}
} // class
#endregion
#region method_SquareRootPetition
public static void SquareRootPetition(SqrtRequest calc, int id)
{
try
{
var httpWebRequest = HeaderBuilder("Calculator", "sqrt", id);
string json = JsonConvert.SerializeObject(calc);
SendRequest(httpWebRequest, json);
SqrtResponse response = null;
HttpWebResponse httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
response = JsonConvert.DeserializeObject <SqrtResponse>(result);
}
Console.WriteLine("Square: {0}", response.Square + "\n\npress enter to continue.");
Console.ReadKey();
}
catch (WebException webex)
{
WebResponse errResp = webex.Response;
using (Stream respStream = errResp.GetResponseStream())
{
StreamReader reader = new StreamReader(respStream);
string text = reader.ReadToEnd();
}
}
} // class
public override Task <SqrtResponse> Sqrt(SqrtRequest request, CancellationToken cancellationToken)
{
_ = request ?? throw new ArgumentNullException(nameof(request));
return(Task.FromResult(new SqrtResponse
{
Value = request.Value < 0 ? double.NaN : Math.Sqrt(request.Value),
}));
}
public SqrtResponse sqrt([FromBody] SqrtRequest value)
{
logger.Trace("Service called: sqrt");
/* An invalid request has been received.
* This may mean the HTTP requests and/or the HTTP body may contains some errors which should be fixed
* */
if (value == null)
{
logger.Error(HttpStatusCode.BadRequest);
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
try
{
SqrtResponse result = new SqrtResponse();
// Execute operation: Sub
String forJournal = "";
result.Square = Math.Sqrt(value.Number);
forJournal = "√" + value.Number + " = " + result.Square;
if (Request != null && Request.Headers != null)
{
var headers = Request.Headers;
if (headers.Contains("X-Evi-Tracking-Id"))
{
// Must store this request’s details inside it’s journal
string trackingId = headers.GetValues("X-Evi-Tracking-Id").First();
logger.Info("X-Evi-Tracking-Id = " + trackingId);
Operation operation = new Operation
{
OperationDes = "Sqrt",
Calculation = forJournal,
Date = DateTime.Now.ToString("u")
};
Journal.store(trackingId, operation);
logger.Trace("Sqrt success!!");
}
}
return(result);
}
catch (Exception ex)
{
logger.Error(ex);
/*
* An unexpected error condition was triggered which made impossible to fulfill the request. Please try again or contact support
* */
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public IHttpActionResult Square(SqrtRequest request)
{
string dataJournal = "";
IEnumerable <string> headerValues;
logger.Trace("Service called: square root");
// An invalid request has been received
// This may mean the HTTP requests and/or the HTTP body may contains some errors which should be fixed
if (request == null)
{
logger.Error(HttpStatusCode.BadRequest);
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
try
{
SqrtResponse result = new SqrtResponse();
// Execute operation: Square root
result.Square = Math.Sqrt(request.Number);
dataJournal = "√" + request.Number + " = " + result.Square;
logger.Trace("Square success!!");
// If tracking ID exists create operation instance and store in journal
if (Request.Headers.TryGetValues("X-Evi-Tracking-Id", out headerValues))
{
string id;
id = headerValues.FirstOrDefault();
var operation = new Operation()
{
Name = "square root",
Calculation = dataJournal,
Date = DateTime.Now
};
Journal.Store(id, operation);
}
return(Ok(result));
}
catch (Exception ex)
{
logger.Error(ex);
// An unexpected error condition was triggered which made impossible to fulfill the request
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public void SqrtRequest_CorrectlyReturnsOperationname()
{
var expected = "sqrt";
var request = new SqrtRequest();
var operationName = request.GetOperationName();
operationName.Should().Be(expected);
}
public static string Root()
{
SqrtRequest petition = new SqrtRequest();
Console.WriteLine("Introduce el número, cuya raíz cuadrada quieras saber");
petition.Number = ParseStringToInteger(Console.ReadLine());
var response = JsonConvert.DeserializeObject <SqrtResponse>(LaunchRequestAndReceiveResponse(petition, "sqrt"));
return(String.Format("La raíz cuadrada del número dado es: {0}", response.Square));
}
public async Task Sqrt_WithNumberLowerThan0_Returns400Response()
{
var request = new SqrtRequest()
{
Number = -1
};
var client = _factory.CreateClient();
var response = await client.PostJsonAsync("/calculator/sqrt", request);
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public void SqrtRequestValidator_WithNumberDifferentTo0_IsSuccessful()
{
var request = new SqrtRequest
{
Number = 5
};
var validator = new SqrtRequestValidator();
var result = validator.Validate(request);
result.IsValid.Should().BeTrue();
}
public void SqrtRequestValidator_WithNNumberLowerThan0_IsNotSuccessful()
{
var request = new SqrtRequest
{
Number = -1
};
var validator = new SqrtRequestValidator();
var result = validator.Validate(request);
result.IsValid.Should().BeFalse();
}
public async Task SqrtHandler_CalculatesSquareRoot()
{
var request = new SqrtRequest
{
Number = TestHelper.GeneratePositiveNumber()
};
var expected = Math.Sqrt(request.Number);
var handler = new SqrtHandler();
var response = await handler.Handle(request, default);
response.Square.Should().Be(expected);
}
public void SqrtRequest_CorrectlyFormatsRequestForJournal()
{
var number = TestHelper.GeneratePositiveNumber();
var expected = $"{(char)0x221A}{number}";
var request = new SqrtRequest
{
Number = number
};
var formattedRequest = request.GetFormatedRequest();
formattedRequest.Should().Be(expected);
}
/// <summary>
/// Group the Sqrt operations.
/// </summary>
static public void SqrtMethod()
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("RAIZ CUADRADA");
Console.ForegroundColor = ConsoleColor.White;
int number = int.Parse(ValidarNumero("Ingrese el número:"));
string logSqrt = ValidarNumeroEspacio("\nIngrese el identificador del Log OPCIONAL:");
SqrtRequest sqrtRequest = new SqrtRequest();
sqrtRequest.Number = number;
ManagementCalculator.Sqrt(sqrtRequest, logSqrt);
}
public override async Task <SqrtResponse> Sqrt(SqrtRequest request, ServerCallContext context)
{
var number = request.Number;
if (number >= 0)
{
return(new SqrtResponse {
SqrtRoot = Math.Sqrt(number)
});
}
throw new RpcException(new Status(StatusCode.InvalidArgument, "number < 0"));
}
public void Sqrt_ShouldReturnOK()
{
SqrtRequest testRequest = new SqrtRequest();
testRequest.Number = 16;
var controller = new CalculatorController();
var result = controller.sqrt(testRequest) as SqrtResponse;
Assert.AreEqual(4, result.Square);
}
public IHttpActionResult Sqrt(SqrtRequest request)
{
log.Info("this is the controller -> Sqrt");
if (request == null)
{
log.Error(HttpStatusCode.BadRequest);
return(BadRequest());
}
var id = Request.Headers.GetValues("X-Evi-Tracking-Id").FirstOrDefault();
var res = servicio.Sqrt(request, id);
return(Ok(res));
}
public void Sqrt_ShouldReturnBadRequest()
{
try
{
SqrtRequest testRequest = new SqrtRequest();
var controller = new CalculatorController();
var result = controller.sqrt(testRequest) as SqrtResponse;
}
catch (HttpResponseException ex)
{
Assert.AreEqual(ex.Response.StatusCode, HttpStatusCode.BadRequest);
}
}
public SqrtResponse Postsqrt([FromBody] SqrtRequest entry)
{
SqrtResponse raiz = new SqrtResponse
{
Square = Math.Sqrt(entry.Number)
};
if (Request.Headers["X-Evi-Tracking-Id"].Any())
{
var identification = Request.Headers["X-Evi-Tracking-Id"];
var currentUser = UsersHandler.KnownOrNot(identification);
currentUser.Operations.Add(new SqrtOperation(entry, raiz));
}
return(raiz);
}
public override async Task <SqrtResponse> SquareRoot(SqrtRequest request, ServerCallContext context)
{
int number = request.Number.A;
if (number >= 0)
{
return(new SqrtResponse()
{
Result = Math.Sqrt(number)
});
}
else
{
throw new RpcException(new Status(StatusCode.InvalidArgument, "Number below 0"));
}
}
public override Task <SqrtResponse> Sqrt(SqrtRequest request, ServerCallContext context)
{
if (request.Number >= 0)
{
var res = new SqrtResponse()
{
SquareRoot = Math.Sqrt(request.Number)
};
return(Task.FromResult(res));
}
else
{
throw new RpcException(new Status(StatusCode.InvalidArgument,
$"number {request.Number} has to be greater or equal than 0"));
}
}
public override async Task <SqrtResponse> Sqrt(SqrtRequest request, ServerCallContext context)
{
int square = request.Square;
if (square >= 0)
{
return(new SqrtResponse()
{
SquareRoot = Math.Sqrt(square)
});
}
else
{
throw new RpcException(new Status(StatusCode.InvalidArgument, "number(square) < 0"));
}
}
public override async Task <SqrtResponse> sqrt(SqrtRequest request, ServerCallContext context)
{
int number = request.Number;
if (number >= 0)
{
return new SqrtResponse()
{
SquareRoot = Math.Sqrt(number)
}
}
;
else
{
throw new RpcException(new Status(StatusCode.InvalidArgument, "number<0"));//to not stop server after throwing exception, async is made
}
}
public string SqrtPost(SqrtRequest calc)
{
var headerRequest = this.Request.Headers;
int id = ServerCalc.getIdHeader(headerRequest);
SqrtResponse response = server.ServerCalc.SquareRooCalculation(calc.Number);
if (id != -1)
{
var fecha = DateTime.UtcNow;
fecha.ToString("O");
Query addquery = new Query(Operations.Sqrt, $"√{calc.Number}={response.Square}", fecha);
ServerCalc.writeQuery(id, addquery);
}
return(JsonConvert.SerializeObject(response));
}
public override async Task <SqrtResponse> Sqrt(SqrtRequest request, ServerCallContext context)
{
var num = request.Number;
if (num >= 0)
{
return new SqrtResponse()
{
SquareRoot = Math.Sqrt(num)
}
}
;
else
{
throw new RpcException(new Status(StatusCode.InvalidArgument, $"number : {num}"));
}
}
public async Task Sqrt_WithTrackingId_TracksOperation()
{
var request = new SqrtRequest();
var trackId = "Sqrt_WithTrackingId_TracksOperation";
var client = _factory.CreateClient()
.WithTrackIdHeader(trackId);
await client.PostJsonAsync("/calculator/sqrt", request);
using (new AssertionScope())
{
_factory.Journal.TryGetValue(trackId, out ICollection <JournalOperation> journalOperations)
.Should().BeTrue();
journalOperations.Should().ContainSingle()
.Which.Operation.Should().Be(request.GetOperationName());
}
}
public static void handleSqrt()
{
Console.WriteLine("Type a number");
var numberStr = Console.ReadLine();
int.TryParse(numberStr, out var number);
var sqrtRequest = new SqrtRequest()
{
Number = number
};
var sqrtResponse = SqrtRPC.Execute(host, port, sqrtRequest).Result;
if (sqrtResponse != null)
{
Console.WriteLine($"Result: {sqrtResponse.SquareRoot}");
}
}
public async Task <ActionResult <SqrtResponse> > PostSqrt([FromBody] SqrtRequest request)
{
var validate = sqrtValidator.Validate(request);
if (!validate.IsValid)
{
return(BadRequest(new ErrorResponse("BadRequest", "Unable to process request", "400", validate.Errors)));
}
var parameters = mapper.Map <SqrtParams>(request);
var operation = GetOp <SqrtParams, IntResult>(nameof(SqrtService));
var result = await operation.Execute(parameters);
logger.LogInformation($"PostSqrt executed");
var resultResponse = this.mapper.Map <SqrtResponse>(result);
return(resultResponse);
}
