public override List <PaymentResult> EvaluatePaymentType(IEvaluateableClaim claim, List <PaymentResult> paymentResults, bool isCarveOut, bool isContractFilter)
{
if (claim != null)
{
foreach (ClaimCharge claimCharge in claim.ClaimCharges.Where(code => (!string.IsNullOrWhiteSpace(code.HcpcsCodeWithModifier.Trim()))))
{
if (isCarveOut && paymentResults.Any(currentPaymentResult => currentPaymentResult.Line == claimCharge.Line && currentPaymentResult.ServiceTypeId == PaymentTypeBase.ServiceTypeId))
{
break;
}
if (PaymentTypeBase.ValidLineIds.Contains(claimCharge.Line) && paymentResults.Any(
currentPaymentResult => currentPaymentResult.Line == claimCharge.Line && (currentPaymentResult.AdjudicatedValue == null || isCarveOut)))
{
PaymentResult paymentResult = GetPaymentResult(paymentResults, isCarveOut, claimCharge.Line);
if (paymentResult != null)
{
EvaluateLine(paymentResult, claimCharge);
}
}
}
}
return(paymentResults);
}
public override List <PaymentResult> EvaluatePaymentType(IEvaluateableClaim claim,
List <PaymentResult> paymentResults, bool isCarveOut, bool isContractFilter)
{
if (PaymentTypeMedicareOp != null)
{
if (isCarveOut ||
(PaymentTypeMedicareOp.PayAtClaimLevel &&
!paymentResults.Any(
currentPaymentResult => currentPaymentResult.Line == null && currentPaymentResult.ServiceTypeId == PaymentTypeMedicareOp.ServiceTypeId)) ||
(!PaymentTypeMedicareOp.PayAtClaimLevel && paymentResults.Any(
currentPaymentResult =>
currentPaymentResult.Line != null &&
PaymentTypeMedicareOp.ValidLineIds.Contains(currentPaymentResult.Line.Value) &&
currentPaymentResult.AdjudicatedValue == null)))
{
if (PaymentTypeMedicareOp != null)
{
MedicareOutPatientResult medicareOutPatientResult = GetMedicareOutPatientResult(claim);
paymentResults = PaymentTypeMedicareOp.PayAtClaimLevel
? EvaluateAtClaimLevel(paymentResults, medicareOutPatientResult, isCarveOut)
: EvaluateAtLineLevel(claim, paymentResults, isCarveOut, medicareOutPatientResult);
}
}
}
return(paymentResults);
}
public override List <PaymentResult> EvaluatePaymentType(IEvaluateableClaim claim,
List <PaymentResult> paymentResults, bool isCarveOut, bool isContractFilter)
{
MedicareInPatientResult medicareInPatientResult = GetMedicareInPatientResult(claim);
var claimPaymentResult = GetClaimLevelPaymentResult(paymentResults, isCarveOut);
if (claimPaymentResult != null && medicareInPatientResult != null)
{
//Update PaymentResult and set matching ServiceTypeId,PaymentTypeDetailId & PaymentTypeId
Utilities.UpdatePaymentResult(claimPaymentResult, PaymentTypeMedicareIp.ServiceTypeId,
PaymentTypeMedicareIp.PaymentTypeDetailId, PaymentTypeMedicareIp.PaymentTypeId);
if (medicareInPatientResult.IsSucess)
{
if (PaymentTypeMedicareIp.InPatient.HasValue)
{
claimPaymentResult.AdjudicatedValue = (PaymentTypeMedicareIp.InPatient.Value / 100) *
medicareInPatientResult.TotalPaymentAmount;
claimPaymentResult.ClaimStatus = (byte)Enums.AdjudicationOrVarianceStatuses.Adjudicated;
}
else
{
claimPaymentResult.ClaimStatus =
(byte)Enums.AdjudicationOrVarianceStatuses.AdjudicationErrorInvalidPaymentData;
}
}
else
{
claimPaymentResult.ClaimStatus = (byte)Enums.AdjudicationOrVarianceStatuses.ClaimDataError;
}
}
return(paymentResults);
}
public override List <PaymentResult> EvaluatePaymentType(IEvaluateableClaim claim,
List <PaymentResult> paymentResults, bool isCarveOut, bool isContractFilter)
{
UpdateThresholdAndCaa(claim, paymentResults, isContractFilter);
if (isContractFilter)
{
ApplyContractFilter(claim, paymentResults);
}
else if (PaymentTypeBase.ValidLineIds != null && PaymentTypeBase.ValidLineIds.Count > 0)
{
switch ((Enums.StopLossCondition)PaymentTypeStopLoss.StopLossConditionId)
{
case Enums.StopLossCondition.TotalChargeLines:
ApplyTotalChargeLines(claim, paymentResults, isCarveOut,
string.IsNullOrEmpty(PaymentTypeStopLoss.RevCode) &&
string.IsNullOrEmpty(PaymentTypeStopLoss.HcpcsCode));
break;
case Enums.StopLossCondition.PerChargeLine:
ApplyPerChargeLine(claim, paymentResults, isCarveOut);
break;
case Enums.StopLossCondition.PerDayofStay:
ApplyPerDay(claim, paymentResults, isCarveOut);
break;
}
}
return(paymentResults);
}
public List <PaymentResult> Evaluate(IEvaluateableClaim claim, List <PaymentResult> paymentResults,
bool isCarveOut, bool isContractFilter)
{
//Get claim level payment result
PaymentResult overAllClaimPaymentResult = paymentResults.FirstOrDefault(
payment => payment.Line == null && payment.ServiceTypeId == null);
if (claim != null && !string.IsNullOrEmpty(claim.PriPayerName) &&
!string.IsNullOrEmpty(claim.BillType) && !string.IsNullOrEmpty(claim.ClaimState) &&
!string.IsNullOrEmpty(claim.ClaimType) && claim.StatementFrom.HasValue &&
claim.StatementThru.HasValue && claim.ClaimTotal.HasValue)
{
if (!(claim.ClaimCharges != null && claim.ClaimCharges.Any()) && overAllClaimPaymentResult != null)
{
overAllClaimPaymentResult.ClaimStatus =
(byte)Enums.AdjudicationOrVarianceStatuses.AdjudicationErrorMissingServiceLine;
}
}
else if (overAllClaimPaymentResult != null)
{
overAllClaimPaymentResult.ClaimStatus =
(byte)Enums.AdjudicationOrVarianceStatuses.ClaimDataError;
}
return(paymentResults);
}
public override List <PaymentResult> EvaluatePaymentType(IEvaluateableClaim claim,
List <PaymentResult> paymentResults, bool isCarveOut, bool isContractFilter)
{
var validPaymentResults = GetValidPaymentResults(claim, paymentResults, isCarveOut);
List <ClaimCharge> validCharges = new List <ClaimCharge>();
if (claim != null)
{
validCharges = (from charge in claim.ClaimCharges
from lineid in PaymentTypeAscFeeSchedule.ValidLineIds
where charge.Line == lineid
select charge).ToList();
}
List <ClaimFieldValue> validCodeAmounts = GetValidCodeAmounts(validCharges);
int order = 0;
foreach (var validCode in validCodeAmounts)
{
GetValidChargeAdjudicatedValue(validCode, validCharges, validPaymentResults, ref order);
}
ApplyingNfs(validCharges, validCodeAmounts, validPaymentResults);
List <PaymentResult> tempPaymentResults = paymentResults.Where(result => result.Line == null || !(!result.IsInitialEntry && result.ClaimStatus == (byte)Enums.AdjudicationOrVarianceStatuses.UnAdjudicated && result.ServiceTypeId == null && result.AdjudicatedValue == null)).ToList();
paymentResults = tempPaymentResults;
return(paymentResults);
}
/// <summary>
/// Updates the expanded expression.
/// </summary>
/// <param name="expression">The expression.</param>
/// <param name="claim">The claim.</param>
/// <param name="paymentTypeBase">The payment type base.</param>
/// <param name="occurence">The occurence.</param>
private static void UpdateExpandedExpression(string expression, IEvaluateableClaim claim,
PaymentTypeBase paymentTypeBase, int occurence)
{
if (occurence == 0)
{
paymentTypeBase.ExpandedExpression = Constants.ThresholdSmartBoxVariables.Where(
s => claim.SmartBox.GetType().GetProperty(s) != null)
.Aggregate(expression, (current, s) =>
current.Replace(s,
Convert.ToString(claim.SmartBox.GetType().GetProperty(s).GetValue(claim.SmartBox, null))));
}
else if (occurence > 0)
{
paymentTypeBase.MultiplierExpandedExpression = Constants.ThresholdSmartBoxVariables.Where(
s => claim.SmartBox.GetType().GetProperty(s) != null)
.Aggregate(expression, (current, s) =>
current.Replace(s,
Convert.ToString(claim.SmartBox.GetType().GetProperty(s).GetValue(claim.SmartBox, null))));
}
else
{
paymentTypeBase.LimitExpandedExpression = Constants.ThresholdSmartBoxVariables.Where(
s => claim.SmartBox.GetType().GetProperty(s) != null)
.Aggregate(expression, (current, s) =>
current.Replace(s,
Convert.ToString(claim.SmartBox.GetType().GetProperty(s).GetValue(claim.SmartBox, null))));
}
}
/// <summary>
/// Evaluates at claim level.
/// </summary>
/// <param name="claim">The claim.</param>
/// <param name="paymentResults">The payment result list.</param>
/// <param name="isCarveOut">if set to <c>true</c> [is carve out].</param>
/// <returns></returns>
private List <PaymentResult> EvaluateAtClaimLevel(IEvaluateableClaim claim, List <PaymentResult> paymentResults, bool isCarveOut)
{
if (paymentResults != null)
{
PaymentResult claimPaymentResult = GetClaimLevelPaymentResult(paymentResults, isCarveOut);
if (claimPaymentResult != null)
{
//Update PaymentResult and set matching ServiceTypeId,PaymentTypeDetailId & PaymentTypeId
Utilities.UpdatePaymentResult(claimPaymentResult, PaymentTypePercentageCharge.ServiceTypeId,
PaymentTypePercentageCharge.PaymentTypeDetailId, PaymentTypePercentageCharge.PaymentTypeId);
if (claim.ClaimTotal.HasValue)
{
claimPaymentResult.AdjudicatedValue = (PaymentTypePercentageCharge.Percentage / 100) *
claim.ClaimTotal.Value;
claimPaymentResult.ClaimStatus =
(byte)Enums.AdjudicationOrVarianceStatuses.Adjudicated;
}
else
{
claimPaymentResult.ClaimStatus =
(byte)Enums.AdjudicationOrVarianceStatuses.ClaimDataError;
}
}
}
return(paymentResults);
}
/// <summary>
/// Gets the multiplied formula value.
/// </summary>
/// <param name="claimPaymentResult">The claim payment result.</param>
/// <param name="claim">The claim.</param>
/// <param name="multiplierExpandedExpression">The mulpilier expanded expression.</param>
/// <param name="codeOccurence">The code occurence.</param>
/// <param name="formula">The formula.</param>
private void GetMultipliedFormulaValue(PaymentResult claimPaymentResult, IEvaluateableClaim claim,
string multiplierExpandedExpression, int codeOccurence, double?formula)
{
claimPaymentResult.AdjudicatedValue = (claimPaymentResult.AdjudicatedValue ?? 0) + (Utilities.EvaluateExpression(
multiplierExpandedExpression, claim,
PaymentTypeCustomTable, codeOccurence) * formula);
}
/// <summary>
/// Evaluates the claim at line level
/// </summary>
/// <param name="claim">details of the claim</param>
/// <param name="paymentResults">payment result</param>
/// <param name="isCarveOut">if the claim is carved out</param>
/// <returns>list of payment results</returns>
private List <PaymentResult> EvaluateLineLevel(IEvaluateableClaim claim, List <PaymentResult> paymentResults, bool isCarveOut)
{
List <CodeDetails> codeDetails = new List <CodeDetails>();
foreach (
ClaimCharge claimCharge in
claim.ClaimCharges.TakeWhile(claimCharge => !isCarveOut || !paymentResults.Any(
currentPaymentResult =>
currentPaymentResult.Line == claimCharge.Line &&
currentPaymentResult.ServiceTypeId == PaymentTypeBase.ServiceTypeId))
.Where(
claimCharge =>
PaymentTypeBase.ValidLineIds.Contains(claimCharge.Line) && paymentResults.Any(
currentPaymentResult =>
currentPaymentResult.Line == claimCharge.Line &&
(currentPaymentResult.AdjudicatedValue == null || isCarveOut))))
{
EvaluateLine(paymentResults, claim, claimCharge, isCarveOut, codeDetails);
}
if (PaymentTypeCustomTable.IsPerCode)
{
GroupLinesByCode(paymentResults);
}
else if (PaymentTypeCustomTable.IsPerDayOfStay)
{
GroupLinesByPerDayOfStay(paymentResults);
}
return(paymentResults);
}
/// <summary>
/// Calculates the adjudicated value.
/// </summary>
/// <param name="claimPaymentResult">The claim payment result.</param>
/// <param name="claim">The claim.</param>
/// <param name="codeDetailsList">The per day of stays.</param>
/// <param name="claimCharge">The claim charge.</param>
/// <param name="multiplierExpandedExpression">The multiplier expanded expression.</param>
/// <param name="claimFieldDocValueDictionary">The claim field document value dictionary.</param>
/// <param name="codeValue">The code value.</param>
/// <param name="codeOccurence">The code occurence.</param>
/// <param name="formula">The formula.</param>
/// <param name="isMultiplierExist">if set to <c>true</c> [is multiplier exist].</param>
private void CalculateAdjudicatedValue(PaymentResult claimPaymentResult, IEvaluateableClaim claim,
List <CodeDetails> codeDetailsList, ClaimCharge claimCharge, string multiplierExpandedExpression,
Dictionary <string, string> claimFieldDocValueDictionary, string codeValue, int codeOccurence, double?formula, bool isMultiplierExist)
{
multiplierExpandedExpression = GetExpandedExpression(claimFieldDocValueDictionary,
multiplierExpandedExpression);
if (PaymentTypeCustomTable.IsPerDayOfStay)
{
var perDayOfStay = codeDetailsList.FirstOrDefault(
p => p.Code == codeValue && p.Day == claimCharge.ServiceFromDate);
if (perDayOfStay != null)
{
GetMultipliedFormulaValue(claimPaymentResult, claim, multiplierExpandedExpression, codeOccurence, formula);
UpdateLimit(claimPaymentResult, codeDetailsList, claimCharge, codeValue, isMultiplierExist
);
}
claimPaymentResult.ServiceLineCode = codeValue;
claimPaymentResult.ClaimStatus = (byte)Enums.AdjudicationOrVarianceStatuses.Adjudicated;
Utilities.UpdateCustomTableDetails(claimPaymentResult, claim.SmartBox, PaymentTypeCustomTable, codeOccurence);
}
else
{
GetMultipliedFormulaValue(claimPaymentResult, claim, multiplierExpandedExpression, codeOccurence, formula);
UpdateLimit(claimPaymentResult, codeDetailsList, claimCharge, codeValue, isMultiplierExist);
claimPaymentResult.ServiceLineCode = codeValue;
claimPaymentResult.ClaimStatus = (byte)Enums.AdjudicationOrVarianceStatuses.Adjudicated;
Utilities.UpdateCustomTableDetails(claimPaymentResult, claim.SmartBox, PaymentTypeCustomTable, codeOccurence);
}
}
/// <summary>
/// Evaluate the total charge at claim level.
/// </summary>
/// <param name="claim">The claim.</param>
/// <param name="paymentResults">The payment results.</param>
/// <param name="isCarveOut">if set to <c>true</c> [is carve out].</param>
/// <returns></returns>
private void EvaluateTotalChargeAtClaimLevel(IEvaluateableClaim claim,
List <PaymentResult> paymentResults, bool isCarveOut)
{
PaymentResult claimPaymentResult = paymentResults.Any(
result => result.ServiceTypeId == PaymentTypeStopLoss.ServiceTypeId && result.Line == null)
? paymentResults.FirstOrDefault(
result => result.ServiceTypeId == PaymentTypeStopLoss.ServiceTypeId && result.Line == null)
: GetClaimLevelPaymentResult(paymentResults, isCarveOut);
if (claimPaymentResult != null)
{
if (claim.ClaimTotal.HasValue)
{
claimPaymentResult = GetTotalLinesValue(claimPaymentResult, claim.ClaimTotal, claim);
Utilities.UpdateStopLossDetails(claimPaymentResult, claim.SmartBox, PaymentTypeStopLoss, PaymentTypeStopLoss.IsFormulaError);
//Remove PaymentResult if its not satisfied thresold condition
if (claimPaymentResult.AdjudicatedValue == null &&
claimPaymentResult.ClaimStatus == (byte)Enums.AdjudicationOrVarianceStatuses.UnAdjudicated)
{
paymentResults.Remove(claimPaymentResult);
}
}
claimPaymentResult.ServiceTypeId = PaymentTypeStopLoss.ServiceTypeId;
}
}
public override List <PaymentResult> EvaluatePaymentType(IEvaluateableClaim claim, List <PaymentResult> paymentResults, bool isCarveOut, bool isContractFilter)
{
if (claim != null)
{
foreach (ClaimCharge claimCharge in claim.ClaimCharges)
{
if (isCarveOut && paymentResults.Any(currentPaymentResult => currentPaymentResult.Line == claimCharge.Line && currentPaymentResult.ServiceTypeId == PaymentTypeBase.ServiceTypeId))
{
break;
}
if (PaymentTypeBase.ValidLineIds.Contains(claimCharge.Line) && paymentResults.Any(
paymentResult => paymentResult.Line == claimCharge.Line && (paymentResult.AdjudicatedValue == null || isCarveOut)))
{
PaymentResult paymentResult = GetPaymentResult(paymentResults, isCarveOut, claimCharge.Line);
if (paymentResult != null)
{
EvaluateLine(paymentResult, claimCharge, claim.MedicareLabFeeSchedules);
}
}
}
}
return(paymentResults);
}
/// <summary>
/// Applies the per day formula.
/// </summary>
/// <param name="groupCharge">The group charge.</param>
/// <param name="itemIndex">Index of the item.</param>
/// <param name="claim">The claim.</param>
/// <param name="paymentResult">The payment result.</param>
/// <returns></returns>
private int ApplyPerDayFormula(double?groupCharge, int itemIndex, IEvaluateableClaim claim, PaymentResult paymentResult)
{
if (itemIndex == 1)
{
if (PaymentTypeStopLoss.Threshold != null)
{
if (PaymentTypeStopLoss.Percentage != null)
{
paymentResult.AdjudicatedValue =
PaymentTypeStopLoss.IsExcessCharge
? ((groupCharge - PaymentTypeStopLoss.Threshold.Value) / 100) *
PaymentTypeStopLoss.Percentage.Value
: (PaymentTypeStopLoss
.Percentage.Value /
100) * groupCharge;
}
}
itemIndex++;
}
else
{
paymentResult.AdjudicatedValue = 0.0;
}
paymentResult.ClaimStatus =
(byte)Enums.AdjudicationOrVarianceStatuses.Adjudicated;
paymentResult.PaymentTypeId = (byte)Enums.PaymentTypeCodes.StopLoss;
paymentResult.ServiceTypeId = PaymentTypeStopLoss.ServiceTypeId;
Utilities.UpdateStopLossDetails(paymentResult, claim.SmartBox, PaymentTypeStopLoss,
PaymentTypeStopLoss.IsFormulaError);
return(itemIndex);
}
public override List <PaymentResult> EvaluatePaymentType(IEvaluateableClaim claim, List <PaymentResult> paymentResults, bool isCarveOut, bool isContractFilter)
{
PaymentResult claimPaymentResult = GetClaimLevelPaymentResult(paymentResults, isCarveOut);
if (claimPaymentResult != null)
{
Utilities.UpdatePaymentResult(claimPaymentResult, PaymentTypeDrg.ServiceTypeId,
PaymentTypeDrg.PaymentTypeDetailId, PaymentTypeDrg.PaymentTypeId);
ClaimFieldValue drgRate = PaymentTypeDrg.ClaimFieldDoc.ClaimFieldValues.Find(claimField => claimField.Identifier == claim.Drg);
if (drgRate != null)
{
double amount;
if (Double.TryParse(drgRate.Value, out amount))
{
claimPaymentResult.AdjudicatedValue = PaymentTypeDrg.BaseRate * amount;
}
else
{
//If value is not a double than give codeAmount as 0. And log the error for the same.
claimPaymentResult.AdjudicatedValue = 0;
Log.LogError(
string.Format(CultureInfo.InvariantCulture, Constants.ConversionFailedError, PaymentTypeDrg.ClaimFieldDoc.ClaimFieldDocId, drgRate.Value), Constants.BackgroundServiceUser);
}
}
else
{
claimPaymentResult.AdjudicatedValue = 0;
}
claimPaymentResult.ClaimStatus = (byte)Enums.AdjudicationOrVarianceStatuses.Adjudicated;
}
return(paymentResults);
}
/// <summary>
/// Calculates the per day.
/// </summary>
/// <param name="paymentResults">The payment results.</param>
/// <param name="groupCharge">The group charge.</param>
/// <param name="validPaymentResults">The valid payment results.</param>
/// <param name="claimCharge">The claimCharge.</param>
/// <param name="itemIndex">The itemIndex.</param>
/// <param name="claim"></param>
/// <returns></returns>
private int CalculatePerDay(ICollection <PaymentResult> paymentResults, double?groupCharge, IEnumerable <PaymentResult> validPaymentResults, ClaimCharge claimCharge,
int itemIndex, IEvaluateableClaim claim)
{
////Logic to apply stop loss
if (groupCharge > 0 &&
(PaymentTypeStopLoss.Threshold != null &&
groupCharge > PaymentTypeStopLoss.Threshold.Value &&
PaymentTypeStopLoss.Percentage != null))
{
PaymentResult paymentResult =
validPaymentResults.FirstOrDefault(
currentPaymentResult => currentPaymentResult.Line == claimCharge.Line && (currentPaymentResult.AdjudicatedValue == null || currentPaymentResult.ServiceTypeId == PaymentTypeStopLoss.ServiceTypeId));
if (paymentResult != null)
{
itemIndex = ApplyPerDayFormula(groupCharge, itemIndex, claim, paymentResult);
}
}
else
{
PaymentResult paymentResult =
validPaymentResults.FirstOrDefault(
x => x.Line == claimCharge.Line && x.AdjudicatedValue == null && !x.IsInitialEntry);
if (paymentResult != null)
{
paymentResults.Remove(paymentResult);
}
}
return(itemIndex);
}
/// <summary>
/// Applies the per day.
/// </summary>
/// <param name="claim">The claim.</param>
/// <param name="paymentResults">The payment results.</param>
/// <param name="isCarveOut">if set to <c>true</c> [is carve out].</param>
/// <returns></returns>
///
private void ApplyPerDay(IEvaluateableClaim claim,
List <PaymentResult> paymentResults, bool isCarveOut)
{
var validPaymentResults = GetValidPaymentResults(claim, paymentResults, isCarveOut);
List <int> days = GetDays();
List <ClaimCharge> validCharges = (from charge in claim.ClaimCharges
from lineId in PaymentTypeStopLoss.ValidLineIds
where charge.Line == lineId
select charge).ToList();
List <DateTime> serviceDates = validCharges.OrderBy(claimCharge => claimCharge.ServiceFromDate).Select(claimCharge => claimCharge.ServiceFromDate).Distinct().OrderBy(b => b).ToList();
List <DateTime> validServiceDates = GetValidDates(serviceDates, days);
if (PaymentTypeBase.ValidLineIds != null && PaymentTypeBase.ValidLineIds.Count > 0)
{
if (days.Any())
{
GetQualifiedAndNonQualifiedCharges(claim, paymentResults, validCharges, validServiceDates, validPaymentResults);
}
else
{
GetGroupedClaimCharges(claim, paymentResults, validCharges, validPaymentResults);
}
}
}
/// <summary>
/// Applies the type of the charges on payment.
/// </summary>
/// <param name="claim">The claim.</param>
/// <param name="paymentResults">The payment results.</param>
/// <param name="isCarveOut">if set to <c>true</c> [is carve out].</param>
/// <param name="claimCharge">The claim charge.</param>
/// <param name="lineId">The line identifier.</param>
private void ApplyChargesOnPaymentType(IEvaluateableClaim claim, List <PaymentResult> paymentResults, bool isCarveOut,
ClaimCharge claimCharge, int lineId)
{
if (PaymentTypeStopLoss.Threshold != null && (claimCharge != null &&
(PaymentTypeBase.ValidLineIds.Contains(
claimCharge.Line) && paymentResults.Any(
currentPaymentResult =>
currentPaymentResult.Line ==
claimCharge.Line &&
(currentPaymentResult.AdjudicatedValue ==
null || isCarveOut ||
currentPaymentResult.ServiceTypeId ==
PaymentTypeStopLoss.ServiceTypeId))) &&
claimCharge.Amount >
PaymentTypeStopLoss.Threshold.Value))
{
PaymentResult paymentResult = paymentResults.Any(
result =>
result.ServiceTypeId == PaymentTypeStopLoss.ServiceTypeId && result.Line == lineId)
? paymentResults.FirstOrDefault(
result =>
result.ServiceTypeId == PaymentTypeStopLoss.ServiceTypeId &&
result.Line == lineId)
: GetPaymentResult(paymentResults, isCarveOut, claimCharge.Line);
GetTotalLinesValue(paymentResult, claimCharge.Amount, claim);
}
}
public override List <PaymentResult> EvaluatePaymentType(IEvaluateableClaim claim, List <PaymentResult> paymentResults, bool isCarveOut, bool isContractFilter)
{
if (PaymentTypePerDiem.PayAtClaimLevel)
{
PaymentResult claimPaymentResult = GetClaimLevelPaymentResult(paymentResults, isCarveOut);
if (claimPaymentResult != null && claim != null)
{
GetAdjudicatedValue(true, claimPaymentResult, claim.Los);
}
}
else
{
var validPaymentResults = GetValidPaymentResults(claim, paymentResults, isCarveOut);
if (claim != null)
{
List <ClaimCharge> validCharges = (from charge in claim.ClaimCharges
from lineId in PaymentTypePerDiem.ValidLineIds
where charge.Line == lineId
select charge).ToList();
foreach (var charge in validCharges)
{
PaymentResult paymentresult =
validPaymentResults.FirstOrDefault(
currentPaymentResult =>
currentPaymentResult.Line == charge.Line &&
currentPaymentResult.AdjudicatedValue == null);
if (paymentresult != null)
{
GetAdjudicatedValue((charge.Units.HasValue && charge.Units > 0), paymentresult, charge.Units);
}
}
}
}
return(paymentResults);
}
/// <summary>
/// Gets the current sellection.
/// </summary>
/// <param name="claim">The claim.</param>
/// <param name="paymentResults">The payment results.</param>
/// <param name="isRevCodeAvailable">if set to <c>true</c> [is rev code available].</param>
/// <param name="chargeData">The charge data.</param>
/// <param name="isCptCodeAvailable">if set to <c>true</c> [is CPT code available].</param>
/// <param name="validPaymentResults">The valid payment results.</param>
/// <returns></returns>
private List <PaymentResult> GetCurrentSelection(IEvaluateableClaim claim, List <PaymentResult> paymentResults, bool isRevCodeAvailable,
ClaimCharge chargeData, bool isCptCodeAvailable, IEnumerable <PaymentResult> validPaymentResults)
{
List <ClaimCharge> claimCharges = claim.ClaimCharges.Where(
currentClaimCharge =>
(!isRevCodeAvailable || chargeData.RevCode == currentClaimCharge.RevCode) &&
(!isCptCodeAvailable || chargeData.HcpcsCode == currentClaimCharge.HcpcsCode) &&
chargeData.ServiceFromDate == currentClaimCharge.ServiceFromDate &&
validPaymentResults.Select(currentPaymentType => currentPaymentType.Line)
.ToList()
.Contains(chargeData.Line)).ToList();
//Get valid line ids based on current rev/cpt/thrudate selection
List <int> lineItemWithCurrentSelection = claimCharges.Select(currentClaimCharge => currentClaimCharge.Line).ToList();
//Get Sum of Unit based on current rev/cpt/thrudate selection
int?unitSum = claimCharges.Sum(currentClaimCharge => currentClaimCharge.Units);
if (lineItemWithCurrentSelection.Any())
{
paymentResults = EvaluateWithMaxCases(paymentResults, claim,
lineItemWithCurrentSelection, unitSum);
}
return(paymentResults);
}
public override List <PaymentResult> EvaluatePaymentType(IEvaluateableClaim claim, List <PaymentResult> paymentResults, bool isCarveOut, bool isContractFilter)
{
paymentResults = isContractFilter
? ApplyContractFilter(paymentResults)
: ApplyCap(paymentResults);
return(paymentResults);
}
public List <PaymentResult> Evaluate(IEvaluateableClaim claim, List <PaymentResult> paymentResults,
bool isCarveOut, bool isContractFilter)
{
//Determines whether the specified claim is match and has matching lines id's
if (isContractFilter || IsMatch((claim)))
{
paymentResults = EvaluatePaymentType(claim, paymentResults, isCarveOut, isContractFilter);
}
return(paymentResults);
}
public override List <PaymentResult> EvaluatePaymentType(IEvaluateableClaim claim, List <PaymentResult> paymentResults, bool isCarveOut, bool isContractFilter)
{
if (claim != null)
{
claim.SmartBox.CAA = Utilities.CalculateAllowedAmount(paymentResults);
paymentResults = PaymentTypeCustomTable.ClaimFieldId == (byte)Enums.ClaimFieldTypes.RevenueCode || PaymentTypeCustomTable.ClaimFieldId == (byte)Enums.ClaimFieldTypes.HcpcsOrRateOrHipps || PaymentTypeCustomTable.ClaimFieldId == (byte)Enums.ClaimFieldTypes.PlaceOfService
? EvaluateLineLevel(claim, paymentResults, isCarveOut)
: EvaluateClaimLevel(claim, paymentResults, isCarveOut);
}
return(paymentResults);
}
protected void GetCarveOutPaymentResults(IEvaluateableClaim claim, List <PaymentResult> paymentResults, bool isCarveOut)
{
if (claim != null)
{
foreach (var claimCharge in claim.ClaimCharges.Where(claimCharge => PaymentTypeBase.ValidLineIds.Contains(claimCharge.Line) && paymentResults.Any(
currentPaymentResult =>
currentPaymentResult.Line == claimCharge.Line && (currentPaymentResult.AdjudicatedValue == null || isCarveOut))))
{
GetPaymentResult(paymentResults, isCarveOut, claimCharge.Line);
}
}
}
/// <summary>
/// Apply Stop loss at Total Charge Lines
/// </summary>
/// <param name="claim"></param>
/// <param name="paymentResults"></param>
/// <param name="isCarveOut"></param>
/// <param name="isClaimLevel"></param>
/// <returns></returns>
private void ApplyTotalChargeLines(IEvaluateableClaim claim,
List <PaymentResult> paymentResults, bool isCarveOut, bool isClaimLevel)
{
if (isClaimLevel)
{
EvaluateTotalChargeAtClaimLevel(claim, paymentResults, isCarveOut);
}
else
{
EvaluateTotalChargeAtLineLevel(claim, paymentResults, isCarveOut);
}
}
/// <summary>
/// Get list of payment results which matches with line id in Claim charge list
/// </summary>
/// <param name="claim"></param>
/// <param name="paymentResults"></param>
/// <param name="isCarveOut"></param>
/// <returns></returns>
private List <PaymentResult> GetValidPaymentResults(IEvaluateableClaim claim, List <PaymentResult> paymentResults,
bool isCarveOut)
{
GetCarveOutPaymentResults(claim, paymentResults, isCarveOut);
List <PaymentResult> validPaymentResults =
paymentResults.Where(
currentPaymentResult => currentPaymentResult.Line.HasValue &&
PaymentTypePerDiem.ValidLineIds.Contains(
currentPaymentResult.Line.Value) &&
currentPaymentResult.Line != null).ToList();
return(validPaymentResults);
}
/// <summary>
/// Evaluates at line level.
/// </summary>
/// <param name="claim">The claim.</param>
/// <param name="paymentResults">The payment results.</param>
/// <param name="isCarveOut">if set to <c>true</c> [is carve out].</param>
/// <returns></returns>
private List <PaymentResult> EvaluateAtLineLevel(IEvaluateableClaim claim, List <PaymentResult> paymentResults, bool isCarveOut)
{
if (PaymentTypePerCase.MaxCasesPerDay == null ||
PaymentTypePerCase.MaxCasesPerDay.Value == 0)
{
paymentResults = ApplyPerCaseWithoutMaxCases(claim, paymentResults, isCarveOut);
}
else
{
paymentResults = ApplyPerCaseWithMaxCases(claim, paymentResults, isCarveOut);
}
return(paymentResults);
}
/// <summary>
/// Evaluates the contract payment filter.
/// </summary>
/// <param name="claim">The claim.</param>
/// <param name="paymentResults">The payment result list.</param>
/// <returns></returns>
private List <PaymentResult> EvaluatePaymentFilter(IEvaluateableClaim claim,
List <PaymentResult> paymentResults)
{
foreach (PaymentTypeBase paymentType in Contract.PaymentTypes)
{
//Inject payment logics based on Payment type.
IPaymentTypeLogic paymentlogic = Factory.CreateInstance <IPaymentTypeLogic>(((Enums.PaymentTypeCodes)paymentType.PaymentTypeId).ToString());
paymentlogic.PaymentTypeBase = paymentType;
//Apply payment logic for each payment types. This will consider all charge line codes to match with contract codes
paymentResults = paymentlogic.Evaluate(claim, paymentResults, false, true);
}
return(paymentResults);
}
/// <summary>
/// Evaluates the type of the payment.
/// </summary>
/// <param name="claim">The claim.</param>
/// <param name="paymentResults">The payment result list.</param>
/// <param name="isCarveOut">if set to <c>true</c> [is carve out].</param>
/// <param name="isContractFilter">if set to <c>true</c> [is contract filter].</param>
/// <returns></returns>
public override List <PaymentResult> EvaluatePaymentType(IEvaluateableClaim claim, List <PaymentResult> paymentResults, bool isCarveOut, bool isContractFilter)
{
//Get Payment result for contract level
PaymentResult paymentResult = paymentResults.First();
if (paymentResult.AdjudicatedValue.HasValue && PaymentTypeMedicareSequester.Percentage.HasValue && claim.PatientResponsibility.HasValue)
{
double?allowedAmount = paymentResult.AdjudicatedValue - claim.PatientResponsibility;
paymentResult.MedicareSequesterAmount = allowedAmount * (PaymentTypeMedicareSequester.Percentage / Constants.MedicareSequesterPercentage);
paymentResult.AdjudicatedValue = allowedAmount - paymentResult.MedicareSequesterAmount + claim.PatientResponsibility;
}
return(paymentResults);
}
public List <PaymentResult> Evaluate(IEvaluateableClaim claim, List <PaymentResult> paymentResults,
bool isCarveOut, bool isContractFilter)
{
if (claim != null)
{
bool isEarlyExit = claim.LastAdjudicatedContractId == Contract.ContractId &&
claim.IsClaimAdjudicated;
//claim codes with contract codes
// ReSharper disable once PossibleNullReferenceException
if (claim.ContractId != null || (IsMatch(claim)))
{
//If the particular claim is adjudicated with the contract and contract is not modified after that, then the claim will go to the early exit skipping the adjudication
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (!isEarlyExit && claim != null && paymentResults != null)
{
//Update Contract Id into payment results
paymentResults.ForEach(paymentResult => paymentResult.ContractId = Contract.ContractId);
//Evaluate Service Type logic
paymentResults = EvaluateServiceType(claim, paymentResults, isCarveOut);
//update payment result(Over All adjudication amount/Status)
paymentResults = _paymentResultLogic.Evaluate(claim, paymentResults, false, false);
//Evaluate Contract level payment filter
paymentResults = EvaluatePaymentFilter(claim, paymentResults);
//Updates the Adjudicated Claim details
AdjudicateClaims.Add(new EvaluateableClaim
{
ClaimId = claim.ClaimId,
ContractId = Contract.ContractId
});
}
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
else
{
//Updates the Claim details for early exit claims
EarlyExitClaims.Add(new EvaluateableClaim
{
ClaimIds = Convert.ToString(claim.ClaimId),
ContractId = Contract.ContractId
});
// The claim is already adjucated then pass Payment result as null so it will not update in DB.
return(null);
}
}
}
return(paymentResults);
}
