public DivResponse div([FromBody] DivRequest value)
{
logger.Trace("Service called: div");
/* 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
{
DivResponse result = new DivResponse();
// Execute operation: Sub
String forJournal = "";
result.Quotient = value.Dividend / value.Divisor;
result.Remainder = value.Dividend % value.Divisor;
forJournal = value.Dividend + " / " + value.Divisor + " = " + result.Quotient + " Remainder = " + result.Remainder;
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 = "Div",
Calculation = forJournal,
Date = DateTime.Now.ToString("u")
};
Journal.store(trackingId, operation);
logger.Trace("Div 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 DivResponse Div(DivRequest request, string trakingId)
{
log.Trace("this is the service -> Div");
DivResponse div = new DivResponse();
try
{
var result = request.Dividend / request.Divisor;
var result1 = request.Dividend % request.Divisor;
div.Quotient = result;
div.Remainder = result1;
log.Trace(HttpStatusCode.OK);
if (trakingId != null)
{
var op = new Operation()
{
name = "Div",
date = DateTime.Now,
calculation = string.Join("/", request.Dividend, request.Divisor)
};
JournalList.Add(new KeyValuePair <string, Operation>(trakingId, op));
}
}
catch (Exception e)
{
log.Error("Error in the controller Div " + e);
log.Error(HttpStatusCode.InternalServerError);
throw new Exception();
}
return(div);
}
} // class
#endregion
#region method_DivisionPetition
public static void DivisionPetition(DivRequest calc, int id)
{
try
{
var httpWebRequest = HeaderBuilder("Calculator", "div", id);
string json = JsonConvert.SerializeObject(calc);
SendRequest(httpWebRequest, json);
DivResponse response = null;
HttpWebResponse httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
response = JsonConvert.DeserializeObject <DivResponse>(result);
}
Console.WriteLine("Quotient: {0} Remainder: {1}", response.Quotient, response.Remainder + "\n\npress enter to continue.");
Console.ReadKey();
}
// handle error exceptions
catch (WebException webex)
{
WebResponse errResp = webex.Response;
using (Stream respStream = errResp.GetResponseStream())
{
StreamReader reader = new StreamReader(respStream);
string text = reader.ReadToEnd();
}
}
} // class
public string Divide(DivRequest petition)
{
logger.Debug("------- Division Method -------");
try
{
if (petition == null || petition.Numbers == null)
{
return(Error400().ErrorMessage.ToString());
}
DivResponse result = new DivResponse();
string key = Request.Headers.GetValues("X_Evi_Tracking_Id").FirstOrDefault();
JournalService.Storing(Operations.Div(petition, result), "Division", key);
logger.Debug(Operations.Div(petition, result));
var hasonServer = JsonConvert.SerializeObject(result);
return(hasonServer);
}
catch (Exception ex)
{
return(JsonConvert.SerializeObject(Error500(ex)));
}
}
private static async Task Div()
{
Console.Clear();
var dividend = PromptSelection("Enter the dividend, or 'X' to end:");
if (dividend is null)
{
AnsiConsole.MarkupLine($"There is no dividend, no operation performed\n");
return;
}
var divisor = PromptSelection("Enter the divisor, or 'X' to end:");
if (dividend is null)
{
AnsiConsole.MarkupLine($"There is no divisor, no operation performed\n");
return;
}
var divRequest = new DivRequest {
Dividend = dividend.Value, Divisor = divisor.Value
};
var response = await CalculatorServiceClient.DivAsync(divRequest);
AnsiConsole.MarkupLine($"The quotient is: {response.Quotient} and the remainder is {response.Remainder}\n");
}
public void DivRequest_CorrectlyReturnsOperationname()
{
var expected = "div";
var request = new DivRequest();
var operationName = request.GetOperationName();
operationName.Should().Be(expected);
}
public void Div(string trackingId)
{
#region DivisionStuff
Console.WriteLine("-------Division Operation------");
Console.WriteLine("Type the integer division you want to do(ex:1243 / 12 / 2): ");
char symb = '/';
string div = Console.ReadLine();
div = CheckingSymbol.HaveOperationSymbol(symb, div);
int[] numbers;
if (ParsingComprobation.CanBeParsed(symb, div))
{
numbers = ParsingComprobation.Parse(ParsingComprobation.SeparateString(symb, div));
}
else
{
return;
}
#endregion
#region Connection
DivRequest division = new DivRequest();
DivResponse result = new DivResponse();
division.Numbers = numbers;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create($"{url}div");
request.Method = "POST";
request.ContentType = "application/json";
if (trackingId != "")
{
request.Headers.Add("X_Evi_Tracking_Id", trackingId);
}
using (StreamWriter dataStream = new StreamWriter(request.GetRequestStream()))
{
var jason = JsonConvert.SerializeObject(division);
dataStream.Write(jason);
dataStream.Close();
}
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
using (StreamReader stRead = new StreamReader(response.GetResponseStream()))
{
Console.WriteLine("The server operation's result is:");
result = JsonConvert.DeserializeObject <DivResponse>(stRead.ReadToEnd());
Console.WriteLine(result.Quotient);
Console.WriteLine("The remainder of the last division is:");
Console.WriteLine(result.Remainder);
stRead.Close();
}
#endregion
}
public void Div(string trackingId)
{
#region DivisionStuff
Console.WriteLine("-------Division Operation------");
Console.WriteLine("Type the binomial int division you want to do(ex:13 / 12): ");
char symb = '/';
string div = Console.ReadLine();
string[] nums = div.Split(symb);
int[] numbers = new int[nums.Length];
for (int i = 0; i < nums.Length; i++)
{
numbers[i] = int.Parse(nums[i].Trim());
Console.WriteLine(numbers[i]);
}
#endregion
#region Connection
DivRequest division = new DivRequest();
DivResponse result = new DivResponse();
division.Dividend = numbers[0];
division.Diviser = numbers[1];
HttpWebRequest request = (HttpWebRequest)WebRequest.Create($"{url}div");
request.Method = "POST";
request.ContentType = "application/json";
if (trackingId != "")
{
request.Headers.Add("X_Evi_Tracking_Id", trackingId);
}
using (StreamWriter dataStream = new StreamWriter(request.GetRequestStream()))
{
var jason = JsonConvert.SerializeObject(division);
dataStream.Write(jason);
dataStream.Close();
}
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
using (StreamReader stRead = new StreamReader(response.GetResponseStream()))
{
Console.WriteLine("The server operation's result is:");
result = JsonConvert.DeserializeObject <DivResponse>(stRead.ReadToEnd());
Console.WriteLine(result.Quotient);
Console.WriteLine("The remainder of the division is:");
Console.WriteLine(result.Remainder);
stRead.Close();
}
#endregion
}
public static string Division()
{
DivRequest petition = new DivRequest();
Console.WriteLine("Introduce dividendo y divisor");
petition.Dividend = ParseStringToInteger(Console.ReadLine());
petition.Divisor = ParseStringToInteger(Console.ReadLine());
var response = JsonConvert.DeserializeObject <DivResponse>(LaunchRequestAndReceiveResponse(petition, "div"));
return(String.Format("El cociente de la operacion es: {0} y el resto es: {1}", response.Quotient, response.Remainder));
}
public void Div(int[] numbers, string url)
{
string jsonRequest = "";
if (numbers.Length <= 2)
{
Console.WriteLine($"Operacion: {string.Join("/", numbers)}");
}
else
{
Console.WriteLine($"Operacion: {string.Join("/", numbers).Substring(0, string.Join("/", numbers).Length - 2)}");
}
logger.Info(url);
DivRequest div = new DivRequest();
if (numbers.Length != 0)
{
//Console.WriteLine("The request not have values");
div.Dividend = numbers[0];
div.Divisor = numbers[1];
}
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
req.Method = "POST";
req.ContentType = "application/json";
req.Headers.Add("X_Evi_Tracking_Id", "Test");
using (StreamWriter sw = new StreamWriter(req.GetRequestStream()))
{
jsonRequest = JsonConvert.SerializeObject(div);
sw.WriteLine(jsonRequest);
sw.Close();
}
// Get the response
string resp;
HttpWebResponse Response = (HttpWebResponse)req.GetResponse();
using (StreamReader sr = new StreamReader(Response.GetResponseStream(), Encoding.UTF8))
{
//response = JsonConvert.DeserializeObject<AddResponse>(sr.ReadToEnd());
resp = sr.ReadToEnd();
sr.Close();
Response.Close();
}
Console.WriteLine("The server responds: ");
Console.WriteLine(resp);
//Console.WriteLine($"{response.Operation} = {response.Total}");
logger.Info($"The server responds: {resp}");
logger.Info("-------------------------------------------------------------");
}
public async Task <Tuple <int, int> > Div(string trackingId, int dividend, int divisor)
{
var request = new DivRequest {
Dividend = dividend, Divisor = divisor
};
var response = await GetRequest(trackingId, CalculatorPath, DivPath)
.PostJsonAsync(request)
.ReceiveJson <DivResponse>();
return(new Tuple <int, int>(response.Quotient, response.Remainder));
}
public string Div(DivRequest Reqdiv)
{
DivResponse response = new DivResponse();
string operation = "";
logger.Trace("----- Method Divide -----");
try
{
if (Reqdiv == null || !(Reqdiv.Dividend.HasValue || Reqdiv.Divisor.HasValue))
{
return(Error400().ErrorMessage.ToString());
//throw new ArgumentNullException();
}
if (Reqdiv.Divisor == 0)
{
throw new DivideByZeroException();
//throw new Exception("The operation result is Infinite");
}
else
{
response.Quotient = Reqdiv.Dividend.Value / Reqdiv.Divisor.Value;
response.Remainder = Reqdiv.Dividend.Value % Reqdiv.Divisor.Value;
}
operation = $"{Reqdiv.Dividend} / {Reqdiv.Divisor}";
logger.Trace($"{operation} = {response.Quotient}(Reaminder: {response.Remainder})");
if (Request.Headers.GetValues("X_Evi_Tracking_Id") != null && Request.Headers.GetValues("X_Evi_Tracking_Id").Any())
{
string key = Request.Headers.GetValues("X_Evi_Tracking_Id").First();
JournalService.StoreOperation(CreateOperation("Div", $"{operation} = {response.Quotient}(Remainder: {response.Remainder})", DateTime.Now, key));
}
string json = JsonConvert.SerializeObject(response);
return(json);
}
catch (ArgumentNullException e)
{
logger.Error(e.Message);
return(e.Message);
}
catch (DivideByZeroException ex)
{
logger.Error(ex.Message);
return(ex.Message);
}
catch (Exception)
{
return(Error500().ErrorMessage.ToString());
}
}
public async Task Div_WithDivisor0_Returns400Response()
{
var request = new DivRequest()
{
Divisor = 0
};
var client = _factory.CreateClient();
var response = await client.PostJsonAsync("/calculator/div", request);
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public void DivRequestValidator_WithDivisorDifferentTo0_IsSuccessful()
{
var request = new DivRequest
{
Dividend = TestHelper.GeneratePositiveNumber(),
Divisor = TestHelper.GeneratePositiveNumber()
};
var validator = new DivRequestValidator();
var result = validator.Validate(request);
result.IsValid.Should().BeTrue();
}
public void DivRequestValidator_WithDivisor0_IsNotSuccessful()
{
var request = new DivRequest
{
Dividend = TestHelper.GeneratePositiveNumber(),
Divisor = 0
};
var validator = new DivRequestValidator();
var result = validator.Validate(request);
result.IsValid.Should().BeFalse();
}
public async Task Should_ReportBadRequest_When_Divide(int dividend, int divisor)
{
var server = await GetServer();
var client = server.GetTestClient();
var toSend = new DivRequest()
{
Dividend = dividend, Divisor = divisor
};
var content = new StringContent(JsonConvert.SerializeObject(toSend), Encoding.UTF8, "application/json");
var httpResponse = await client.PostAsync($"api/v1/calculator/div", content);
Assert.True(httpResponse.StatusCode == HttpStatusCode.BadRequest);
}
public void DivRequest_CorrectlyFormatsRequestForJournal()
{
var dividend = TestHelper.GeneratePositiveNumber();
var divisor = TestHelper.GeneratePositiveNumber();
var expected = $"{dividend} / {divisor}";
var request = new DivRequest
{
Dividend = dividend,
Divisor = divisor
};
var formattedRequest = request.GetFormatedRequest();
formattedRequest.Should().Be(expected);
}
public void Div_ShouldReturnBadRequest()
{
try
{
DivRequest testRequest = null;
var controller = new CalculatorController();
var result = controller.div(testRequest) as DivResponse;
}
catch (HttpResponseException ex)
{
Assert.AreEqual(ex.Response.StatusCode, HttpStatusCode.BadRequest);
}
}
public IHttpActionResult Div(DivRequest request)
{
log.Info("this is the controller -> Div");
if (request == null)
{
log.Error(HttpStatusCode.BadRequest);
return(BadRequest());
}
var id = Request.Headers.GetValues("X-Evi-Tracking-Id").FirstOrDefault();
var res = servicio.Div(request, id);
return(Ok(res));
}
public string Divide(DivRequest petition)
{
int[] nums = new int[2];
nums[0] = petition.Dividend;
nums[1] = petition.Diviser;
DivResponse result = new DivResponse();
result.Quotient = nums[0] / nums[1];
result.Remainder = nums[0] % nums[1];
var hasonServer = JsonConvert.SerializeObject(result);
return(hasonServer);
}
public void Div_ShouldReturnOK()
{
DivRequest testRequest = new DivRequest();
testRequest.Dividend = 11;
testRequest.Divisor = 2;
var controller = new CalculatorController();
var result = controller.div(testRequest) as DivResponse;
DivResponse compare = new DivResponse {
Quotient = 5, Remainder = 1
};
Assert.AreEqual(5, result.Quotient);
Assert.AreEqual(1, result.Remainder);
}
public string DivPost(DivRequest calc)
{
var headerRequest = this.Request.Headers;
int id = ServerCalc.getIdHeader(headerRequest);
var response = server.ServerCalc.DividingCalculation(calc.Dividend, calc.Divisor);
if (id != -1)
{
var fecha = DateTime.UtcNow;
fecha.ToString("O");
Query addquery = new Query(Operations.Div, $"{calc.Dividend}-{calc.Divisor}={response.Item1.Quotient}c-{response.Item1.Remainder}", fecha);
ServerCalc.writeQuery(id, addquery);
}
return(JsonConvert.SerializeObject(response.Item1));
}
public void Div(int[] numbers, string url)
{
string jsonRequest = "";
Console.WriteLine($"Operation: {string.Join("/", numbers)}");
logger.Info(url);
DivRequest div = new DivRequest();
if (numbers.Length != 0)
{
div.Numbers = numbers;
}
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
req.Method = "POST";
req.ContentType = "application/json";
req.Headers.Add("X_Evi_Tracking_Id", "This are the operations from the autotesting");
using (StreamWriter sw = new StreamWriter(req.GetRequestStream()))
{
jsonRequest = JsonConvert.SerializeObject(div);
sw.WriteLine(jsonRequest);
sw.Close();
}
string resp;
HttpWebResponse Response = (HttpWebResponse)req.GetResponse();
using (StreamReader sr = new StreamReader(Response.GetResponseStream(), Encoding.UTF8))
{
resp = sr.ReadToEnd();
sr.Close();
Response.Close();
}
Console.WriteLine("The server response is : ");
Console.WriteLine(resp);
logger.Info($"The server response is : {resp}");
logger.Info("---------");
}
public async Task <ActionResult <DivResponse> > PostDiv([FromBody] DivRequest request)
{
var validate = divValidator.Validate(request);
if (!validate.IsValid)
{
return(BadRequest(new ErrorResponse("BadRequest", "Unable to process request", "400", validate.Errors)));
}
var parameters = mapper.Map <DivParams>(request);
var operation = GetOp <DivParams, DivResult>(nameof(DivService));
var result = await operation.Execute(parameters);
logger.LogInformation($"PostDiv executed");
var resultResponse = this.mapper.Map <DivResponse>(result);
return(resultResponse);
}
public async Task Should_OperateCorrectly_When_Divide(int dividend, int divisor, int quotient, int remainder)
{
var server = await GetServer();
var client = server.GetTestClient();
var toSend = new DivRequest()
{
Dividend = dividend, Divisor = divisor
};
var content = new StringContent(JsonConvert.SerializeObject(toSend), Encoding.UTF8, "application/json");
var httpResponse = await client.PostAsync($"api/v1/calculator/div", content);
var responseContetAsString = await httpResponse.Content.ReadAsStringAsync();
var response = JsonConvert.DeserializeObject <DivResponse>(responseContetAsString);
Assert.True(httpResponse.StatusCode == HttpStatusCode.OK);
Assert.Equal(quotient, response.Quotient);
Assert.Equal(remainder, response.Remainder);
}
public async Task DivHandler_DividesDividendByDivisor()
{
var request = new DivRequest
{
Dividend = TestHelper.GeneratePositiveNumber(),
Divisor = TestHelper.GeneratePositiveNumber()
};
var expectedQuotiend = request.Dividend / request.Divisor;
var expectedRemainder = request.Dividend % request.Divisor;
var handler = new DivHandler();
var response = await handler.Handle(request, default);
using (new AssertionScope())
{
response.Quotient.Should().Be(expectedQuotiend);
response.Remainder.Should().Be(expectedRemainder);
}
}
public static string testDiv()
{
// Request Test Object
DivRequest request = new DivRequest();
request.Dividend = 11;
request.Divisor = 2;
// Response Test Object
DivResponse response;
// Calling service...
HttpWebRequest Req = (HttpWebRequest)WebRequest.Create(String.Format("{0}{1}", ENDPOINT, "div"));
Req.Method = "POST";
Req.ContentType = "application/json";
Req.Headers.Add("X-Evi-Tracking-Id", "12345678");
using (var streamWriter = new StreamWriter(Req.GetRequestStream()))
{
string json = JsonConvert.SerializeObject(request);
streamWriter.Write(json);
streamWriter.Flush();
streamWriter.Close();
}
// Getting response...
HttpWebResponse Resp = (HttpWebResponse)Req.GetResponse();
StreamReader sr = new StreamReader(Resp.GetResponseStream(), Encoding.UTF8);
string s = sr.ReadToEnd();
sr.Close();
Resp.Close();
response = JsonConvert.DeserializeObject <DivResponse>(s);
return(" Quotient = " + response.Quotient.ToString() + " Remainder = " + response.Remainder.ToString());
}
public async Task Div_WithTrackingId_TracksOperation()
{
var request = new DivRequest
{
Dividend = 10,
Divisor = 3
};
var trackId = "Div_WithTrackingId_TracksOperation";
var client = _factory.CreateClient()
.WithTrackIdHeader(trackId);
await client.PostJsonAsync("/calculator/div", request);
using (new AssertionScope())
{
_factory.Journal.TryGetValue(trackId, out var journalOperations)
.Should().BeTrue();
journalOperations.Should().ContainSingle()
.Which.Operation.Should().Be(request.GetOperationName());
}
}
public IActionResult Div([FromBody] DivRequest divRequest)
{
Log.Debug("Div");
if (!ModelState.IsValid)
{
return(GetError(StatusCodes.Status400BadRequest));
}
try
{
var result = _mathService.Div(divRequest.Dividend, divRequest.Divisor, Request.GetHeader(CalculatorServiceConstants.EvilTrackingHeader));
if (result != null)
{
return(Ok(new DivResponse(result.Quotient, result.Remainder)));
}
}
catch (Exception ex)
{
Log.Error(ex.Message);
}
return(GetError(StatusCodes.Status500InternalServerError));
}
public async Task Div_GetsCorrectResponse()
{
var dividend = 10;
var divisor = 3;
var expectedQuotient = dividend / divisor;
var expectedRemainder = dividend % divisor;
var request = new DivRequest
{
Dividend = dividend,
Divisor = divisor
};
var client = _factory.CreateClient();
var response = await client.PostJsonAsync("/calculator/div", request);
using (new AssertionScope())
{
response.StatusCode.Should().Be(HttpStatusCode.OK);
var responseObject = await response.GetResponse <DivResponse>();
responseObject.Quotient.Should().Equals(expectedQuotient);
responseObject.Remainder.Should().Equals(expectedRemainder);
}
}
