public void AddCalculationResult(int numOfAffectedRows, long time)
{
CalculationResults.Add(new CaluclationResult()
{
DurationMs = time, RowsAffected = numOfAffectedRows
});
}
public void SetUp()
{
Family family = new Family
{
Members = new List <Person> {
new Person {
IsEmployee = true,
FirstName = "Aaron",
LastName = "Smith"
},
new Person {
FirstName = "Ahmed",
LastName = "Smith"
},
new Person {
FirstName = "Amy",
LastName = "Smith"
}
},
};
Calculator calculator = new Calculator();
_appConfig = new AppConfiguration();
_calculation = calculator.RunCalculations(family, _appConfig);
}
// POST: api/BenefitsApi
/// <summary>
/// Post performs the calculation.
/// </summary>
/// <param name="model">a Family instance</param>
/// <returns>CalculateResultsModel</returns>
/// an IEnumerable collection
public HttpResponseMessage Post([FromBody] Family model)
{
try
{
var validationResults = _familyValidator.Run(model);
if (validationResults.IsValid)
{
CalculationResults results = _calculator.RunCalculations(model, _appConfig);
CalculatedResultsModel resultsModel = _modelMapper.MapToResults(results);
return(Request.CreateResponse(HttpStatusCode.OK, resultsModel));
}
HttpError err = new HttpError("Invalid input parameter. " + validationResults.Message);
return(Request.CreateErrorResponse(HttpStatusCode.NotAcceptable, err));
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
//TODO: log the exception
HttpError err = new HttpError("Exception occurred check server logs");
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, err));
}
}
public CalculatedResultsModel MapToResults(CalculationResults calculation)
{
CalculatedResultsModel model = new CalculatedResultsModel();
//Brute force approach
//in real application we can integrate a mapping technology such
//as automapper
model.EmployeeName = getEmployeeName(calculation.Family);
model.AdjustedPeriodPayAmount = calculation.AdjustedPeriodAmount;
model.AnnualCosts = calculation.AnnualCosts;
model.AnnualSalary = calculation.AnnualSalary;
model.EmployerDiscounts = calculation.EmployerDiscounts;
model.Family = calculation.Family;
model.PerPeriodCosts = (calculation.AnnualCosts - calculation.EmployerDiscounts) / 26;
return(model);
}
public void SetUp()
{
_family = new Family
{
Members = new List <Person> {
new Person {
IsEmployee = true,
FirstName = "Joe",
LastName = "Smith"
}
},
};
_calculator = new Calculator();
_appConfig = new AppConfiguration();
_calculation = _calculator.RunCalculations(_family, _appConfig);
}
public void SetUp()
{
_family = new Family
{
Members = new List <Person> {
new Person {
IsEmployee = true,
FirstName = "Aaron",
LastName = "Smith"
}
},
};
_calculator = new Calculator();
_appConfig = new AppConfiguration();
_calculation = _calculator.RunCalculations(_family, _appConfig);
_mapper = new ModelMapper();
_results = _mapper.MapToResults(_calculation);
}
public async Task VisualizeAsync(CalculationResults calculationResults)
{
CancellationTokenSource = new CancellationTokenSource();
var cancellationToken = CancellationTokenSource.Token;
VisualizationStarted?.Invoke(calculationResults);
try
{
VisualizationTask = ValuesOutputAsync?.Invoke(calculationResults, cancellationToken);
if (VisualizationTask is not null)
{
await VisualizationTask;
}
}
catch
{
return;
}
VisualizationFinished?.Invoke(calculationResults);
}
/// <summary>
/// Calculator is a service object that
/// performs calculations and returns the results of those calculations.
/// </summary>
/// <param name="family">this parameter is input to perform the calculations</param>
/// <param name="appConfig">The app config is provides values necessary for the calculations</param>
/// <returns></returns>
public CalculationResults RunCalculations(Family family, IAppConfiguration appConfig)
{
decimal totalAnnualCosts = 0;
decimal employerDiscounts = 0;
decimal annualSalary = appConfig.AnnualSalary;
foreach (Person p in family.Members)
{
decimal annualCosts = 0;
if (p.IsEmployee)
{
annualCosts = appConfig.AnnualCostPerEmployee;
}
else
{
annualCosts = appConfig.AnnualCostPerMember;
}
totalAnnualCosts += annualCosts;
if (QualifiesForDiscount(p.FirstName))
{
employerDiscounts += (appConfig.BonusDiscountPercentage * .010M) * annualCosts;
}
}
CalculationResults results = new CalculationResults
{
AnnualCosts = totalAnnualCosts,
EmployerDiscounts = employerDiscounts,
AnnualSalary = annualSalary,
Family = family
};
return(results);
}
public IEnumerator Launch()
{
//Check how many spawned objects are not disintegrated yet
int spawnedObjectsStillAlive = 0;
foreach (GameObject obj in spawnedObjects)
{
if (!obj.GetComponentInChildren <MoveableScript>().isFall)
{
spawnedObjectsStillAlive++;
}
}
if (spawnedObjectsStillAlive < maxNumberOfObjectsInGame)
{
GameObject ins = Instantiate(launchObject, transform.position, Quaternion.identity, game.transform.root);
PlayerScript.restrictAllInput = true;
PlayerScript.allowRotate = false;
game.allowRewind = false;
MoveableScript moveable = ins.GetComponentInChildren <MoveableScript>();
moveable.moveCountAtSpawnTime = PlayerScript.moveCount;
Rigidbody rbody = ins.GetComponent <Rigidbody>();
rbody.isKinematic = false;
rbody.useGravity = true;
CalculationResults calc = CalculateLaunchData(ins);
rbody.velocity = calc.velocity;
DisintegrationScript destroy = ins.GetComponentInChildren <DisintegrationScript>();
destroy.destroyOnObstructedLanding = true;
spawnedObjects.Add(ins);
game.moveables.Add(moveable);
yield return(new WaitForSeconds(calc.time));
if (ins != null)
{
destroy.destroyOnObstructedLanding = false;
rbody.isKinematic = true;
rbody.useGravity = false;
ins.transform.position = targetPos;
ins.transform.eulerAngles = launchedObjectRotation;
}
PlayerScript.restrictAllInput = false;
PlayerScript.allowRotate = true;
game.allowRewind = true;
}
else
{
print("TOO MANY OBJECTS IN SCENE - ABOVE SET QUOTA");
moveCountWhenDenied.Add(PlayerScript.moveCount);
}
}
