/// <summary>
/// Calculation generic
/// </summary>
/// <param name="calculateParams"></param>
/// <returns></returns>
public async Task <ICalculateResult> CalculateAsync(ICalculateParams calculateParams)
{
//result instance
var calculateGenericResult = new CalculateGenericResult();
var genericParams = calculateParams as CalculateGenericParams;
var calculateOverdraftParams = new CalculateOverdraftParams()
{
DeleteAccumulates = true,
SaveOverdraft = false,
IdentityWorkID = genericParams.IdentityWorkID,
InstanceID = genericParams.InstanceID,
OverdraftID = genericParams.OverdraftID.Value,
ResetCalculation = false,
};
var overdraftCalculationManager = new OverdraftCalculationManager();
await overdraftCalculationManager.CalculateAsync(calculateOverdraftParams);
var calculateResult = overdraftCalculationManager.CalculateFormula(genericParams.Formula);
calculateGenericResult.Result = calculateResult.Result;
calculateGenericResult.ResultText = calculateResult.ResultText;
calculateGenericResult.CalculateArguments = calculateResult.CalculateArguments;
return(calculateGenericResult);
}
public async Task <CalculateOverdraftResult> CalculateOverdraftAsync(CalculateOverdraftParams calculateOverdraftParams)
{
ICalculationManager calculationManager = new OverdraftCalculationManager();
var calculationResult = await calculationManager.CalculateAsync(calculateOverdraftParams) as CalculateOverdraftResult;
return(calculationResult);
}
public async Task CalculationFireAndForgetByPeriodIdsAsync(CalculationFireAndForgetByPeriodParams calculationFireAndForgetByPeriodParams)
{
var calculationManager = new OverdraftCalculationManager();
await calculationManager.CalculationFireAndForgetByPeriodIdsAsync(
calculationFireAndForgetByPeriodParams.PeriodIds,
calculationFireAndForgetByPeriodParams.IdentityWorkID,
calculationFireAndForgetByPeriodParams.InstanceID,
calculationFireAndForgetByPeriodParams.UserID);
}
private async Task <Overdraft> Calculate(Overdraft actualOverdraft, Guid identityWorkID, Guid instanceID, Guid user)
{
var mgr = new OverdraftCalculationManager();
var result = await mgr.CalculateAsync(new CalculateOverdraftParams()
{
IdentityWorkID = identityWorkID,
InstanceID = instanceID,
DeleteAccumulates = false,
OverdraftID = actualOverdraft.ID,
ResetCalculation = false,
UserID = user
});
return((result as CalculateOverdraftResult).OverdraftResult);
}
public async Task TM_229_()
{
using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
//Arrange
var identityWorkId = Guid.NewGuid();
var instanceID = Guid.NewGuid();
var diarySalary = 250M;
var fixedSBC = 261.30M;
//creates overdraft
var overdraft = await new PayrollStampingManagerUT().CreateRealOverdraftAsync(
identityWorkId, instanceID, diarySalary, fixedSBC);
ICalculateParams calculateByOverdraftParams = new Schema.Calculation.CalculateOverdraftParams()
{
OverdraftID = overdraft.ID,
IdentityWorkID = identityWorkId,
InstanceID = instanceID,
ResetCalculation = true,
UserID = Guid.NewGuid()
};
//Act
ICalculationManager overdraftCalculationManager = new OverdraftCalculationManager();
var calculateResult = await overdraftCalculationManager.CalculateAsync(calculateByOverdraftParams);
var calculateOverdraftResult = calculateResult as CalculateOverdraftResult;
var details = calculateOverdraftResult.OverdraftResult.OverdraftDetails;
//Asserts
//Ret. Inv. Y Vida - Deducción 5
var retInvYVida = details.FirstOrDefault(p =>
p.ConceptPayment.Code == 5 &&
p.ConceptPayment.ConceptType == ConceptType.DeductionPayment);
Assert.True(retInvYVida.Amount == 24.5M);
//Ret. Cesantia - Deduccion 6
var retCesantia = details.FirstOrDefault(p =>
p.ConceptPayment.Code == 6 &&
p.ConceptPayment.ConceptType == ConceptType.DeductionPayment);
Assert.True(retCesantia.Amount == 44.09M);
}
public async Task <CalculateResult> CalculateFormula(ICalculateParams calculateParams, string formula)
{
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
//result instance
var calculateOverdraftDIParams = calculateParams as CalculateOverdraftDIParams;
//Functions params // Para inyectarle a las formulas los datos necesarios para el calculo (1 sola llamada a BD)
var dataResponse = await GetDataAsync(
calculateOverdraftDIParams.InstanceID,
calculateOverdraftDIParams.IdentityWorkID,
calculateOverdraftDIParams.UserID);
//Fill necesary data to calculate
dataResponse = await FillDataAsync(calculateOverdraftDIParams, dataResponse);
//Poner en 0 todos los amounts / previous calculation
dataResponse.Overdraft.OverdraftDetails.ForEach(p =>
{
p.Taxed = 0M;
p.Exempt = 0M;
p.IMSSTaxed = 0M;
p.IMSSExempt = 0M;
if (calculateOverdraftDIParams.ResetCalculation)
{
p.IsAmount1CapturedByUser = false;
p.IsAmount2CapturedByUser = false;
p.IsAmount3CapturedByUser = false;
p.IsAmount4CapturedByUser = false;
p.IsTotalAmountCapturedByUser = false;
p.IsValueCapturedByUser = false;
p.Value = 0M;
p.Amount = 0M;
}
});
var calculateOverdraftParams = new CalculateOverdraftParams();
calculateOverdraftParams.DeleteAccumulates = false;
calculateOverdraftParams.IdentityWorkID = calculateOverdraftDIParams.IdentityWorkID;
calculateOverdraftParams.InstanceID = calculateOverdraftDIParams.InstanceID;
calculateOverdraftParams.OverdraftID = dataResponse.Overdraft.ID;
calculateOverdraftParams.ResetCalculation = true;
calculateOverdraftParams.SaveOverdraft = false;
calculateOverdraftParams.UserID = calculateOverdraftDIParams.UserID;
FunctionParams functionParams = new FunctionParams();
functionParams.CalculationBaseResult = dataResponse;
functionParams.IdentityWorkID = calculateOverdraftParams.IdentityWorkID;
functionParams.InstanceID = calculateOverdraftParams.InstanceID;
//overdraftDetails - All Perceptions, Deductions and Obligations
List <AccumulatedEmployee> accumulatedEmployees = dataResponse.AccumulatedEmployees;
var overdraftCalculationManager = new OverdraftCalculationManager();
//Initializate data, arguments, and functions
overdraftCalculationManager.Initializate(functionParams);
//Perceptions
(Overdraft overdraft, List <AccumulatedEmployee> employeeAccumulates) = await overdraftCalculationManager.CalculateByConceptAsync(dataResponse, ConceptType.SalaryPayment,
calculateOverdraftParams, null);
accumulatedEmployees = employeeAccumulates;
dataResponse.Overdraft = overdraft;
//Deductions
(overdraft, employeeAccumulates) = await overdraftCalculationManager.CalculateByConceptAsync(dataResponse, ConceptType.DeductionPayment,
calculateOverdraftParams, new ConcurrentBag <AccumulatedEmployee>(accumulatedEmployees));
accumulatedEmployees = employeeAccumulates;
dataResponse.Overdraft = overdraft;
//Liabilities
//Liability
dataResponse.IsLiability = true;
(overdraft, employeeAccumulates) = await overdraftCalculationManager.CalculateByConceptAsync(dataResponse, ConceptType.LiabilityPayment,
calculateOverdraftParams, new ConcurrentBag <AccumulatedEmployee>(accumulatedEmployees));
dataResponse.Overdraft = overdraft;
dataResponse.IsLiability = false;
//Ajuste al neto
await overdraftCalculationManager.amountAdjustmentAsync(dataResponse.Overdraft, calculateOverdraftParams, dataResponse);
var calculareResult = overdraftCalculationManager.CalculateFormula(formula);
stopwatch.Stop();
Trace.WriteLine($"Time elapsed in the overdraft di calculation {stopwatch.Elapsed}");
return(calculareResult);
}
