/// <summary>
/// Get Overdraft Data necesary for the calculations
/// </summary>
/// <param name="overdraftID"></param>
/// <param name="instanceID"></param>
/// <param name="identityWorkID"></param>
/// <returns></returns>
private async Task <CalculationBaseResult> GetDataAsync(Guid instanceID, Guid identityWorkID, Guid userID)
{
var calculationBaseResult = new CalculationBaseResult();
//Period variables
var memoryManager = new MemoryStorageContext();
//Prepare data
calculationBaseResult.MinimunSalaries = memoryManager.GetDefaultMinimunSalaries(identityWorkID, instanceID, userID);
calculationBaseResult.SGDFLimits = memoryManager.GetDefaultSGDFLimits(identityWorkID, instanceID, userID);
calculationBaseResult.UMAs = memoryManager.GetdDefaultUMA(identityWorkID, instanceID, userID);
calculationBaseResult.IMSSEmployeeTables = memoryManager.GetDefaultIMSSEmployeeTable(identityWorkID, instanceID, userID);
calculationBaseResult.IMSSEmployerTables = memoryManager.GetDefaultIMSSEmployerTable(identityWorkID, instanceID, userID);
calculationBaseResult.IMSSWorkRisks = memoryManager.GetDefaultIMSSWorkRisk(identityWorkID, instanceID, userID);
calculationBaseResult.SettlementCatalogs = memoryManager.GetDefaultSettlementCatalogTable(identityWorkID, instanceID, userID);
calculationBaseResult.MonthlyIncomeTaxes = memoryManager.GetDefaultMonthlyIncomeTax(identityWorkID, instanceID, userID);
calculationBaseResult.AnualIncomeTaxes = memoryManager.GetDefaultAnualIncomeTax(identityWorkID, instanceID, userID);;
calculationBaseResult.MonthlyEmploymentSubsidies = memoryManager.GetDefaultMonthlyEmploymentSubsidy(identityWorkID, instanceID, userID);
calculationBaseResult.AnualEmploymentSubsidies = memoryManager.GetDefaultAnualEmploymentSubsidy(identityWorkID, instanceID, userID);
var accumulatedTypes = memoryManager.GetDefaultAccumulatedType(identityWorkID, instanceID, userID);
(var iconcepts, var conceptRelations) = memoryManager.GetDefaultConcept <ConceptPayment>(identityWorkID, instanceID, userID, accumulatedTypes);
calculationBaseResult.ConceptPayments = iconcepts.Cast <ConceptPayment>().ToList();
calculationBaseResult.ConceptPaymentRelationships = memoryManager.GetDefaultConceptPaymentRelationship(iconcepts, accumulatedTypes);
calculationBaseResult.AccumulatedTypes = accumulatedTypes;
foreach (var relationship in calculationBaseResult.ConceptPaymentRelationships)
{
var accumulatedType = calculationBaseResult.AccumulatedTypes.FirstOrDefault(q => q.ID == relationship.AccumulatedTypeID);
relationship.AccumulatedType = accumulatedType;
var conceptPayment = calculationBaseResult.ConceptPayments.FirstOrDefault(q => q.ID == relationship.ConceptPaymentID);
relationship.ConceptPayment = conceptPayment;
}
return(calculationBaseResult);
}
private ConceptPayment fixFormulasConceptPayment(ConceptPayment conceptPayment, CalculationBaseResult dataResponse)
{
var conceptDefault = dataResponse.ConceptPayments.FirstOrDefault(p =>
p.Code == conceptPayment.Code &&
p.ConceptType == conceptPayment.ConceptType);
if (conceptPayment.FormulaValue == null)
{
conceptPayment.FormulaValue = conceptDefault.FormulaValue;
}
if (conceptPayment.Formula == null)
{
conceptPayment.Formula = conceptDefault.Formula;
}
if (conceptPayment.Formula1 == null)
{
conceptPayment.Formula1 = conceptDefault.Formula1;
}
if (conceptPayment.Formula2 == null)
{
conceptPayment.Formula2 = conceptDefault.Formula2;
}
if (conceptPayment.Formula3 == null)
{
conceptPayment.Formula3 = conceptDefault.Formula3;
}
if (conceptPayment.Formula4 == null)
{
conceptPayment.Formula4 = conceptDefault.Formula4;
}
if (conceptPayment.SATGroupCode == null)
{
conceptPayment.SATGroupCode = String.Empty;
}
//Name
conceptPayment.Name = conceptDefault.Name;
return(conceptPayment);
}
private async Task <CalculationBaseResult> FillDataAsync(CalculateOverdraftDIParams calculateOverdraftDIParams,
CalculationBaseResult dataResponse)
{
dataResponse.Overdraft = _mapper.Map <OverdraftDI, Overdraft>(calculateOverdraftDIParams.OverdraftDI);
dataResponse.Overdraft.PeriodDetail = _mapper.Map <PeriodDetailDI, PeriodDetail>(calculateOverdraftDIParams.OverdraftDI.PeriodDetailDI);
dataResponse.Overdraft.PeriodDetail.Period = _mapper.Map <PeriodDI, Period>(calculateOverdraftDIParams.OverdraftDI.PeriodDetailDI.PeriodDI);
dataResponse.Overdraft.Employee = _mapper.Map <EmployeeDI, Employee>(calculateOverdraftDIParams.OverdraftDI.EmployeeDI);
dataResponse.Overdraft.Employee.Workshift = _mapper.Map <WorkshiftDI, Workshift>(calculateOverdraftDIParams.OverdraftDI.EmployeeDI.WorkshiftDI);
dataResponse.Overdraft.Employee.HistoricEmployeeSalaryAdjustments = new List <HistoricEmployeeSalaryAdjustment>();
dataResponse.Overdraft.Employee.HistoricEmployeeSBCAdjustments = new List <HistoricEmployeeSBCAdjustment>();
if (calculateOverdraftDIParams.OverdraftDI.OverdraftDetailDIs.Any())
{
for (int i = 0; i < calculateOverdraftDIParams.OverdraftDI.OverdraftDetailDIs.Count; i++)
{
var detailDI = calculateOverdraftDIParams.OverdraftDI.OverdraftDetailDIs[i];
var overdraftDetail = _mapper.Map <OverdraftDetailDI, OverdraftDetail>(detailDI);
overdraftDetail.ConceptPayment = fixFormulasConceptPayment(_mapper.Map <ConceptPaymentDI, ConceptPayment>(detailDI.ConceptPaymentDI), dataResponse);
dataResponse.Overdraft.OverdraftDetails.Add(overdraftDetail);
}
}
else
{
dataResponse.Overdraft.OverdraftDetails = new List <OverdraftDetail>();
dataResponse.ConceptPayments.Where(p => p.GlobalAutomatic).ForEach(p =>
{
var overdraftDetail = new OverdraftDetail()
{
ConceptPayment = p,
ConceptPaymentID = p.ID,
ID = Guid.NewGuid()
};
dataResponse.Overdraft.OverdraftDetails.Add(overdraftDetail);
});
}
//Neccesary
dataResponse.AccumulatedEmployees = new List <AccumulatedEmployee>();
dataResponse.AccumulatedTypes.ForEach(p =>
{
var accumulatedEmployee = new AccumulatedEmployee()
{
AccumulatedTypeID = p.ID,
AccumulatedType = p,
Employee = dataResponse.Overdraft.Employee,
InitialExerciseAmount = 0,
PreviousExerciseAccumulated = 0,
ExerciseFiscalYear = calculateOverdraftDIParams.OverdraftDI.PeriodDetailDI.PeriodDI.FiscalYear,
};
dataResponse.AccumulatedEmployees.Add(accumulatedEmployee);
});
//Other things
dataResponse.FonacotMovements = new List <FonacotMovement>();
dataResponse.HistoricAccumulatedEmployees = new List <HistoricAccumulatedEmployee>();
dataResponse.Incidents = new List <Incident>();
dataResponse.InfonavitMovements = new List <InfonavitMovement>();
dataResponse.Inhabilities = new List <Inhability>();
dataResponse.Vacations = new List <Vacation>();
return(dataResponse);
}
/// <summary>
/// Get Overdraft Data necesary for the calculations
/// </summary>
/// <param name="overdraftID"></param>
/// <param name="instanceID"></param>
/// <param name="identityWorkID"></param>
/// <returns></returns>
public async static Task <CalculationBaseResult> GetDataAsync(Guid?overdraftID, Guid instanceID, Guid identityWorkID)
{
Stopwatch stopwatchGetData = new Stopwatch();
stopwatchGetData.Start();
var calculationBaseResult = new CalculationBaseResult();
//validate OverdraftID
if (null == overdraftID || overdraftID == Guid.Empty)
{
return(calculationBaseResult);
}
//Get Overdraft and relationships
var overdraftDetailManager = new MiddlewareManager <Overdraft>(new BaseRecordManager <Overdraft>(), new OverdraftValidator());
var overdrafts = await overdraftDetailManager.FindByExpressionAsync(p =>
p.ID == overdraftID &&
p.InstanceID == instanceID &&
p.company == identityWorkID &&
p.Active,
identityWorkID, new string[] {
"OverdraftDetails",
"OverdraftDetails.ConceptPayment",
"PeriodDetail",
"PeriodDetail.Period",
"Employee",
"Employee.Workshift",
"Employee.HistoricEmployeeSalaryAdjustments",
"Employee.HistoricEmployeeSBCAdjustments"
});
Trace.WriteLine($"Get overdraft data elapsed time: {stopwatchGetData.Elapsed}");
//validate overdrafts
if (!overdrafts.Any())
{
return(calculationBaseResult);
}
var overdraft = overdrafts.AsParallel().FirstOrDefault();
//Period variables
var periodDetailInitialDate = overdraft.PeriodDetail.InitialDate;
var periodDetailFinalDate = overdraft.PeriodDetail.FinalDate;
var periodDetailID = overdraft.PeriodDetailID;
var employeeID = overdraft.EmployeeID;
IEnumerable <Vacation> vacations = null;
IEnumerable <VacationDaysOff> vacationDaysOff = null;
IEnumerable <Incident> incidents = null;
IEnumerable <Inhability> inhabilities = null;
IEnumerable <MinimunSalary> minimunSalaries = null;
IEnumerable <UMA> umas = null;
IEnumerable <InfonavitMovement> infonavitMovements = null;
IEnumerable <SGDFLimits> sGDFLimits = null;
IEnumerable <IMSSEmployeeTable> iMSSEmployeeTables = null;
IEnumerable <IMSSEmployerTable> iMSSEmployerTables = null;
IEnumerable <IMSSWorkRisk> iMSSWorkRisks = null;
IEnumerable <HistoricAccumulatedEmployee> historicAccumulatedEmployees = null;
IEnumerable <SettlementCatalog> settlementCatalogs = null;
IEnumerable <MonthlyIncomeTax> monthlyIncomeTaxes = null;
IEnumerable <AnualIncomeTax> anualIncomeTaxes = null;
IEnumerable <MonthlyEmploymentSubsidy> monthlyEmploymentSubsidies = null;
IEnumerable <AnualEmploymentSubsidy> anualEmploymentSubsidies = null;
IEnumerable <FonacotMovement> fonacotMovements = null;
IEnumerable <IncidentType> incidentTypes = null;
IEnumerable <AccumulatedType> accumulatedTypes = null;
IEnumerable <ConceptPaymentRelationship> conceptPaymentRelationships = null;
IEnumerable <ConceptPayment> conceptPayments = null;
IEnumerable <EmployeeConceptsRelation> employeeConceptsRelations = null;
IEnumerable <InfonavitInsurance> infonavitInsurances = null;
IEnumerable <UMI> uMIs = null;
using (var conn = new SqlConnection(ConnectionManager.ConfigConnectionString))
{
if (conn.State != ConnectionState.Open)
{
await conn.OpenAsync();
}
SqlDataAdapter da = new SqlDataAdapter("GetRequiredOverdraftCalculationData", conn);
da.SelectCommand.Parameters.AddWithValue("@CompanyID", identityWorkID);
da.SelectCommand.Parameters.AddWithValue("@InstanceID", instanceID);
da.SelectCommand.Parameters.AddWithValue("@EmployeeID", employeeID);
da.SelectCommand.Parameters.AddWithValue("@PeriodDetailID", periodDetailID);
da.SelectCommand.Parameters.AddWithValue("@PeriodDetailInitialDate", periodDetailInitialDate);
da.SelectCommand.Parameters.AddWithValue("@PeriodDetailFinalDate", periodDetailFinalDate);
da.SelectCommand.CommandType = CommandType.StoredProcedure;
DataSet ds = new DataSet();
da.Fill(ds);
vacations = DataTableUtil.ConvertDataTable <Vacation>(ds.Tables[0]);
incidents = DataTableUtil.ConvertDataTable <Incident>(ds.Tables[1]);
inhabilities = DataTableUtil.ConvertDataTable <Inhability>(ds.Tables[2]);
minimunSalaries = DataTableUtil.ConvertDataTable <MinimunSalary>(ds.Tables[3]);
umas = DataTableUtil.ConvertDataTable <UMA>(ds.Tables[4]);
infonavitMovements = DataTableUtil.ConvertDataTable <InfonavitMovement>(ds.Tables[5]);
sGDFLimits = DataTableUtil.ConvertDataTable <SGDFLimits>(ds.Tables[6]);
iMSSEmployeeTables = DataTableUtil.ConvertDataTable <IMSSEmployeeTable>(ds.Tables[7]);
iMSSEmployerTables = DataTableUtil.ConvertDataTable <IMSSEmployerTable>(ds.Tables[8]);
iMSSWorkRisks = DataTableUtil.ConvertDataTable <IMSSWorkRisk>(ds.Tables[9]);
historicAccumulatedEmployees = DataTableUtil.ConvertDataTable <HistoricAccumulatedEmployee>(ds.Tables[10]);
settlementCatalogs = DataTableUtil.ConvertDataTable <SettlementCatalog>(ds.Tables[11]);
monthlyIncomeTaxes = DataTableUtil.ConvertDataTable <MonthlyIncomeTax>(ds.Tables[12]);
anualIncomeTaxes = DataTableUtil.ConvertDataTable <AnualIncomeTax>(ds.Tables[13]);
monthlyEmploymentSubsidies = DataTableUtil.ConvertDataTable <MonthlyEmploymentSubsidy>(ds.Tables[14]);
anualEmploymentSubsidies = DataTableUtil.ConvertDataTable <AnualEmploymentSubsidy>(ds.Tables[15]);
fonacotMovements = DataTableUtil.ConvertDataTable <FonacotMovement>(ds.Tables[16]);
incidentTypes = DataTableUtil.ConvertDataTable <IncidentType>(ds.Tables[17]);
accumulatedTypes = DataTableUtil.ConvertDataTable <AccumulatedType>(ds.Tables[18]);
conceptPaymentRelationships = DataTableUtil.ConvertDataTable <ConceptPaymentRelationship>(ds.Tables[19]);
conceptPayments = DataTableUtil.ConvertDataTable <ConceptPayment>(ds.Tables[20]);
vacationDaysOff = DataTableUtil.ConvertDataTable <VacationDaysOff>(ds.Tables[21]);
employeeConceptsRelations = DataTableUtil.ConvertDataTable <EmployeeConceptsRelation>(ds.Tables[22]);
infonavitInsurances = DataTableUtil.ConvertDataTable <InfonavitInsurance>(ds.Tables[23]);
uMIs = DataTableUtil.ConvertDataTable <UMI>(ds.Tables[24]);
}
Parallel.ForEach(vacations, vacation =>
{
var vacationDayOff = vacationDaysOff.Where(p => p.VacationID == vacation.ID);
if (vacationDayOff.Any())
{
vacation.VacationDaysOff.AddRange(vacationDayOff);
}
});
Parallel.ForEach(fonacotMovements, fonacotMovement =>
{
fonacotMovement.EmployeeConceptsRelation = employeeConceptsRelations.FirstOrDefault(p => p.ID == fonacotMovement.EmployeeConceptsRelationID);
});
Parallel.ForEach(incidents, incident =>
{
incident.IncidentType = incidentTypes.FirstOrDefault(p => p.ID == incident.IncidentTypeID);
});
Parallel.ForEach(inhabilities, inhability =>
{
inhability.IncidentType = incidentTypes.FirstOrDefault(p => p.ID == inhability.IncidentTypeID);
});
Parallel.ForEach(historicAccumulatedEmployees, accumulatedEmployee =>
{
accumulatedEmployee.AccumulatedType = accumulatedTypes.FirstOrDefault(p => p.ID == accumulatedEmployee.AccumulatedTypeID);
});
Parallel.ForEach(conceptPaymentRelationships, conceptPaymentRelationship =>
{
conceptPaymentRelationship.AccumulatedType = accumulatedTypes.FirstOrDefault(p => p.ID == conceptPaymentRelationship.AccumulatedTypeID);
});
//Prepare data
calculationBaseResult.Overdraft = overdraft;
calculationBaseResult.Vacations = vacations;
calculationBaseResult.Incidents = incidents;
calculationBaseResult.Inhabilities = inhabilities;
calculationBaseResult.MinimunSalaries = minimunSalaries;
calculationBaseResult.SGDFLimits = sGDFLimits;
calculationBaseResult.UMAs = umas;
calculationBaseResult.InfonavitMovements = infonavitMovements;
calculationBaseResult.IMSSEmployeeTables = iMSSEmployeeTables;
calculationBaseResult.IMSSEmployerTables = iMSSEmployerTables;
calculationBaseResult.IMSSWorkRisks = iMSSWorkRisks;
calculationBaseResult.HistoricAccumulatedEmployees = historicAccumulatedEmployees;
calculationBaseResult.SettlementCatalogs = settlementCatalogs;
calculationBaseResult.MonthlyIncomeTaxes = monthlyIncomeTaxes;
calculationBaseResult.AnualIncomeTaxes = anualIncomeTaxes;
calculationBaseResult.MonthlyEmploymentSubsidies = monthlyEmploymentSubsidies;
calculationBaseResult.AnualEmploymentSubsidies = anualEmploymentSubsidies;
calculationBaseResult.FonacotMovements = fonacotMovements;
calculationBaseResult.ConceptPaymentRelationships = conceptPaymentRelationships;
calculationBaseResult.ConceptPayments = conceptPayments;
calculationBaseResult.InfonavitInsurances = infonavitInsurances;
calculationBaseResult.UMIs = uMIs;
//track elapsed time
stopwatchGetData.Stop();
Trace.WriteLine($"GetData elapsed time: {stopwatchGetData.Elapsed}");
return(calculationBaseResult);
}
