/// <summary>
/// Determines whether [is alpha numeric codes exists] [the specified contract code].
/// </summary>
/// <param name="contractCode">The contract code.</param>
/// <param name="condition">The condition.</param>
/// <param name="conditionOperation">The condition operation.</param>
/// <param name="isHcpcsCode">if set to <c>true</c> [is HCPCS code].</param>
/// <returns></returns>
private bool IsAlphaNumericCodesExists(ConditionRange contractCode, ICondition condition,
Enums.ConditionOperation conditionOperation, bool isHcpcsCode = false)
{
IEnumerable <string> claimCodes = condition.LeftOperands;
//Default flag to false
bool isValid = false;
var enumerable = claimCodes == null ? new List <string>() : claimCodes.ToList();
var emptyCodes = enumerable.ToList().Any(string.IsNullOrEmpty);
if (emptyCodes && conditionOperation == Enums.ConditionOperation.NotEqualTo)
{
isValid = true;
}
else if (!(emptyCodes && conditionOperation == Enums.ConditionOperation.EqualTo))
{
foreach (string claimCode in enumerable.Select(code => code.ToLower()))
{
isValid = IsClaimCodeExist(conditionOperation, claimCode, contractCode, isHcpcsCode);
//Break loop is condition is not valid
if (Utilities.IsConditionNotValid(isValid, conditionOperation))
{
break;
}
}
}
return(isValid);
}
/// <summary>
/// Gets the maximum length.
/// </summary>
/// <param name="contractCode">The contract codes.</param>
/// <returns></returns>
private static int GetMaxLength(ConditionRange contractCode)
{
int maxLength = 0;
if (contractCode != null)
{
maxLength = Math.Max(contractCode.StartValue.Length,
contractCode.EndValue == null ? 0 : contractCode.EndValue.Length);
}
return(maxLength);
}
/// <summary>
/// Determines whether [is valid length] [the specified contract codes].
/// </summary>
/// <param name="contractCodes">The contract codes.</param>
/// <param name="claimCodes">The claim codes.</param>
/// <param name="conditionOperation">The condition operation.</param>
/// <returns></returns>
public static bool IsValidLength(ConditionRange contractCodes, IEnumerable <string> claimCodes,
Enums.ConditionOperation conditionOperation)
{
if (claimCodes != null)
{
//Match claim code's length with maximum of all contract codes
return((from item in claimCodes
let length = GetMaxLength(contractCodes)
where
conditionOperation == Enums.ConditionOperation.GreaterThan && item.Length >= length ||
conditionOperation == Enums.ConditionOperation.LessThan && item.Length <= length
select item).Any());
}
return(false);
}
/// <summary>
/// Pads the condition ranges.
/// </summary>
/// <param name="conditionRange">The condition range.</param>
/// <returns></returns>
public static ConditionRange PadConditionRange(ConditionRange conditionRange)
{
if (conditionRange != null)
{
//Get Max length from condition ranges
int maxlength = GetMaxLength(conditionRange);
//Pads left with spaces to make all items of same size
if (conditionRange.StartValue != null)
{
conditionRange.StartValue = conditionRange.StartValue.PadLeft(maxlength);
}
if (conditionRange.EndValue != null)
{
conditionRange.EndValue = conditionRange.EndValue.PadLeft(maxlength);
}
}
return(conditionRange);
}
/// <summary>
/// Pads the left to code.
/// </summary>
/// <param name="claimCodes">The claim codes.</param>
/// <param name="conditionRange">The condition range.</param>
public static void PadLeftToCode(List <string> claimCodes, ConditionRange conditionRange)
{
if (claimCodes != null && claimCodes.Count > 0 && conditionRange != null)
{
int maxLength = Math.Max(GetMaxLength(conditionRange), claimCodes.Max(claimCode => claimCode.Length));
//Pads left with spaces to make all items of same size
conditionRange.StartValue = conditionRange.StartValue.PadLeft(maxLength);
if (conditionRange.EndValue != null)
{
conditionRange.EndValue = conditionRange.EndValue.PadLeft(maxLength);
}
//Pads left with spaces to make all items of same size
for (int claimCodesIndex = 0; claimCodesIndex < claimCodes.Count; claimCodesIndex++)
{
claimCodes[claimCodesIndex] = claimCodes[claimCodesIndex].PadLeft(maxLength);
}
}
}
/// <summary>
/// Determines whether [is alphanumeric codes] [the specified condition].
/// </summary>
/// <param name="condition">The condition.</param>
/// <returns></returns>
private bool IsAlphanumericCodes(ICondition condition)
{
bool isValid = false;
bool isHcpcsCode = false;
//Update Code if Condition is set as Include Modifier
if (condition.PropertyColumnName == Constants.PropertyHcpcsCodeWithModifier)
{
condition.LeftOperands = UpdateCodeWithIncludeModifier(condition.LeftOperands);
condition.RightOperand = string.Join(Constants.Comma,
UpdateCodeWithIncludeModifier(new List <string> {
condition.RightOperand
}));
isHcpcsCode = true;
}
if (condition.PropertyColumnName == Constants.PropertyPriPayerName)
{
foreach (ConditionRange conditionRange in Utilities.GetRangesForPriPayerName(condition.RightOperand))
{
Enums.ConditionOperation conditionOperation = (Enums.ConditionOperation)condition.ConditionOperator;
//Check length is valid or not
isValid = Utilities.IsValidLength(conditionRange, condition.LeftOperands, conditionOperation);
if (!(!isValid && (conditionOperation == Enums.ConditionOperation.GreaterThan ||
conditionOperation == Enums.ConditionOperation.LessThan)))
{
//Pads left with spaces to make all items of same size
ConditionRange padConditionRange = Utilities.PadConditionRange(conditionRange);
Utilities.PadLeftToCode(condition.LeftOperands, padConditionRange);
isValid = IsAlphaNumericCodesExists(padConditionRange, condition,
conditionOperation);
}
//Break loop is condition is not valid
if (Utilities.IsConditionNotValid(isValid, conditionOperation))
{
break;
}
}
}
else
{
foreach (ConditionRange conditionRange in Utilities.GetRanges(condition.RightOperand))
{
Enums.ConditionOperation conditionOperation = (Enums.ConditionOperation)condition.ConditionOperator;
//Check length is valid or not
isValid = Utilities.IsValidLength(conditionRange, condition.LeftOperands, conditionOperation);
if (!(!isValid && (conditionOperation == Enums.ConditionOperation.GreaterThan ||
conditionOperation == Enums.ConditionOperation.LessThan)))
{
//Pads left with spaces to make all items of same size
ConditionRange padConditionRange = Utilities.PadConditionRange(conditionRange);
Utilities.PadLeftToCode(condition.LeftOperands, padConditionRange);
isValid = IsAlphaNumericCodesExists(padConditionRange, condition,
conditionOperation, isHcpcsCode);
}
//Break loop is condition is not valid
if (Utilities.IsConditionNotValid(isValid, conditionOperation))
{
break;
}
}
}
return(isValid);
}
/// <summary>
/// Determines whether [is claim code exist] [the specified condition operation].
/// </summary>
/// <param name="conditionOperation">The condition operation.</param>
/// <param name="claimCode">The claim code.</param>
/// <param name="conditionRange">The condition range.</param>
/// <param name="isHcpcsCode">if set to <c>true</c> [is HCPCS code].</param>
/// <returns></returns>
private bool IsClaimCodeExist(Enums.ConditionOperation conditionOperation, string claimCode, ConditionRange conditionRange, bool isHcpcsCode = false)
{
bool isValid = false;
switch (conditionOperation)
{
case Enums.ConditionOperation.EqualTo:
//If the claimcode is HCPCS, then claimcode will be considered as just first five characters of it.
isValid = conditionRange.EndValue != null
? isHcpcsCode && claimCode.Trim() != string.Empty? (String.CompareOrdinal(claimCode.Trim().Length >= 5 ? claimCode.Trim().Substring(0, 5) : claimCode,
conditionRange.StartValue.Trim().Length > 5 ? conditionRange.StartValue.Trim().Substring(0, 5) : conditionRange.StartValue.Trim()) >= 0 &&
String.CompareOrdinal(claimCode.Trim().Length >= 5 ? claimCode.Trim().Substring(0, 5) : claimCode,
conditionRange.EndValue.Trim().Length > 5 ? conditionRange.EndValue.Trim().Substring(0, 5) : conditionRange.EndValue.Trim()) <= 0) : (String.CompareOrdinal(claimCode,
conditionRange.StartValue) >= 0 &&
String.CompareOrdinal(claimCode,
conditionRange.EndValue) <= 0)
: (conditionRange.StartValue.Contains(Constants.WildCard) && claimCode != null
? new RegexHelper(conditionRange.StartValue.Trim().Length >= 5? conditionRange.StartValue.Trim().Substring(0, 5).Replace(@"\", Constants.RegexHash): conditionRange.StartValue.Trim().Replace(@"\", "#")).IsMatch(
isHcpcsCode && claimCode.Trim().Length > 5 ? claimCode.Trim().Substring(0, 5).Replace(@"\", Constants.RegexHash) : claimCode.Trim().Replace(@"\", Constants.RegexHash))
: String.CompareOrdinal(claimCode, conditionRange.StartValue) == 0);
if (!isValid && !string.IsNullOrWhiteSpace(claimCode) && isHcpcsCode && claimCode.Trim().Length > 5 && !conditionRange.StartValue.Contains(Constants.WildCard))
{
string claimCodeHcpcs = claimCode.Trim().Substring(0, 5);
isValid = conditionRange.EndValue != null
? String.CompareOrdinal(claimCodeHcpcs,
conditionRange.StartValue) >= 0 &&
String.CompareOrdinal(claimCodeHcpcs,
conditionRange.EndValue) <= 0
: (conditionRange.StartValue.Contains(Constants.WildCard)
? new RegexHelper(conditionRange.StartValue.Trim().Replace(@"\", Constants.RegexHash)).IsMatch(
claimCodeHcpcs.Replace(@"\", Constants.RegexHash))
: String.CompareOrdinal(claimCodeHcpcs,
conditionRange.StartValue.Trim()) == 0);
}
break;
case Enums.ConditionOperation.GreaterThan:
isValid = String.CompareOrdinal(claimCode,
conditionRange.StartValue) > 0;
break;
case Enums.ConditionOperation.LessThan:
isValid = conditionRange.EndValue != null
? String.CompareOrdinal(claimCode
, conditionRange.EndValue) < 0
: String.CompareOrdinal(claimCode,
conditionRange.StartValue) < 0;
break;
case Enums.ConditionOperation.NotEqualTo:
claimCode = claimCode.Trim();
isValid = conditionRange.EndValue != null
? !(String.CompareOrdinal(claimCode,
conditionRange.StartValue.Trim()) >= 0 &&
String.CompareOrdinal(claimCode,
conditionRange.EndValue.Trim()) <= 0)
: (conditionRange.StartValue.Contains(Constants.WildCard)
? !new RegexHelper(conditionRange.StartValue.Trim().Replace(@"\", Constants.RegexHash)).IsMatch(
claimCode.Replace(@"\", Constants.RegexHash))
: String.CompareOrdinal(claimCode, conditionRange.StartValue.Trim()) != 0);
if (isValid && !string.IsNullOrWhiteSpace(claimCode) && isHcpcsCode && claimCode.Length > 5)
{
string claimCodeHcpcs = claimCode.Substring(0, 5);
isValid = conditionRange.EndValue != null
? !(String.CompareOrdinal(claimCodeHcpcs,
conditionRange.StartValue) >= 0 &&
String.CompareOrdinal(claimCodeHcpcs,
conditionRange.EndValue) <= 0)
: (conditionRange.StartValue.Contains(Constants.WildCard)
? !new RegexHelper(conditionRange.StartValue.Trim().Replace(@"\", Constants.RegexHash)).IsMatch(
claimCodeHcpcs.Replace(@"\", Constants.RegexHash))
: String.CompareOrdinal(claimCodeHcpcs, conditionRange.StartValue.Trim()) != 0);
}
break;
case Enums.ConditionOperation.Contains:
isValid = claimCode.Trim().Contains(conditionRange.StartValue.Trim());
break;
}
return(isValid);
}
/// <summary>
/// Determines whether [is code exist] [the specified condition operation].
/// </summary>
/// <param name="conditionOperation">The condition operation.</param>
/// <param name="claimCode">The claim code.</param>
/// <param name="conditionRange">The condition range.</param>
/// <returns></returns>
private bool IsCodeExist(Enums.ConditionOperation conditionOperation, string claimCode, ConditionRange conditionRange)
{
bool isValid = false;
double numericCode;
double numericStartValue;
if (Double.TryParse(claimCode, out numericCode) && Double.TryParse(conditionRange.StartValue, out numericStartValue))
{
double numericEndValue;
switch (conditionOperation)
{
case Enums.ConditionOperation.EqualTo:
isValid = conditionRange.EndValue != null
? Double.TryParse(conditionRange.EndValue, out numericEndValue) &&
(numericCode >= numericStartValue) &&
(numericCode <= numericEndValue)
: numericCode.Equals(numericStartValue);
break;
case Enums.ConditionOperation.GreaterThan:
isValid = numericCode > numericStartValue;
break;
case Enums.ConditionOperation.LessThan:
isValid = numericCode < numericStartValue;
break;
case Enums.ConditionOperation.NotEqualTo:
isValid = conditionRange.EndValue != null
? Double.TryParse(conditionRange.EndValue, out numericEndValue) &&
!((numericCode >= numericStartValue) &&
(numericCode <= numericEndValue))
: !numericCode.Equals(numericStartValue);
break;
}
}
else if (conditionRange.StartValue.Contains('*') && claimCode != null && conditionRange.EndValue == null)
{
switch (conditionOperation)
{
case Enums.ConditionOperation.EqualTo:
isValid =
new RegexHelper(conditionRange.StartValue.Trim().Replace(@"\", "#")).IsMatch(claimCode.Trim().Replace(
@"\", "#"));
break;
case Enums.ConditionOperation.NotEqualTo:
isValid =
!new RegexHelper(conditionRange.StartValue.Trim().Replace(@"\", "#")).IsMatch(
claimCode.Trim().Replace(@"\", "#"));
break;
}
}
return(isValid);
}
