public override async Task <CalculatorResponse> Calculate(CalculatorRequest request, ServerCallContext context)
{
return(new CalculatorResponse
{
Result = request.A + request.B
});
}
public ActionResult <string> Divide(CalculatorRequest request)
{
var a = request.A;
var b = request.B;
return($"A: {a} B: {b}, a + b = {a / b}");
}
public CalculatorResponse Calculate
(CalculatorRequest request)
{
decimal result;
switch (request.Action)
{
case "+":
result = request.DigA + request.DigB;
break;
case "-":
result = request.DigA - request.DigB;
break;
case "*":
result = request.DigA * request.DigB;
break;
case "/":
result = request.DigA / request.DigB;
break;
case "^":
result = Pow(request.DigA, request.DigB);
break;
default:
throw new InvalidOperationException();
}
return(new CalculatorResponse {
Result = result
});
}
public ActionResult <string> Multiply(CalculatorRequest request)
{
var a = request.A;
var b = request.B;
return($"A: {a} B: {b}, a + b = {a * b}");
}
public ActionResult <string> Subtract(CalculatorRequest request)
{
var a = request.A;
var b = request.B;
return($"A: {a} B: {b}, a + b = {a - b}");
}
public override Task <CalculatorReply> Calc(CalculatorRequest request, ServerCallContext context)
{
var exp = string.Empty;
var result = 0;
switch (request.Op)
{
case "+":
exp = $"{request.Num1} + {request.Num2}";
result = request.Num1 + request.Num2;
break;
case "-":
exp = $"{request.Num1} - {request.Num2}";
result = request.Num1 - request.Num2;
break;
case "*":
exp = $"{request.Num1} * {request.Num2}";
result = request.Num1 * request.Num2;
break;
case "/":
exp = $"{request.Num1} / {request.Num2}";
result = request.Num1 / request.Num2;
break;
}
return(Task.FromResult(new CalculatorReply()
{
Exp = exp,
Result = result
}));
}
async public Task <CalculatorResponse> Post(CalculatorRequest exp)
{
string content = exp.Expression;
if (!string.IsNullOrWhiteSpace(content))
{
float value;
string errMsg;
if (EvalStrWorker.EvalStr(content, out value, out errMsg))
{
_logger.LogInformation($"value: {value}");
return(new CalculatorResponse
{
StatusCode = System.Net.HttpStatusCode.OK,
Result = value.ToString()
});
}
else
{
_logger.LogInformation($"errMsg: {errMsg}");
return(new CalculatorResponse
{
StatusCode = System.Net.HttpStatusCode.BadRequest,
ErrorMessage = errMsg
});
}
}
return(new CalculatorResponse
{
StatusCode = System.Net.HttpStatusCode.BadRequest,
ErrorMessage = "Expression can't be null."
});
}
public HttpResponseMessage Calcula(CalculatorRequest calculate)
{
var response = calculatorBusiness.Calculate(calculate);
return(Request.CreateResponse(
String.IsNullOrEmpty(response) ? HttpStatusCode.OK : HttpStatusCode.ExpectationFailed,
response));
}
public override Task <CalculatorResponse> Calc(CalculatorRequest request, ServerCallContext context)
{
int result = request.Calculator.FirstNumber + request.Calculator.SecondNumber;
return(Task.FromResult(new CalculatorResponse()
{
Result = result
}));
}
public IActionResult CalcResult([FromBody] CalculatorRequest request)
{
var result = _serv.Evaluate(request.Expression);
return(Json(new
{
result = result != null ? result.ToString() : "Invalid expression",
}));
}
public override Task <CalculatorReply> Subtract(CalculatorRequest request, ServerCallContext context)
{
if (request.N2 == 0)
{
throw new RpcException(new Status(StatusCode.InvalidArgument, "Division by zero."));
}
return(Task.FromResult(new CalculatorReply {
Result = request.N1 - request.N2
}));
}
public async Task AdderMustAdd()
{
var testData = new CalculatorRequest
{
CalculatorOperatorType = CalculatorOperatorTypeEnum.Adder,
LeftVal = 3,
RightVal = 6
};
int addingResult = await getResultAsync(testData);
Assert.Equal(9, addingResult);
}
public async Task MultiplierMustMultiply()
{
var testData = new CalculatorRequest
{
CalculatorOperatorType = CalculatorOperatorTypeEnum.Multiplier,
LeftVal = 84,
RightVal = 37
};
int multiplyResult = await getResultAsync(testData);
Assert.Equal(3108, multiplyResult);
}
public async Task DividerMustDivide()
{
var testData = new CalculatorRequest
{
CalculatorOperatorType = CalculatorOperatorTypeEnum.Divider,
LeftVal = 84,
RightVal = 14
};
int multiplyResult = await getResultAsync(testData);
Assert.Equal(6, multiplyResult);
}
public async void TestProcessor_BadInput(string infix, int value)
{
var request = new CalculatorRequest()
{
Input = infix
};
BResult <CalculatorResponse> result = await new CalculateProcessor().ExecuteAsync(request);
Assert.Equal(value, result.Result.Output);
Assert.NotEmpty(result.Error);
}
public async Task SubstracterMustSubstract()
{
var testData = new CalculatorRequest
{
CalculatorOperatorType = CalculatorOperatorTypeEnum.Substracter,
LeftVal = 123,
RightVal = 43
};
int substractResult = await getResultAsync(testData);
Assert.Equal(80, substractResult);
}
private async Task <int> getResultAsync(CalculatorRequest calculatorRequest)
{
var testDataContent = JsonConvert.SerializeObject(calculatorRequest);
var testDataStringContent = new StringContent(testDataContent, System.Text.Encoding.UTF8, "application/json");
var response = await _client.PostAsync("/api/calculator", testDataStringContent);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var calculatorResponse = JsonConvert.DeserializeObject <CalculatorResponse>(responseString);
return(calculatorResponse.Result);
}
public async void VerifyAddTwoNumbers_ServiceApi_LocalInstance()
{
var service = new Calculator().Service;
var request = new CalculatorRequest
{
I1 = 5,
I2 = 10,
Operation = CalculatorOpEnum.Add,
};
var result = await service.Execute(request);
Xunit.Assert.True(result.Answer == 15);
}
public async void VerifyAddTwoNumbers_ServiceApi_SignalrRelay()
{
var service = new Calculator(typeof(SignalrRelayProxy <CalculatorRequest, CalculatorResponse>)).Service;
var request = new CalculatorRequest
{
I1 = 5,
I2 = 10,
Operation = CalculatorOpEnum.Add,
};
var result = await service.Execute(request);
Xunit.Assert.True(result.Answer == 15);
}
public void CalculatorRequestSum_Success()
{
//Arrange
RabbitRpc rabbit = new RabbitRpc("");
CalculatorRequest request = new CalculatorRequest();
request.Expression = "2+5";
string requestMessage = JsonConvert.SerializeObject(request);
string expected = "7";
//Act
string actual = rabbit.Call(requestMessage);
//Assert
Assert.Equal(expected, actual);
}
public async Task UndefinedMustReturnBadRequest()
{
var random = new Random();
var calculatorRequest = new CalculatorRequest
{
CalculatorOperatorType = CalculatorOperatorTypeEnum.Undefined,
LeftVal = random.Next(100),
RightVal = random.Next(100)
};
var testDataContent = JsonConvert.SerializeObject(calculatorRequest);
var testDataStringContent = new StringContent(testDataContent, System.Text.Encoding.UTF8, "application/json");
var response = await _client.PostAsync("/api/calculator", testDataStringContent);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
public static void Calc(CalculatorService.CalculatorServiceClient client)
{
var calc = new Calculator
{
FirstNumber = 10,
SecondNumber = 10
};
var calcRequest = new CalculatorRequest()
{
Calculator = calc
};
var responseCalc = client.Calc(calcRequest);
Console.WriteLine(responseCalc.Result);
}
public ActionResult <Adder> Post([FromBody] CalculatorRequest calculatorRequest)
{
CalculatorOperatorBase calculator;
switch (calculatorRequest.CalculatorOperatorType)
{
case CalculatorOperatorTypeEnum.Adder:
{
calculator = new Adder(calculatorRequest.LeftVal, calculatorRequest.RightVal);
break;
}
case CalculatorOperatorTypeEnum.Substracter:
{
calculator = new Substracter(calculatorRequest.LeftVal, calculatorRequest.RightVal);
break;
}
case CalculatorOperatorTypeEnum.Multiplier:
{
calculator = new Multiplier(calculatorRequest.LeftVal, calculatorRequest.RightVal);
break;
}
case CalculatorOperatorTypeEnum.Divider:
{
calculator = new Divider(calculatorRequest.LeftVal, calculatorRequest.RightVal);
break;
}
default:
{
return(BadRequest("Invalid CalculatorOperatorType"));
}
}
calculator.Calculate();
var calculatorResponse = new CalculatorResponse
{
Result = calculator.Result
};
return(Ok(calculatorResponse));
}
async Task <CalculatorResponse> CalculateAsync(CalculatorRequest request)
{
// Do async requests for the data
var validationResult = this.Validate(request);
if (!validationResult.IsValid)
{
await _logServiceClient.PostAsync(new LogRequest { Message = $"Failed to Calculate for {request.SupplyPoint}-{request.Date}" });
return(new CalculatorResponse {
Success = false, Errors = validationResult.FormattedErrors
});
}
var taskResult = GetTheDataToMakeCalculationsAsync(request);
var result = new CalculatorResponse {
Success = true, Reply = HttpStatusCode.OK
};
await _logServiceClient.PostAsync(new LogRequest { Message = $"Calculation complete for: {request.SupplyPoint}-{request.MarketParticipantId}-{request.LLF}-{request.Date}" });
return(result);
}
public double?Calculate(CalculatorRequest request)
{
double?operationResult = null;
var calMachine = new Calculator();
if (request.Operation.ToLowerInvariant() == "+" || request.Operation.ToLowerInvariant() == "sum")
{
operationResult += calMachine.Sum(request.Value1, request.Value2);
}
else if (request.Operation.ToLowerInvariant() == "-" || request.Operation.ToLowerInvariant() == "subtract")
{
operationResult += calMachine.Subtract(request.Value1, request.Value2);
}
else if (request.Operation.ToLowerInvariant() == "*" || request.Operation.ToLowerInvariant() == "multiply")
{
operationResult += calMachine.Multiply(request.Value1, request.Value2);
}
else if (request.Operation.ToLowerInvariant() == "/" || request.Operation.ToLowerInvariant() == "divide")
{
operationResult += calMachine.Divide(request.Value1, request.Value2);
}
return(operationResult);
}
public async Task <BResult <CalculatorResponse> > ExecuteAsync(CalculatorRequest request)
{
BResult <CalculatorResponse> result = new BResult <CalculatorResponse> {
Result = new CalculatorResponse()
};
try
{
if (string.IsNullOrWhiteSpace(request.Input))
{
result.Error.Add(new HError("Calculator", "Invalid request - null input"));
}
if (request.Input.Any(c => char.IsLetter(c)))
{
result.Error.Add(new HError("Calculator", "Invalid input - contains letters"));
}
if (!request.Input.EndsWith("="))
{
result.Error.Add(new HError("Calculator", "Invalid input - Expression must end with '='"));
}
if (_operators == null || _operators.Count == 0)
{
result.Error.Add(new HError("Calculator", "Invalid operator creation"));
return(result);
}
// Check input string against valid list of valid operators / digits
List <char> goodChar = _operators.Keys.SelectMany(s => s.ToCharArray()).ToList();
goodChar.AddRange(new List <char> {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '=', '(', ')'
});
if (request.Input.Except(goodChar).Any())
{
string validChar = string.Join(", ", goodChar.Select(c => c.ToString()).ToArray());
result.Error.Add(new HError("Calculator", $"Invalid input - Valid inputs are: {validChar}"));
}
if (result.Error.Count > 0)
{
return(result);
}
var calculateInputRequest = new CalculateInfixRequest()
{
Input = request.Input, Operators = _operators
};
BResult <CalculateInfixResponse> bResultInput = new InfixToPostfixProcessor().InfixToPostfix(calculateInputRequest);
result.Error.AddRange(bResultInput.Error);
//if (result.Error.Any())
// return result;
var calulateOutputRequest = new CalculatePostfixRequest()
{
CalculateStack = bResultInput.Result.CalculateStack, Operators = _operators
};
BResult <CalculatePostfixResponse> bResultOutput = new CalculatePostfixProcessor().Calculate(calulateOutputRequest);
result.Error.AddRange(bResultOutput.Error);
result.Result.Output = bResultOutput.Result.CalculatedValue;
}
catch (Exception ex)
{
result.Error.Add(new HException(_herrorRepository, "Calculator", "Exception will executing Calculator", ex));
}
await Task.Delay(0);
return(result);
}
public override Task <CalculatorReply> Add(CalculatorRequest request, ServerCallContext context) =>
Task.FromResult(new CalculatorReply {
Result = request.N1 + request.N2
});
public async Task <IHttpActionResult> Post([FromBody] CalculatorRequest request)
{
BResult <CalculatorResponse> result = await new CalculateProcessor().ExecuteAsync(request);
return(ResponseMessage(new ActionResponse <CalculatorResponse>().CreateResponse(result)));
}
public string Calculate(CalculatorRequest calc)
{
string requestMessage = JsonConvert.SerializeObject(calc);
return(rabbit.Call(requestMessage));
}
async Task GetTheDataToMakeCalculationsAsync(CalculatorRequest request)
{
// This is set up for one off requests at the moment
var retrievedData = new RetrieveData(request.Date, request.SupplyPoint, request.LLF, request.MarketParticipantId);
// Get the customer information just in case its needed
var customer = retrievedData.GetCustomerName();
var calculated = new CalculatedData(
retrievedData.GetProfileData(), retrievedData.GetDuosTimeBands(),
retrievedData.GetDuosTariffs()[0], retrievedData.GetLosses(),
retrievedData.GetTLossFactor(), retrievedData.GetContractBands());
calculated.Calculate();
var total = new TotalledCalculations(
calculated.CombinedLosses, retrievedData.GetSupplyCapacity(),
retrievedData.GetDuosTariffs()[0],
calculated.LossBand, calculated.EnergyBand);
total.Total();
var totalledDuos = total.DuosBand
.Select(s => new {
SupplyPointRef = request.SupplyPoint,
Date = request.Date,
Band = s.Band,
Units = s.Units,
UOM = s.UOM,
UnitCharge = s.UnitCharge,
Charge = s.Charge,
Count = s.Count
}).ToList();
var doneDuos = new PostDataArray(totalledDuos);
string duosPath = "http://localhost:1521/api/duos";
await doneDuos.MakeCallAsync(duosPath);
var totalledLoss = calculated.LossBand.GroupBy(s => s.Band)
.Select(g => new {
SupplyPointRef = request.SupplyPoint,
Date = request.Date,
Band = g.Key,
PencePerKwh = g.Max(s => s.PencePerKwh),
TLossKwh = g.Sum(s => s.TLossKwh),
DLossKwh = g.Sum(s => s.DLossKwh),
Count = g.Sum(s => s.Count)
}).ToList();
var doneLoss = new PostDataArray(totalledLoss);
string lossPath = "http://localhost:1521/api/loss";
await doneLoss.MakeCallAsync(lossPath);
var totalledEnergy = calculated.EnergyBand.GroupBy(g => g.Band)
.Select(s => new {
SupplyPointRef = request.SupplyPoint,
Date = request.Date,
Band = s.Key,
PencePerKwh = s.Max(g => g.PencePerKwh),
Kwh = s.Sum(g => g.Kwh),
EnergyCost = s.Sum(g => g.EnergyCost),
Count = s.Sum(g => g.Count)
}).ToList();
var doneEnergy = new PostDataArray(totalledEnergy);
string energyPath = "http://localhost:1521/api/energy";
await doneEnergy.MakeCallAsync(energyPath);
}
