public async Task <IActionResult> MultiplyAsync([FromBody] Num num)
{
_lg.LogInformation("multiply");
int result = 0;
try
{
await _context.AddLog(1, $"Required {JsonConvert.SerializeObject(num)}");
result = await _calculatorSoap.MultiplyAsync(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 <ActionResult <int> > Get_MultiplyAsync(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.MultiplyAsync(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> CariBuku_GetTotalSewa(string Dari, string Sampai, string Harga)
{
var r = new ErrorViewModel();
if (ModelState.IsValid)
{
try
{
int dayTotals = GF.GetDiffDays(Dari, Sampai);
CalculatorSoapClient authorServiceClient = new CalculatorSoapClient(CalculatorSoapClient.EndpointConfiguration.CalculatorSoap);
int d = await authorServiceClient.MultiplyAsync(dayTotals, Harga.ToInt());
string sewa = d.ToString().toNumber();
return(await Task.Run(() => Json(new { isValid = true, totalSewa = sewa })));
}
catch (Exception ex)
{
r.MessageContent = ex.ToString();
r.MessageTitle = "Error ";
r.RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier;
return(await Task.Run(() => Json(new { isValid = false, message = r.MessageContent, title = r.MessageTitle })));
}
}
else
{
r.MessageContent = "State Model tidak valid";
r.MessageTitle = "Error ";
r.RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier;
return(await Task.Run(() => Json(new { isValid = false, message = r.MessageContent, title = r.MessageTitle })));
}
}
static void Main(string[] args)
{
CalculatorSoap calculator = new CalculatorSoapClient(CalculatorSoapClient.EndpointConfiguration.CalculatorSoap);
Console.WriteLine("2*2 : " + calculator.MultiplyAsync(2, 2).Result);
Console.ReadLine();
}
public async Task <IActionResult> Multiply([FromBody] Number num)
{
_log.LogError("multiply");
int result = 0;
try
{
await _mathDbContext.AddLog(4, $"Requested {JsonConvert.SerializeObject(num)}");
result = await _calculatorSoap.MultiplyAsync(num.NumOne, num.NumTwo);
_log.LogInformation("result succesfully");
await _mathDbContext.AddLog(4, $"Response {result} {JsonConvert.SerializeObject(num)}");
return(Ok(result));
}
catch (Exception ex)
{
await _mathDbContext.AddLog(4, $"Requested {JsonConvert.SerializeObject(num)}");
await _mathDbContext.AddLog(4, "Error");
_log.LogError("request dont correct", ex);
throw;
}
}
public async Task <ActionResult> Multiply([FromQuery] Number number)
{
try
{
bool flag = _db.CalcFunctions.Any(r => r.Id == 3);
if (!flag)
{
_logger.LogError($"Warning Warning Warning CalcFunction Don't Exist");
throw new ArgumentException("Please Get Connecting with Owner");
}
int result = await _calculatorSoap.MultiplyAsync(number.Number_1, number.Number_2);
string message = Message.Info(number, (int)CalcOperation.Operation.Multiply, result);
await _db.WriteDbContext(3, message);
_logger.LogInformation(message);
return(Content($"Multiply {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> Multiply([FromBody] Number number)
{
_logger.LogInformation("start add method");
int result = 0;
if (ModelState.IsValid)
{
FirstTable first = null;
try
{
result = await CalculatorSoapClient.MultiplyAsync(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 void Multiply_3_7_Return_21()
{
// Act
var result = await _controller.MultiplyAsync(3, 7);
// Assert
Assert.Equal("21", result.ToString());
}
public async Task <int> Multiply(int value1, int value2)
{
await _client.OpenAsync();
var result = await _client.MultiplyAsync(value1, value2);
await _client.CloseAsync();
return(result);
}
public async Task <IActionResult> CalculatePrice(int bookId, DateTime dateStart, DateTime dateEnd)
{
Book data = BookMgr.GetBookByID(bookId);
int dateDiff = (dateEnd - dateStart).Days;
try
{
CalculatorSoapClient calculator = new CalculatorSoapClient(CalculatorSoapClient.EndpointConfiguration.CalculatorSoap12);
var result = await calculator.MultiplyAsync(Convert.ToInt32(data.RentPrice), dateDiff);
return(Json(result));;
}
catch (Exception)
{
var result = Convert.ToInt32(data.RentPrice) * dateDiff;
return(Json(result));;
}
}
public async Task <ActionResult> MultiplyAsync([FromBody] Number number)
{
int result = 0;
if (ModelState.IsValid)
{
_logger.LogInformation((int)CalculateEnum.Multiply, "Request to Json", "Method started ");
try
{
_logger.LogInformation((int)CalculateEnum.Multiply, "Request to Soap", "Request sent");
result = await _soapClient.MultiplyAsync(number.FirstNumber, number.SecondNumber);
_logger.LogInformation((int)CalculateEnum.Multiply, "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.Multiply, "Error message", exp.Message);
throw;
}
return(Ok(result));
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> Multiply([FromBody] NumCalculator number)
{
try
{
var data = JsonConvert.SerializeObject(number);
_logger.LogInformation(string.Format(Messages.Request, "Multiply", data));
await _dbContext.Reports.AddAsync(new Report
{
MethodId = 3,
VALUE = string.Format(Messages.Request, "Multiply", data)
});
await _dbContext.SaveChangesAsync();
var response = await _calculatorSoap.MultiplyAsync(number.FirstNum, number.SecondNum);
await _dbContext.Reports.AddAsync(new Report
{
MethodId = 3,
VALUE = string.Format(Messages.Response, "Multiply", 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> MulCalcAsync(int a, int b)
{
return(await _client.MultiplyAsync(a, b));
}
public async Task <ActionResult <string> > MultiplyAsync(int value1, int value2)
{
int result = await _calculatorSoapClient.MultiplyAsync(value1, value2);
return(result.ToString());
}