public string Multiply(MultRequest petition)
{
MultResponse result = new MultResponse();
logger.Debug("------- Multiply Method -------");
try
{
if (petition == null || petition.Multipliers == null)
{
return(Error400().ErrorMessage.ToString());
}
string key = Request.Headers.GetValues("X_Evi_Tracking_Id").FirstOrDefault();
JournalService.Storing(Operations.Mult(petition, result), "Multiplication", key);
logger.Debug(Operations.Mult(petition, result));
var hasonServer = JsonConvert.SerializeObject(result);
return(hasonServer);
}
catch (Exception ex)
{
return(JsonConvert.SerializeObject(Error500(ex)));
}
}
public MultResponse Product(MultRequest request, string trakingId)
{
log.Trace("this is the service -> Product");
MultResponse mult = new MultResponse();
try
{
int result = 1;
foreach (int i in request.Factors)
{
mult.Product = result *= i;
}
log.Trace(HttpStatusCode.OK);
if (trakingId != null)
{
var op = new Operation()
{
name = "Product",
date = DateTime.Now,
calculation = string.Join("*", request.Factors)
};
JournalList.Add(new KeyValuePair <string, Operation>(trakingId, op));
}
}
catch (Exception e)
{
log.Error("Error in the controller Product " + e);
log.Error(HttpStatusCode.InternalServerError);
throw new Exception();
}
return(mult);
}
private static async Task Mult()
{
Console.Clear();
var factors = new List <int>();
int?factor;
do
{
factor = PromptSelection("Enter an integer, or 'X' to end:");
if (factor.HasValue)
{
factors.Add(factor.Value);
}
}while (factor.HasValue);
if (!factors.Any())
{
AnsiConsole.MarkupLine($"There are no factors, no operation performed\n");
return;
}
var multRequest = new MultRequest {
Factors = factors
};
var response = await CalculatorServiceClient.MultAsync(multRequest);
AnsiConsole.MarkupLine($"The product of the factors is: {response.Product}\n");
}
public static void MultiplicationPetition(MultRequest calc, int id)
{
try
{
var httpWebRequest = HeaderBuilder("Calculator", "mult", id);
string json = JsonConvert.SerializeObject(calc);
SendRequest(httpWebRequest, json);
MultResponse response = null;
HttpWebResponse httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
response = JsonConvert.DeserializeObject <MultResponse>(result);
}
Console.WriteLine("Product: " + response.Product + "\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 MultResult Mult([FromBody] MultRequest multRequest)
{
var headers = this.Request.Headers.ToList();
string tracking_ID = headers[headers.Count - 1].Value.First().ToString();
return(CalculatorBL.Mult(multRequest, tracking_ID));
}
public static void Mult(MultRequest numbers, string EviTrackingID)
{
var client = new RestClient(urlBase);
var request = new RestRequest("Mult", Method.POST);
if (EviTrackingID != "")
{
request.AddHeader("x-evi-tracking-id", EviTrackingID);
}
else if (EviTrackingID == "")
{
request.AddHeader("x-evi-tracking-id", "0");
}
request.AddParameter("application/json", new JavaScriptSerializer().Serialize(numbers), ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
Console.WriteLine();
if (response.StatusCode == HttpStatusCode.OK)
{
MultResult result = (new JavaScriptSerializer()).Deserialize <MultResult>(response.Content);
Console.WriteLine("Resultado: Producto: " + result.Product + ". " + (EviTrackingID != "" ? "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 static MultResult Mult(MultRequest multRequest, string tracking_ID)
{
MultResult multResult = new MultResult();
try
{
int cont = 0;
string calculation = "";
multResult.Product = 1;
foreach (int number in multRequest.Factors)
{
cont += 1;
multResult.Product *= number;
calculation = calculation + number.ToString() + (cont == multRequest.Factors.Length ? "" : "*");
}
//Si viene el header x-trackingID diferente de 0 se guarda el log
if (Convert.ToInt32(tracking_ID) != 0)
{
SaveLog(Convert.ToInt32(tracking_ID), "Mult", calculation, multResult.Product);
}
}
catch (Exception ex)
{
multResult.Product = -1;
}
return(multResult);
}
public async Task Mult_WithEmptyFactors_Returns400Response()
{
var request = new MultRequest();
var client = _factory.CreateClient();
var response = await client.PostJsonAsync("/calculator/mult", request);
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public void MultRequest_CorrectlyReturnsOperationname()
{
var expected = "mult";
var request = new MultRequest();
var operationName = request.GetOperationName();
operationName.Should().Be(expected);
}
public void MultRequestValidator_WithNoMultends_IsNotSuccessful()
{
var request = new MultRequest
{
Factors = Enumerable.Empty <int>()
};
var validator = new MultRequestValidator();
var result = validator.Validate(request);
result.IsValid.Should().BeFalse();
}
public void Mult_ShouldReturnOK()
{
MultRequest testRequest = new MultRequest();
testRequest.Factors = new int[] { 8, 3, 2 };
var controller = new CalculatorController();
var result = controller.mult(testRequest) as MultResponse;
Assert.AreEqual(48, result.Product);
}
public async Task <int> Mult(string trackingId, int[] numbers)
{
var request = new MultRequest {
Factors = numbers.ToArray()
};
var response = await GetRequest(trackingId, CalculatorPath, MultPath)
.PostJsonAsync(request)
.ReceiveJson <MultResponse>();
return(response.Product);
}
public void Mult(string trackingId)
{
#region MultiplicationStuff
Console.WriteLine("------Multplication Operation------");
Console.WriteLine("Type the integer multiplication you want to do, multipliers must have 10 or less digits(ex:13 * 12 * 5): ");
char symb = '*';
string mult = Console.ReadLine();
mult = CheckingSymbol.HaveOperationSymbol(symb, mult);
int[] numbers;
if (ParsingComprobation.CanBeParsed(symb, mult, true))
{
numbers = ParsingComprobation.Parse(ParsingComprobation.SeparateString(symb, mult));
}
else
{
return;
}
#endregion
#region Connection
MultRequest multiply = new MultRequest();
MultResponse result = new MultResponse();
multiply.Multipliers = numbers;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create($"{url}mult");
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(multiply);
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 <MultResponse>(stRead.ReadToEnd());
Console.WriteLine(result.Result);
stRead.Close();
}
#endregion
}
public void Mult(string trackingId)
{
#region MultiplicationStuff
Console.WriteLine("------Multplication Operation------");
Console.WriteLine("Type the multiplication you want to do(ex:13 * 12 * 5): ");
char symb = '*';
string mult = Console.ReadLine();
string[] nums = mult.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
MultRequest multiply = new MultRequest();
MultResponse result = new MultResponse();
multiply.Multipliers = numbers;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create($"{url}mult");
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(multiply);
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 <MultResponse>(stRead.ReadToEnd());
Console.WriteLine(result.Result);
stRead.Close();
}
#endregion
}
public void MultRequestValidator_WithMultipleMultends_IsSuccessful()
{
var factors = TestHelper.GeneratePositiveNumbers();
var request = new MultRequest
{
Factors = factors
};
var validator = new MultRequestValidator();
var result = validator.Validate(request);
result.IsValid.Should().BeTrue();
}
public void MultRequest_CorrectlyFormatsRequestForJournal()
{
var factors = TestHelper.GeneratePositiveNumbers();
var expected = string.Join(" * ", factors);
var request = new MultRequest
{
Factors = factors
};
var formattedRequest = request.GetFormatedRequest();
formattedRequest.Should().Be(expected);
}
public string Multiply(MultRequest petition)
{
int[] nums = petition.Multipliers;
MultResponse result = new MultResponse();
result.Result = 1;
for (int i = 0; i < nums.Length; i++)
{
result.Result *= nums[i];
}
var hasonServer = JsonConvert.SerializeObject(result);
return(hasonServer);
}
public IHttpActionResult Product(MultRequest request)
{
log.Info("this is the controller -> Mult");
if (request == null)
{
log.Error(HttpStatusCode.BadRequest);
return(BadRequest());
}
var id = Request.Headers.GetValues("X-Evi-Tracking-Id").FirstOrDefault();
var res = servicio.Product(request, id);
return(Ok(res));
}
public void Mult_ShouldReturnBadRequest()
{
try
{
MultRequest testRequest = new MultRequest();
testRequest.Factors = null;
var controller = new CalculatorController();
var result = controller.mult(testRequest) as MultResponse;
}
catch (HttpResponseException ex)
{
Assert.AreEqual(ex.Response.StatusCode, HttpStatusCode.BadRequest);
}
}
public string Mult(MultRequest Reqmult)
{
MultResponse response = new MultResponse();
string operation = "";
logger.Trace("----- Method Multiply -----");
try
{
if (Reqmult == null || Reqmult.Factors == null)
{
return(Error400().ErrorMessage.ToString());
//throw new ArgumentNullException();
}
//response.Product = 1;
response.Product = Reqmult.Factors.Aggregate(1, (a, b) => a * b);
foreach (int item in Reqmult.Factors)
{
//response.Product *= item;
operation += $"{item} * ";
}
operation = operation.Substring(0, operation.Length - 3);
logger.Trace($"{operation} = {response.Product}");
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("Mul", $"{operation} = {response.Product}", DateTime.Now, key));
}
string json = JsonConvert.SerializeObject(response);
return(json);
}
catch (ArgumentNullException e)
{
logger.Error(e.Message);
return(e.Message);
}
catch (Exception)
{
return(Error500().ErrorMessage.ToString());
}
}
public string MultPost(MultRequest calc)
{
var headerRequest = this.Request.Headers;
int id = ServerCalc.getIdHeader(headerRequest);
MultResponse response = server.ServerCalc.MultiplyingCalculation(calc.Factors);
if (id != -1)
{
var fecha = DateTime.UtcNow;
fecha.ToString("O");
Query addquery = new Query(Operations.Mult, string.Join("*", calc.Factors) + "=" + response.Product, fecha);
ServerCalc.writeQuery(id, addquery);
}
return(JsonConvert.SerializeObject(response));
}
public static string Multiplication()
{
MultRequest req = new MultRequest();
Console.WriteLine("Introduce cuantos numeros deseas multiplicar");
int cuantos = ParseStringToInteger(Console.ReadLine());
req.Factors = new int[cuantos];
Console.WriteLine("Introduce los " + cuantos + " numeros a multiplicar");
for (int i = 0; i < cuantos; i++)
{
req.Factors[i] = ParseStringToInteger(Console.ReadLine());
}
var rep = JsonConvert.DeserializeObject <MultResponse>(LaunchRequestAndReceiveResponse(req, "mult"));
return(rep.Product.ToString());
}
public async Task <ActionResult <MultResponse> > PostMult([FromBody] MultRequest request)
{
var validate = multValidator.Validate(request);
if (!validate.IsValid)
{
return(BadRequest(new ErrorResponse("BadRequest", "Unable to process request", "400", validate.Errors)));
}
var parameters = mapper.Map <MultParams>(request);
var operation = GetOp <MultParams, IntResult>(nameof(MultService));
var result = await operation.Execute(parameters);
logger.LogInformation($"PostMult executed");
var resultResponse = this.mapper.Map <MultResponse>(result);
return(resultResponse);
}
public MultResponse Postmult([FromBody] MultRequest factores)
{
MultResponse multip = new MultResponse
{
Product = 1
};
foreach (int num in factores.Factors)
{
multip.Product = multip.Product * num;
}
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 MultOperation(factores, multip));
}
return(multip);
}
public async Task MultHandler_MultipliesFactors()
{
var factors = TestHelper.GeneratePositiveNumbers();
var request = new MultRequest
{
Factors = factors
};
var expected = 1;
foreach (var Multend in factors)
{
expected *= Multend;
}
var handler = new MultHandler();
var response = await handler.Handle(request, default);
response.Product.Should().Be(expected);
}
public async Task Mult_GetsCorrectResponse()
{
var factors = new[] { 4, 567, 23 };
var expected = factors.Aggregate((acc, x) => acc *= x);
var request = new MultRequest
{
Factors = factors
};
var client = _factory.CreateClient();
var response = await client.PostJsonAsync("/calculator/mult", request);
using (new AssertionScope())
{
response.StatusCode.Should().Be(HttpStatusCode.OK);
var responseObject = await response.GetResponse <MultResponse>();
responseObject.Product.Should().Equals(expected);
}
}
public async Task Mult_WithTrackingId_TracksOperation()
{
var request = new MultRequest
{
Factors = new[] { 4, 567, 23 }
};
var trackId = "Mult_WithTrackingId_TracksOperation";
var client = _factory.CreateClient()
.WithTrackIdHeader(trackId);
await client.PostJsonAsync("/calculator/mult", request);
using (new AssertionScope())
{
_factory.Journal.TryGetValue(trackId, out var journalOperations)
.Should().BeTrue();
journalOperations.Should().ContainSingle()
.Which.Operation.Should().Be(request.GetOperationName());
}
}
public void Mult(int[] numbers, string url)
{
string jsonRequest = "";
Console.WriteLine($"Operacion: {string.Join("*", numbers)}");
logger.Info(url);
// Connects to the server and sends the request
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()))
{
MultRequest mult = new MultRequest();
mult.Factors = numbers;
jsonRequest = JsonConvert.SerializeObject(mult);
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 static string testMult()
{
// Request Test Object
MultRequest request = new MultRequest();
request.Factors = new int[] { 8, 3, 2 };
// Response Test Object
MultResponse response;
// Calling service...
HttpWebRequest Req = (HttpWebRequest)WebRequest.Create(String.Format("{0}{1}", ENDPOINT, "mult"));
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 <MultResponse>(s);
return(response.Product.ToString());
}
public void Mult(int[] numbers, string url)
{
string jsonRequest = "";
Console.WriteLine($"Operation: {string.Join("*", numbers)}");
logger.Info(url);
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()))
{
MultRequest mult = new MultRequest();
mult.Multipliers = numbers;
jsonRequest = JsonConvert.SerializeObject(mult);
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("---------");
}
