public LimitsApplicationResult Apply(CaseServiceCostSplit caseService)
{
if (_policyVersion == null)
{
return(LimitsApplicationResult.NoApplied());
}
var limit = _policyVersion.LimitFor(caseService.ServiceCode);
if (limit == null)
{
return(LimitsApplicationResult.NoApplied());
}
var limitConsumptionContainer = FindOrCreateMatchingConsumptionContainer(caseService, limit);
var limitCalculation = limit.Calculate
(
caseService,
limitConsumptionContainer.CurrentConsumption()
);
limitConsumptionContainer.ReserveLimitsFor(caseService, limitCalculation.LimitConsumption, 0);
return(LimitsApplicationResult.Applied(limitCalculation));
}
public Consumption(LimitConsumptionContainer consumptionContainer, CaseServiceCostSplit caseService)
{
ConsumptionContainer = consumptionContainer;
ServiceId = caseService.CaseServiceId;
CaseNumber = caseService.CaseNumber;
ConsumptionDate = caseService.Date;
ConsumedAmount = caseService.AmountLimitConsumption;
ConsumedQuantity = caseService.QtLimitConsumption;
}
public CoPaymentApplicationResult Apply(CaseServiceCostSplit caseService)
{
if (policyAtServiceDate == null)
{
return(CoPaymentApplicationResult.NotApplied());
}
var coPayment = policyAtServiceDate.CoPaymentFor(caseService.ServiceCode);
if (coPayment == null)
{
return(CoPaymentApplicationResult.NotApplied());
}
var amount = coPayment.Calculate(caseService);
return(CoPaymentApplicationResult.Applied(amount));
}
public CoverageCheckResult Apply(CaseServiceCostSplit caseService)
{
if (policyAtServiceDate == null)
{
return(CoverageCheckResult.NotCovered(NotCoveredReason.NoPolicyAtServiceDate, caseService));
}
if (!policyAtServiceDate.CoversInsured(caseService.InsuredId))
{
return(CoverageCheckResult.NotCovered(NotCoveredReason.InsuredNotFoundOnPolicy, caseService));
}
if (!policyAtServiceDate.CoversService(caseService.ServiceCode))
{
return(CoverageCheckResult.NotCovered(NotCoveredReason.ServiceNotFoundOnPolicy, caseService));
}
return(CoverageCheckResult.FullyCovered());
}
private LimitConsumptionContainer FindOrCreateMatchingConsumptionContainer(CaseServiceCostSplit caseService,
Limit limit)
{
var consumptionPeriod = limit.CalculatePeriod(caseService.Date, _policyVersion);
var limitConsumptionContainer = _limitConsumptionContainers.GetLimitConsumptionContainer
(
caseService,
limit,
consumptionPeriod
);
if (limitConsumptionContainer == null)
{
limitConsumptionContainer =
new LimitConsumptionContainerFactory().Create(caseService, limit, consumptionPeriod);
_limitConsumptionContainers.Add(limitConsumptionContainer);
}
return(limitConsumptionContainer);
}
public abstract LimitCalculation Calculate(CaseServiceCostSplit costSplit,
(Money, int) currentLimitConsumptionContainer);
public static CoverageCheckResult NotCovered(NotCoveredReason notCoveredReason, CaseServiceCostSplit caseService)
{
return(new CoverageCheckResult(false, notCoveredReason, caseService.TotalCost));
}
public void ReserveLimitsFor(CaseServiceCostSplit caseService, Money amountConsumption, int qtConsumption)
{
ReserveLimitsFor(caseService.CaseNumber, caseService.CaseServiceId, caseService.Date, amountConsumption, qtConsumption);
}
