///<summary>Updates the Voice Mail Origination path for this current computer. Returns true if the preference was changed.
///This is the ONLY PLACE where the VoiceMailOriginationPath preference should be modified.</summary>
public static bool UpdateVoiceMailOriginationPath(string path)
{
List <KeyValuePair <string, string> > listPaths;
try {
//The VoiceMailOriginationPath preference stores a list of KeyValuePairs where the key is the name of the computer and the value
//is the path. When JSON-serialized it looks like this:
//[{"Key":"SERVER153","Value":"\\\\110.10.6.249\\Voicemail\\default\\998\\INBOX"},{"Key":"CHRISM","Value":"C:\\development"}]
listPaths = JsonConvert.DeserializeObject <List <KeyValuePair <string, string> > >
(PrefC.GetString(PrefName.VoiceMailOriginationPath));
}
catch (Exception ex) { //If the preference value was not a well formed JSON list, start over with a new list.
ex.DoNothing();
listPaths = new List <KeyValuePair <string, string> >();
}
bool didUpdatePath = false;
for (int i = 0; i < listPaths.Count; i++)
{
if (listPaths[i].Key == Environment.MachineName)
{
listPaths[i] = new KeyValuePair <string, string>(listPaths[i].Key, path);
didUpdatePath = true;
}
}
if (!didUpdatePath)
{
listPaths.Add(new KeyValuePair <string, string>(Environment.MachineName, path));
}
return(Prefs.UpdateString(PrefName.VoiceMailOriginationPath, JsonConvert.SerializeObject(listPaths)));
}
///<summary>This runs aging for all patients. If using monthly aging, it always just runs the aging as of the last date again. If using daily aging, it runs it as of today. This logic used to be in FormAging, but is now centralized.</summary>
public static void RunAging()
{
//No need to check RemotingRole; no call to db.
if (PrefC.GetBool(PrefName.AgingCalculatedMonthlyInsteadOfDaily))
{
ComputeAging(0, PrefC.GetDate(PrefName.DateLastAging), false);
}
else
{
ComputeAging(0, DateTime.Today, false);
if (PrefC.GetDate(PrefName.DateLastAging) != DateTime.Today)
{
Prefs.UpdateString(PrefName.DateLastAging, POut.Date(DateTime.Today, false));
//Since this is always called from UI, the above line works fine to keep the prefs cache current.
}
}
}
/// <summary>Runs repeating charges for the date passed in, usually today. Can't use 'out' variables because this runs over Middle Tier.</summary>
public static RepeatChargeResult RunRepeatingCharges(DateTime dateRun)
{
if (RemotingClient.RemotingRole == RemotingRole.ClientWeb)
{
return(Meth.GetObject <RepeatChargeResult>(MethodBase.GetCurrentMethod(), dateRun));
}
Prefs.UpdateDateT(PrefName.RepeatingChargesBeginDateTime, dateRun);
try {
RepeatChargeResult result = new RepeatChargeResult();
List <RepeatCharge> listRepeatingCharges = RepeatCharges.Refresh(0).ToList();
if (PrefC.IsODHQ)
{
//Remove all eService repeating charges.
//EService charges have already been calculated and stored in EServiceBilling table. Add those here.
List <string> listEServiceCodes = EServiceCodeLink.GetProcCodesForAll();
listRepeatingCharges.RemoveAll(x => listEServiceCodes.Contains(x.ProcCode));
result.ProceduresAddedCount += EServiceBillings.AddEServiceRepeatingChargesHelper(dateRun).Count;
}
DateTime startedUsingFKs = UpdateHistories.GetDateForVersion(new Version("16.1.0.0")); //We started using FKs from procs to repeat charges in 16.1.
foreach (RepeatCharge repeatCharge in listRepeatingCharges)
{
if (!repeatCharge.IsEnabled || (repeatCharge.DateStop.Year > 1880 && repeatCharge.DateStop.AddMonths(3) < dateRun))
{
continue; //This repeating charge is too old to possibly create a new charge. Not precise but greatly reduces calls to DB.
//We will filter by more stringently on the DateStop later on.
}
long codeNum = ProcedureCodes.GetCodeNum(repeatCharge.ProcCode);
//Must contain all procedures that affect the date range.
DateTime procRangeStart = repeatCharge.DateStart.AddMonths(-1); //Minus 1 month to catch accounts that have changed their billing date
List <Procedure> listExistingProcs = Procedures.GetCompletedForDateRange(procRangeStart, dateRun,
new List <long> {
codeNum
},
new List <long> {
repeatCharge.PatNum
});
for (int j = listExistingProcs.Count - 1; j >= 0; j--) //iterate backwards to remove elements
{
Procedure proc = listExistingProcs[j];
if (((proc.RepeatChargeNum == repeatCharge.RepeatChargeNum) //Check the procedure's FK first
//Use the old logic without matching FKs only if the procedure was added before updating to 16.1
//Match patnum, codenum, fee, year, and month (IsRepeatDateHelper uses special logic to determine correct month)
//Procedures with the ProcDate prior to the RepeatCharge.StartDate should not be considered as valid procedures
//associated to the current repeat charge.
|| ((proc.ProcDate < startedUsingFKs || startedUsingFKs.Year < 1880) &&
proc.PatNum == repeatCharge.PatNum &&
proc.CodeNum == codeNum &&
proc.ProcFee.IsEqual(repeatCharge.ChargeAmt))) &&
(proc.ProcDate >= repeatCharge.DateStart || //Consider procedures that fall on or after the repeat charge start date.
proc.ProcDate.Day != repeatCharge.DateStart.Day)) //Consider procs only when days are not the same. Catches procs that have changed their billing date
{
continue; //This existing procedure needs to be counted for this repeat charge.
}
listExistingProcs.RemoveAt(j); //Removing so that another repeat charge of the same code, date, and amount will be added.
}
List <DateTime> listBillingDates; //This list will have 1 or 2 dates where a repeating charge might be added
if (PrefC.GetBool(PrefName.BillingUseBillingCycleDay))
{
listBillingDates = GetBillingDatesHelper(repeatCharge.DateStart, repeatCharge.DateStop, dateRun, listExistingProcs, repeatCharge,
Patients.GetPat(repeatCharge.PatNum).BillingCycleDay);
}
else
{
listBillingDates = GetBillingDatesHelper(repeatCharge.DateStart, repeatCharge.DateStop, dateRun, listExistingProcs, repeatCharge);
}
listBillingDates.RemoveAll(x => x.Date > DateTime.Today.Date && !PrefC.GetBool(PrefName.FutureTransDatesAllowed));
//If any billing dates have not been filtered out, add a repeating charge on those dates
foreach (DateTime billingDate in listBillingDates)
{
Procedure procAdded = AddRepeatingChargeHelper(repeatCharge, billingDate, dateRun);
List <Claim> listClaimsAdded = new List <Claim>();
if (repeatCharge.CreatesClaim && !ProcedureCodes.GetProcCode(repeatCharge.ProcCode).NoBillIns)
{
listClaimsAdded = AddClaimsHelper(repeatCharge, procAdded);
}
result.ProceduresAddedCount++;
result.ClaimsAddedCount += listClaimsAdded.Count;
}
}
return(result);
}
finally {
Prefs.UpdateString(PrefName.RepeatingChargesBeginDateTime, "");
}
}
/// <summary>Runs repeating charges for the date passed in, usually today. Can't use 'out' variables because this runs over Middle Tier.</summary>
public static RepeatChargeResult RunRepeatingCharges(DateTime dateRun)
{
if (RemotingClient.RemotingRole == RemotingRole.ClientWeb)
{
return(Meth.GetObject <RepeatChargeResult>(MethodBase.GetCurrentMethod(), dateRun));
}
Prefs.UpdateDateT(PrefName.RepeatingChargesBeginDateTime, dateRun);
try {
RepeatChargeResult result = new RepeatChargeResult();
List <RepeatCharge> listRepeatingCharges = RepeatCharges.Refresh(0).ToList();
if (PrefC.IsODHQ)
{
//Remove all eService repeating charges.
//EService charges have already been calculated and stored in EServiceBilling table. Add those here.
List <string> listEServiceCodes = EServiceCodeLink.GetProcCodesForAll();
listRepeatingCharges.RemoveAll(x => listEServiceCodes.Contains(x.ProcCode));
result.ProceduresAddedCount += EServiceBillings.AddEServiceRepeatingChargesHelper(dateRun).Count;
}
//Must contain all procedures that affect the date range, safe to contain too many, bad to contain too few.
List <Procedure> listExistingProcs = Procedures.GetCompletedForDateRange(dateRun.AddMonths(-3), dateRun.AddDays(1),
listRepeatingCharges.Select(x => x.ProcCode).Distinct().Select(x => ProcedureCodes.GetProcCode(x).CodeNum).ToList());
DateTime startedUsingFKs = UpdateHistories.GetDateForVersion(new Version("16.1.0.0")); //We started using FKs from procs to repeat charges in 16.1.
foreach (RepeatCharge repeatCharge in listRepeatingCharges)
{
if (!repeatCharge.IsEnabled || (repeatCharge.DateStop.Year > 1880 && repeatCharge.DateStop.AddMonths(3) < dateRun))
{
continue; //This repeating charge is too old to possibly create a new charge. Not precise but greatly reduces calls to DB.
//We will filter by more stringently on the DateStop later on.
}
Patient pat = null;
List <DateTime> listBillingDates; //This list will have 1 or 2 dates where a repeating charge might be added
if (PrefC.GetBool(PrefName.BillingUseBillingCycleDay))
{
pat = Patients.GetPat(repeatCharge.PatNum);
listBillingDates = GetBillingDatesHelper(repeatCharge.DateStart, repeatCharge.DateStop, dateRun, pat.BillingCycleDay);
}
else
{
listBillingDates = GetBillingDatesHelper(repeatCharge.DateStart, repeatCharge.DateStop, dateRun);
}
long codeNum = ProcedureCodes.GetCodeNum(repeatCharge.ProcCode);
//Remove billing dates if there is a procedure from this repeat charge in that month and year
for (int i = listBillingDates.Count - 1; i >= 0; i--) //iterate backwards to remove elements
{
DateTime billingDate = listBillingDates[i];
for (int j = listExistingProcs.Count - 1; j >= 0; j--) //iterate backwards to remove elements
{
Procedure proc = listExistingProcs[j];
if ((proc.RepeatChargeNum == repeatCharge.RepeatChargeNum && //Check the procedure's FK first
IsRepeatDateHelper(repeatCharge, billingDate, proc.ProcDate, pat))
//Use the old logic without matching FKs only if the procedure was added before updating to 16.1
//Match patnum, codenum, fee, year, and month (IsRepeatDateHelper uses special logic to determine correct month)
|| ((proc.ProcDate < startedUsingFKs || startedUsingFKs.Year < 1880) &&
proc.PatNum == repeatCharge.PatNum &&
proc.CodeNum == codeNum &&
IsRepeatDateHelper(repeatCharge, billingDate, proc.ProcDate, pat) &&
proc.ProcFee.IsEqual(repeatCharge.ChargeAmt)))
{
//This is a match to an existing procedure.
listBillingDates.RemoveAt(i); //Removing so that a procedure will not get added on this date.
listExistingProcs.RemoveAt(j); //Removing so that another repeat charge of the same code, date, and amount will be added.
break; //Go to the next billing date
}
}
}
//If any billing dates have not been filtered out, add a repeating charge on those dates
foreach (DateTime billingDate in listBillingDates)
{
Procedure procAdded = AddRepeatingChargeHelper(repeatCharge, billingDate, dateRun);
List <Claim> listClaimsAdded = new List <Claim>();
if (repeatCharge.CreatesClaim && !ProcedureCodes.GetProcCode(repeatCharge.ProcCode).NoBillIns)
{
listClaimsAdded = AddClaimsHelper(repeatCharge, procAdded);
}
result.ProceduresAddedCount++;
result.ClaimsAddedCount += listClaimsAdded.Count;
}
}
return(result);
}
finally {
Prefs.UpdateString(PrefName.RepeatingChargesBeginDateTime, "");
}
}
///<summary>Updates writeoff estimated for claimprocs for the passed in clinics. Called only in FormFeeSchedTools, located here to allow unit
///testing. Requires an ODProgressExtended to display UI updates. If clinics are enabled and the user is not clinic restricted and chooses to run
///for all clinics, set doUpdatePrevClinicPref to true so that the ClinicNums will be stored in the preference table as they are finished to allow
///for pausing/resuming the process.</summary>
public static long GlobalUpdateWriteoffs(List <long> listWriteoffClinicNums, ODProgressExtended progress, bool doUpdatePrevClinicPref = false)
{
//No need to check RemotingRole; no call to db.
long totalWriteoffsUpdated = 0;
List <Fee> listFeesHQ = Fees.GetByClinicNum(0);//All HQ fees
Dictionary <long, List <Procedure> > dictPatProcs;
List <FamProc> listFamProcs;
Dictionary <long, List <ClaimProc> > dictClaimProcs;
List <Fee> listFeesHQandClinic;
Lookup <FeeKey2, Fee> lookupFeesByCodeAndSched;
List <InsSub> listInsSubs;
List <InsPlan> listInsPlans;
List <PatPlan> listPatPlans;
List <Benefit> listBenefits;
List <Action> listActions;
//Get all objects needed to check if procedures are linked to an orthocase here to avoid querying in loops.
List <OrthoProcLink> listOrthoProcLinksAll = new List <OrthoProcLink>();
Dictionary <long, OrthoProcLink> dictOrthoProcLinksAll = new Dictionary <long, OrthoProcLink>();
Dictionary <long, OrthoCase> dictOrthoCases = new Dictionary <long, OrthoCase>();
Dictionary <long, OrthoSchedule> dictOrthoSchedules = new Dictionary <long, OrthoSchedule>();
OrthoCases.GetDataForAllProcLinks(ref listOrthoProcLinksAll, ref dictOrthoProcLinksAll, ref dictOrthoCases, ref dictOrthoSchedules);
OrthoProcLink orthoProcLink = null;
OrthoCase orthoCase = null;
OrthoSchedule orthoSchedule = null;
List <OrthoProcLink> listOrthoProcLinksForOrthoCase = null;
foreach (long clinicNumCur in listWriteoffClinicNums)
{
progress.Fire(ODEventType.FeeSched, new ProgressBarHelper(Clinics.GetAbbr(clinicNumCur), "0%", 0, 100, ProgBarStyle.Blocks, "WriteoffProgress"));
long rowCurIndex = 0; //reset for each clinic.
object lockObj = new object(); //used to lock rowCurIndex so the threads will correctly increment the count
progress.Fire(ODEventType.FeeSched, new ProgressBarHelper(Lans.g("FeeSchedEvent", "Getting list to update writeoffs..."),
progressBarEventType: ProgBarEventType.TextMsg));
listFeesHQandClinic = Fees.GetByClinicNum(clinicNumCur); //could be empty for some clinics that don't use overrides
listFeesHQandClinic.AddRange(listFeesHQ);
lookupFeesByCodeAndSched = (Lookup <FeeKey2, Fee>)listFeesHQandClinic.ToLookup(x => new FeeKey2(x.CodeNum, x.FeeSched));
dictPatProcs = Procedures.GetAllTp(clinicNumCur)
.GroupBy(x => x.PatNum)
.ToDictionary(x => x.Key, x => Procedures.SortListByTreatPlanPriority(x.ToList()).ToList());
#region Has Paused or Cancelled
while (progress.IsPaused)
{
progress.AllowResume();
if (progress.IsCanceled)
{
break;
}
}
if (progress.IsCanceled)
{
break;
}
#endregion Has Paused or Cancelled
if (dictPatProcs.Count == 0)
{
continue;
}
int procCount = dictPatProcs.Sum(x => x.Value.Count);
listFamProcs = Patients.GetFamilies(dictPatProcs.Keys.ToList()).Where(x => x.Guarantor != null)
.Select(x => new FamProc {
GuarNum = x.Guarantor.PatNum,
ListPatProcs = x.ListPats.Select(y => new PatProc {
PatNum = y.PatNum,
Age = y.Age,
ListProcs = dictPatProcs.TryGetValue(y.PatNum, out List <Procedure> listProcsCurr)?listProcsCurr:new List <Procedure>()
}).ToList()
}).ToList();
listPatPlans = PatPlans.GetPatPlansForPats(dictPatProcs.Keys.ToList());
listInsSubs = InsSubs.GetListInsSubs(dictPatProcs.Keys.ToList());
List <long> listInsSubNums = listInsSubs.Select(x => x.InsSubNum).ToList();
listInsSubs.AddRange(InsSubs.GetMany(listPatPlans.Select(x => x.InsSubNum).Distinct().Where(x => !listInsSubNums.Contains(x)).ToList()));
listInsSubs = listInsSubs.DistinctBy(x => x.InsSubNum).ToList();
listInsPlans = InsPlans.RefreshForSubList(listInsSubs);
listBenefits = Benefits.GetAllForPatPlans(listPatPlans, listInsSubs);
#region Has Paused or Cancelled
while (progress.IsPaused)
{
progress.AllowResume();
if (progress.IsCanceled)
{
break;
}
}
if (progress.IsCanceled)
{
break;
}
#endregion Has Paused or Cancelled
//dictionary of key=PatNum, value=list of claimprocs, i.e. a dictionary linking each PatNum to a list of claimprocs for the given procs
dictClaimProcs = ClaimProcs.GetForProcs(dictPatProcs.SelectMany(x => x.Value.Select(y => y.ProcNum)).ToList(), useDataReader: true)
.GroupBy(x => x.PatNum)
.ToDictionary(x => x.Key, x => x.ToList());
#region Has Paused or Cancelled
while (progress.IsPaused)
{
progress.AllowResume();
if (progress.IsCanceled)
{
break;
}
}
if (progress.IsCanceled)
{
break;
}
#endregion Has Paused or Cancelled
progress.Fire(ODEventType.FeeSched, new ProgressBarHelper(Lans.g("FeeSchedEvent", "Updating writeoff estimates for patients..."),
progressBarEventType: ProgBarEventType.TextMsg));
listActions = listFamProcs.Select(x => new Action(() => {
#region Has Cancelled
if (progress.IsCanceled)
{
return;
}
#endregion Has Cancelled
List <long> listPatNums = x.ListPatProcs.Select(y => y.PatNum).ToList();
List <long> listInsSubNumsPatPlanCur = listPatPlans.Where(y => y.PatNum.In(listPatNums)).Select(y => y.InsSubNum).ToList();
List <InsSub> listInsSubsCur = listInsSubs.FindAll(y => listPatNums.Contains(y.Subscriber) || y.InsSubNum.In(listInsSubNumsPatPlanCur));
List <long> listInsSubPlanNumsCur = listInsSubsCur.Select(y => y.PlanNum).ToList();
List <InsPlan> listInsPlansCur = listInsPlans.FindAll(y => listInsSubPlanNumsCur.Contains(y.PlanNum));
List <SubstitutionLink> listSubstitutionLinks = SubstitutionLinks.GetAllForPlans(listInsPlansCur);
List <PatPlan> listPatPlansCur;
List <Benefit> listBenefitsCur;
foreach (PatProc patProc in x.ListPatProcs) //foreach patient in the family
{
if (patProc.ListProcs.IsNullOrEmpty())
{
continue;
}
listPatPlansCur = listPatPlans.FindAll(y => y.PatNum == patProc.PatNum);
List <long> listInsPlanNumsCur = listInsPlansCur.Select(y => y.PlanNum).ToList();
List <long> listPatPlanNumsCur = listPatPlansCur.Select(y => y.PatPlanNum).ToList();
listBenefitsCur = listBenefits
.FindAll(y => listInsPlanNumsCur.Contains(y.PlanNum) || listPatPlanNumsCur.Contains(y.PatPlanNum));
listBenefitsCur.Sort(Benefits.SortBenefits);
if (!dictClaimProcs.TryGetValue(patProc.PatNum, out List <ClaimProc> listClaimProcsCur))
{
listClaimProcsCur = new List <ClaimProc>();
}
foreach (Procedure procCur in patProc.ListProcs) //foreach proc for this patient
{
OrthoCases.FillOrthoCaseObjectsForProc(procCur.ProcNum, ref orthoProcLink, ref orthoCase, ref orthoSchedule
, ref listOrthoProcLinksForOrthoCase, dictOrthoProcLinksAll, dictOrthoCases, dictOrthoSchedules, listOrthoProcLinksAll);
Procedures.ComputeEstimates(procCur, patProc.PatNum, ref listClaimProcsCur, false, listInsPlansCur, listPatPlansCur, listBenefitsCur,
null, null, true, patProc.Age, listInsSubsCur, listSubstLinks: listSubstitutionLinks, lookupFees: lookupFeesByCodeAndSched,
orthoProcLink: orthoProcLink, orthoCase: orthoCase, orthoSchedule: orthoSchedule, listOrthoProcLinksForOrthoCase: listOrthoProcLinksForOrthoCase);
double percentage = 0;
lock (lockObj) {
percentage = Math.Ceiling(((double)(++rowCurIndex) / procCount) * 100);
}
progress.Fire(ODEventType.FeeSched,
new ProgressBarHelper(Clinics.GetAbbr(clinicNumCur), (int)percentage + "%", (int)percentage, 100, ProgBarStyle.Blocks, "WriteoffProgress"));
}
}
})).ToList();
ODThread.RunParallel(listActions, TimeSpan.FromHours(3),
onException: new ODThread.ExceptionDelegate((ex) => {
//Notify the user what went wrong via the text box.
progress.Fire(ODEventType.FeeSched, new ProgressBarHelper("Error updating writeoffs: " + ex.Message,
progressBarEventType: ProgBarEventType.TextMsg));
})
);
if (listWriteoffClinicNums.Count > 1) //only show if more than one clinic
{
progress.Fire(ODEventType.FeeSched,
new ProgressBarHelper(rowCurIndex + " " + Lans.g("FeeSchedTools", "procedures processed from") + " " + Clinics.GetAbbr(clinicNumCur),
progressBarEventType: ProgBarEventType.TextMsg));
}
totalWriteoffsUpdated += rowCurIndex;
if (doUpdatePrevClinicPref && rowCurIndex == procCount)
{
//if storing previously completed clinic and we actually completed this clinic's procs, update the pref
if (listWriteoffClinicNums.Last() == clinicNumCur)
{
//if this is the last clinic in the list, clear the last clinic pref so the next time it will run for all clinics
Prefs.UpdateString(PrefName.GlobalUpdateWriteOffLastClinicCompleted, "");
}
else
{
Prefs.UpdateString(PrefName.GlobalUpdateWriteOffLastClinicCompleted, POut.Long(clinicNumCur));
}
Signalods.SetInvalid(InvalidType.Prefs);
}
#region Has Cancelled
if (progress.IsCanceled)
{
break;
}
#endregion Has Cancelled
}
progress.OnProgressDone();
progress.Fire(ODEventType.FeeSched, new ProgressBarHelper("Writeoffs updated. " + totalWriteoffsUpdated + " procedures processed.\r\nDone.",
progressBarEventType: ProgBarEventType.TextMsg));
return(totalWriteoffsUpdated);
}