public async void Divide_8_2_Return_4()
{
// Act
var result = await _controller.DivideAsync(8, 2);
// Assert
Assert.Equal("4", result.ToString());
}
public async Task <ActionResult <int> > Get_DivideAsync(int first, int second)
{
try
{
await _dbContext.Logs.AddAsync(new Model.Log
{
Value = $" Request to Soap "
});
await _dbContext.SaveChangesAsync();
CalculatorSoapClient soapClient = new CalculatorSoapClient(CalculatorSoapClient.EndpointConfiguration.CalculatorSoap12);
int result = await soapClient.DivideAsync(first, second);
await _dbContext.Logs.AddAsync(new Model.Log
{
Value = $" Response from Soap "
});
await _dbContext.SaveChangesAsync();
return(result);
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> Divide([FromBody] Num num)
{
_lg.LogInformation("divide");
int result = 0;
try
{
await _context.AddLog(1, $"Required {JsonConvert.SerializeObject(num)}");
result = await _calculatorSoap.DivideAsync(num.Num1, num.Num2);
_lg.LogInformation("succes", result);
await _context.AddLog(1, $"Response {result} & {JsonConvert.SerializeObject(num)}");
return(Ok(result));
}
catch (Exception e)
{
await _context.AddLog(1, $"Required {JsonConvert.SerializeObject(num)}");
await _context.AddLog(1, "Error");
_lg.LogError("Error", e);
throw;
}
}
public async Task <IActionResult> Divide([FromBody] Number num)
{
_log.LogInformation("divide");
int result = 0;
try
{
await _mathDbContext.AddLog(3, $"Requested {JsonConvert.SerializeObject(num)}");
result = await _calculatorSoap.DivideAsync(num.NumOne, num.NumTwo);
_log.LogInformation("result succesfully");
await _mathDbContext.AddLog(3, $"Response {result} {JsonConvert.SerializeObject(num)}");
return(Ok(result));
}
catch (Exception ex)
{
await _mathDbContext.AddLog(3, $"Requested {JsonConvert.SerializeObject(num)}");
await _mathDbContext.AddLog(3, "Error");
_log.LogError("request dont correct", ex);
throw;
}
}
public async Task <ActionResult> Divide([FromQuery] Number number)
{
try
{
bool flag = _db.CalcFunctions.Any(r => r.Id == 4);
if (!flag)
{
_logger.LogError($"Warning Warning Warning CalcFunction Don't Exist");
throw new ArgumentException("Please Get Connecting with Owner");
}
int result = await _calculatorSoap.DivideAsync(number.Number_1, number.Number_2);
string message = Message.Info(number, (int)CalcOperation.Operation.Divide, result);
await _db.WriteDbContext(4, message);
_logger.LogInformation(message);
return(Content($"Divide {number.Number_1} / {number.Number_2} = {result}"));
}
catch (Exception ex)
{
_logger.LogError($"Warning Warning Warning in Adding Method ! {ex}");
throw new ArgumentException("Please Get Connecting with Owner");;
}
}
public async Task <IActionResult> Divide([FromBody] Number number)
{
_logger.LogInformation("start add method");
int result = 0;
if (ModelState.IsValid)
{
FirstTable first = null;
try
{
result = await CalculatorSoapClient.DivideAsync(number.IntA, number.IntB);
_logger.LogInformation("result successful");
first = new FirstTable();
_db.firstTables.Add(first);
await _db.SaveChangesAsync();
}
catch (Exception ex)
{
_logger.LogInformation("Request dont coreect", ex);
throw;
}
_db.secondTables.Add(new SecondTable(first.Id, result.ToString()));
await _db.SaveChangesAsync();
_logger.LogInformation("Successful");
return(Ok(result));
}
return(BadRequest());
}
public async Task <ActionResult <string> > DivideAsync(int value1, int value2)
{
if (value2 != 0)
{
int result = await _calculatorSoapClient.DivideAsync(value1, value2);
return(result.ToString());
}
return("Division on 0 exception");
}
public async Task <int> Divide(int value1, int value2)
{
await _client.OpenAsync();
var result = await _client.DivideAsync(value1, value2);
await _client.CloseAsync();
return(result);
}
public async Task <ActionResult> DivideAsync([FromBody] Number number)
{
int result = 0;
if (ModelState.IsValid)
{
_logger.LogInformation((int)CalculateEnum.Divide, "Request to Json", "Method started ");
try
{
_logger.LogInformation((int)CalculateEnum.Divide, "Request to Soap", "Request sent");
result = await _soapClient.DivideAsync(number.FirstNumber, number.SecondNumber);
_logger.LogInformation((int)CalculateEnum.Divide, "Response from Soap", "Request success");
using (var transaction = await _dbContext.Database.BeginTransactionAsync())
{
Table table = new Table();
_dbContext.Tables.Add(table);
await _dbContext.SaveChangesAsync();
SecondTable second = new SecondTable
{
Value = result.ToString(),
TableId = table.Id
};
await _dbContext.SecondTables.AddAsync(second);
await _dbContext.SaveChangesAsync();
await transaction.CommitAsync();
}
}
catch (Exception exp)
{
_logger.LogError((int)CalculateEnum.Divide, "Error message", exp.Message);
throw;
}
return(Ok(result));
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> Divide([FromBody] NumCalculator number)
{
try
{
var data = JsonConvert.SerializeObject(number);
_logger.LogInformation(string.Format(Messages.Request, "Divide", data));
await _dbContext.Reports.AddAsync(new Report
{
MethodId = 1,
VALUE = string.Format(Messages.Request, "Divide", data)
});
await _dbContext.SaveChangesAsync();
var response = await _calculatorSoap.DivideAsync(number.FirstNum, number.SecondNum);
await _dbContext.Reports.AddAsync(new Report
{
MethodId = 1,
VALUE = string.Format(Messages.Response, "Divide", response, data)
});
await _dbContext.SaveChangesAsync();
_logger.LogInformation("The control is succesfully", response);
return(Ok(response));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(new StatusCodeResult((int)HttpStatusCode.InternalServerError));
}
}
public async Task <int> DivCalcAsync(int a, int b)
{
return(await _client.DivideAsync(a, b));
}