///<summary>Get all non-hidden fee sched fees for a clinic and add to the cache. Cannot be used as part of a transaction.</summary> private void AddClinicFees(long clinicNum) { List <long> listFeeScheds = FeeScheds.GetDeepCopy(true).Select(x => x.FeeSchedNum).ToList(); List <Fee> listFees = Fees.GetByFeeSchedNumsClinicNums(listFeeScheds, new List <long>() { clinicNum }); Add(listFees); }
///<summary>Searches the db for a fee with the exact codeNum, feeSchedNum, clinicNum, and provNum provided. Returns null if no exact match found. ///The goal of this method is to have a way to check the database for "duplicate" fees before adding more fees to the db. Set doGetExactMatch to ///true to exactly match all passed in parameters.</summary> public static Fee GetFeeFromDb(long codeNum, long feeSchedNum, long clinicNum = 0, long provNum = 0, bool doGetExactMatch = false) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <Fee>(MethodBase.GetCurrentMethod(), codeNum, feeSchedNum, clinicNum, provNum, doGetExactMatch)); } if (FeeScheds.IsGlobal(feeSchedNum) && !doGetExactMatch) { clinicNum = 0; provNum = 0; } //If the logic changes here, then we need to change FeeCache.GetFee. string command = //Search for exact match first. This would include a clinic and provider override. @"SELECT fee.* FROM fee WHERE fee.CodeNum=" + POut.Long(codeNum) + @" AND fee.FeeSched=" + POut.Long(feeSchedNum) + @" AND fee.ClinicNum=" + POut.Long(clinicNum) + @" AND fee.ProvNum=" + POut.Long(provNum); if (!doGetExactMatch) { //Provider override command += @" UNION ALL SELECT fee.* FROM fee WHERE fee.CodeNum=" + POut.Long(codeNum) + @" AND fee.FeeSched=" + POut.Long(feeSchedNum) + @" AND fee.ClinicNum=0 AND fee.ProvNum=" + POut.Long(provNum); //Clinic override command += @" UNION ALL SELECT fee.* FROM fee WHERE fee.CodeNum=" + POut.Long(codeNum) + @" AND fee.FeeSched=" + POut.Long(feeSchedNum) + @" AND fee.ClinicNum=" + POut.Long(clinicNum) + @" AND fee.ProvNum=0" ; //Unassigned clinic with no override command += @" UNION ALL SELECT fee.* FROM fee WHERE fee.CodeNum=" + POut.Long(codeNum) + @" AND fee.FeeSched=" + POut.Long(feeSchedNum) + @" AND fee.ClinicNum=0 AND fee.ProvNum=0" ; } return(Crud.FeeCrud.SelectOne(command)); }
///<summary>Gets the fee directly from the database every time.</summary> public Fee GetFee(long codeNum, long feeSchedNum, long clinicNum = 0, long provNum = 0, bool doGetExactMatch = false) { if (FeeScheds.IsGlobal(feeSchedNum) && !doGetExactMatch) { clinicNum = 0; provNum = 0; } //If the logic changes here, then we need to change FeeCache.GetFee. string command = //Search for exact match first @"SELECT fee.* FROM fee WHERE fee.CodeNum=" + POut.Long(codeNum) + @" AND fee.FeeSched=" + POut.Long(feeSchedNum) + @" AND fee.ClinicNum=" + POut.Long(clinicNum) + @" AND fee.ProvNum=" + POut.Long(provNum); if (!doGetExactMatch) { //Then try same provider and codeNum with default clinic. command += @" UNION ALL SELECT fee.* FROM fee WHERE fee.CodeNum=" + POut.Long(codeNum) + @" AND fee.FeeSched=" + POut.Long(feeSchedNum) + @" AND fee.ClinicNum=0 AND fee.ProvNum=" + POut.Long(provNum); //Then try same clinic with no provider. command += @" UNION ALL SELECT fee.* FROM fee WHERE fee.CodeNum=" + POut.Long(codeNum) + @" AND fee.FeeSched=" + POut.Long(feeSchedNum) + @" AND fee.ClinicNum=" + POut.Long(clinicNum) + @" AND fee.ProvNum=0" ; //Then try default clinic with no provider. command += @" UNION ALL SELECT fee.* FROM fee WHERE fee.CodeNum=" + POut.Long(codeNum) + @" AND fee.FeeSched=" + POut.Long(feeSchedNum) + @" AND fee.ClinicNum=0 AND fee.ProvNum=0" ; } return(Crud.FeeCrud.SelectOne(command)); }
///<summary>Returns an amount if a fee has been entered. Prefers local clinic fees over HQ fees. Otherwise returns -1. ///Not usually used directly. If you don't pass in a list of Fees, it will go directly to the Db.</summary> public static double GetAmount(long codeNum, long feeSchedNum, long clinicNum, long provNum, List <Fee> listFees = null) { //No need to check RemotingRole; no call to db. if (FeeScheds.GetIsHidden(feeSchedNum)) { return(-1); //you cannot obtain fees for hidden fee schedules } Fee fee = GetFee(codeNum, feeSchedNum, clinicNum, provNum, listFees); if (fee == null) { return(-1); } return(fee.Amount); }
///<summary>Returns the amount for the fee that best matches the provided parameters (according to the rules of GetFee() when doGetExactMatch ///is false. Returns 0 if the fee can't be found.</summary> public double GetAmount0(long codeNum, long feeSchedNum, long clinicNum = 0, long provNum = 0) { //No need to check RemotingRole; no call to db. AddClinicNum(clinicNum); if (FeeScheds.GetIsHidden(feeSchedNum)) { return(0); //you cannot obtain fees for hidden fee schedules } Fee fee = GetFee(codeNum, feeSchedNum, clinicNum, provNum); if (fee == null) { return(0); } return(fee.Amount); }
///<summary>Increases the fee schedule by percent. Round should be the number of decimal places, either 0,1,or 2. ///Returns listFees back after increasing the fees from the passed in fee schedule information.</summary> public static List <Fee> Increase(long feeSchedNum, int percent, int round, List <Fee> listFees, long clinicNum, long provNum) { //No need to check RemotingRole; no call to db. FeeSched feeSched = FeeScheds.GetFirst(x => x.FeeSchedNum == feeSchedNum); List <long> listCodeNums = new List <long>(); //Contains only the fee codeNums that have been increased. Used for keeping track. foreach (Fee feeCur in listFees) { if (listCodeNums.Contains(feeCur.CodeNum)) { continue; //Skip the fee if it's associated to a procedure code that has already been increased / added. } //The best match isn't 0, and we haven't already done this CodeNum if (feeCur != null && feeCur.Amount != 0) { double newVal = (double)feeCur.Amount * (1 + (double)percent / 100); if (round > 0) { newVal = Math.Round(newVal, round); } else { newVal = Math.Round(newVal, MidpointRounding.AwayFromZero); } //The fee showing in the fee schedule is not a perfect match. Make a new one that is. //E.g. We are increasing all fees for clinicNum of 1 and provNum of 5 and the best match found was for clinicNum of 3 and provNum of 7. //We would then need to make a copy of that fee, increase it, and then associate it to the clinicNum and provNum passed in (1 and 5). if (!feeSched.IsGlobal && (feeCur.ClinicNum != clinicNum || feeCur.ProvNum != provNum)) { Fee fee = new Fee(); fee.Amount = newVal; fee.CodeNum = feeCur.CodeNum; fee.ClinicNum = clinicNum; fee.ProvNum = provNum; fee.FeeSched = feeSchedNum; listFees.Add(fee); } else //Just update the match found. { feeCur.Amount = newVal; } } listCodeNums.Add(feeCur.CodeNum); } return(listFees); }
///<summary>Same logic as above, in Fees.GetFeeNoCache(). Also, same logic as in FeeCache.GetFee(). ///Typical to pass in a list of fees for just one or a few feescheds so that the search goes quickly. ///When doGetExactMatch is true, this will return either the fee that matches the parameters exactly, or null if no such fee exists. ///When doGetExactMatch is false, and the fee schedule is global, we ignore the clinicNum and provNum and return the HQ fee that matches the given codeNum and feeSchedNum. ///When doGetExactMatch is false, and the fee schedule is not global, and no exact match exists we attempt to return the closest matching fee in this order: ///1 - The fee with the same codeNum, feeSchedNum, and providerNum, with a clinicNum of 0 ///2 - The fee with the same codeNum, feeSchedNum, and clinicNum, with a providerNum of 0 ///3 - The fee with the same codeNum, feeSchedNum, and both a clinicNum and providerNum of 0 ///If no partial match can be found, return null.</summary> private static Fee GetFeeFromList(List <Fee> listFees, long codeNum, long feeSched = 0, long clinicNum = 0, long provNum = 0, bool doGetExactMatch = false) { //No need to check RemotingRole; no call to db. if (FeeScheds.IsGlobal(feeSched) && !doGetExactMatch) //speed things up here with less loops { clinicNum = 0; provNum = 0; } Fee fee = listFees.Find(f => f.CodeNum == codeNum && f.FeeSched == feeSched && f.ClinicNum == clinicNum && f.ProvNum == provNum); if (fee != null) { return(fee); //match found. Would include a clinic and provider override. } if (doGetExactMatch || FeeScheds.IsGlobal(feeSched)) { return(null); //couldn't find exact match } //no exact match exists, so we look for closest match //2: Prov override fee = listFees.Find(f => f.CodeNum == codeNum && f.FeeSched == feeSched && f.ClinicNum == 0 && f.ProvNum == provNum); if (fee != null) { return(fee); } //3: Clinic override fee = listFees.Find(f => f.CodeNum == codeNum && f.FeeSched == feeSched && f.ClinicNum == clinicNum && f.ProvNum == 0); if (fee != null) { return(fee); } //4: Just unassigned clinic default fee = listFees.Find(f => f.CodeNum == codeNum && f.FeeSched == feeSched && f.ClinicNum == 0 && f.ProvNum == 0); //whether it's null or not: return(fee); }
///<summary>Returns an amount if a fee has been entered. Otherwise returns -1. Not usually used directly.</summary> public static double GetAmount(long codeNum, long feeSchedNum) { //No need to check RemotingRole; no call to db. if (codeNum == 0) { return(-1); } if (feeSchedNum == 0) { return(-1); } if (FeeScheds.GetIsHidden(feeSchedNum)) { return(-1); //you cannot obtain fees for hidden fee schedules } for (int i = 0; i < Listt.Count; i++) { if (Listt[i].CodeNum == codeNum && Listt[i].FeeSched == feeSchedNum) { return(Listt[i].Amount); } } return(-1); //code not found }
protected override void FillCacheIfNeeded() { FeeScheds.GetTableFromCache(false); }
///<summary>This method will remove and/or add a fee for the fee information passed in. ///codeText will typically be one valid procedure code. E.g. D1240 ///If an amt of -1 is passed in, then it indicates a "blank" entry which will cause deletion of any existing fee. ///Returns listFees back after importing the passed in fee information. ///Does not make any database calls. This is left up to the user to take action on the list of fees returned. ///Also, makes security log entries based on how the fee changed. Does not make a log for codes that were removed (user already warned)</summary> public static List <Fee> Import(string codeText, double amt, long feeSchedNum, long clinicNum, long provNum, List <Fee> listFees) { //No need to check RemotingRole; no call to db. if (!ProcedureCodes.IsValidCode(codeText)) { return(listFees); //skip for now. Possibly insert a code in a future version. } string feeOldStr = ""; long codeNum = ProcedureCodes.GetCodeNum(codeText); Fee fee = listFees.FirstOrDefault(x => x.CodeNum == codeNum && x.FeeSched == feeSchedNum && x.ClinicNum == clinicNum && x.ProvNum == provNum); DateTime datePrevious = DateTime.MinValue; if (fee != null) { feeOldStr = Lans.g("FormFeeSchedTools", "Old Fee") + ": " + fee.Amount.ToString("c") + ", "; datePrevious = fee.SecDateTEdit; listFees.Remove(fee); } if (amt == -1) { return(listFees); } fee = new Fee(); fee.Amount = amt; fee.FeeSched = feeSchedNum; fee.CodeNum = ProcedureCodes.GetCodeNum(codeText); fee.ClinicNum = clinicNum; //Either 0 because you're importing on an HQ schedule or local clinic because the feesched is localizable. fee.ProvNum = provNum; listFees.Add(fee); //Insert new fee specific to the active clinic. SecurityLogs.MakeLogEntry(Permissions.ProcFeeEdit, 0, Lans.g("FormFeeSchedTools", "Procedure") + ": " + codeText + ", " + feeOldStr + Lans.g("FormFeeSchedTools", "New Fee") + ": " + amt.ToString("c") + ", " + Lans.g("FormFeeSchedTools", "Fee Schedule") + ": " + FeeScheds.GetDescription(feeSchedNum) + ". " + Lans.g("FormFeeSchedTools", "Fee changed using the Import button in the Fee Tools window."), ProcedureCodes.GetCodeNum(codeText), DateTime.MinValue); SecurityLogs.MakeLogEntry(Permissions.LogFeeEdit, 0, "Fee changed", fee.FeeNum, datePrevious); return(listFees); }
///<summary>If ClientWeb, then this method is instead run on the server, and the result passed back to the client. And since it's ClientWeb, FillCache will be run on the client.</summary> public static DataSet GetCacheDs(string itypesStr) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetDS(MethodBase.GetCurrentMethod(), itypesStr)); } //so this part below only happens if direct or server------------------------------------------------ List <int> itypes = new List <int>(); string[] strArray = itypesStr.Split(','); for (int i = 0; i < strArray.Length; i++) { itypes.Add(PIn.Int(strArray[i])); } bool isAll = false; if (itypes.Contains((int)InvalidType.AllLocal)) { isAll = true; } DataSet ds = new DataSet(); if (itypes.Contains((int)InvalidType.AccountingAutoPays) || isAll) { ds.Tables.Add(AccountingAutoPays.RefreshCache()); } if (itypes.Contains((int)InvalidType.AutoCodes) || isAll) { ds.Tables.Add(AutoCodes.RefreshCache()); ds.Tables.Add(AutoCodeItems.RefreshCache()); ds.Tables.Add(AutoCodeConds.RefreshCache()); } if (itypes.Contains((int)InvalidType.Automation) || isAll) { ds.Tables.Add(Automations.RefreshCache()); } if (itypes.Contains((int)InvalidType.AutoNotes) || isAll) { ds.Tables.Add(AutoNotes.RefreshCache()); ds.Tables.Add(AutoNoteControls.RefreshCache()); } if (itypes.Contains((int)InvalidType.Carriers) || isAll) { ds.Tables.Add(Carriers.RefreshCache()); //run on startup, after telephone reformat, after list edit. } if (itypes.Contains((int)InvalidType.ClaimForms) || isAll) { ds.Tables.Add(ClaimFormItems.RefreshCache()); ds.Tables.Add(ClaimForms.RefreshCache()); } if (itypes.Contains((int)InvalidType.ClearHouses) || isAll) { ds.Tables.Add(Clearinghouses.RefreshCache()); //kh wants to add an EasyHideClearHouses to disable this } if (itypes.Contains((int)InvalidType.Computers) || isAll) { ds.Tables.Add(Computers.RefreshCache()); ds.Tables.Add(Printers.RefreshCache()); } if (itypes.Contains((int)InvalidType.Defs) || isAll) { ds.Tables.Add(Defs.RefreshCache()); } if (itypes.Contains((int)InvalidType.DentalSchools) || isAll) { ds.Tables.Add(SchoolClasses.RefreshCache()); ds.Tables.Add(SchoolCourses.RefreshCache()); } if (itypes.Contains((int)InvalidType.DictCustoms) || isAll) { ds.Tables.Add(DictCustoms.RefreshCache()); } if (itypes.Contains((int)InvalidType.Diseases) || isAll) { ds.Tables.Add(DiseaseDefs.RefreshCache()); ds.Tables.Add(ICD9s.RefreshCache()); } if (itypes.Contains((int)InvalidType.DisplayFields) || isAll) { ds.Tables.Add(DisplayFields.RefreshCache()); } if (itypes.Contains((int)InvalidType.ElectIDs) || isAll) { ds.Tables.Add(ElectIDs.RefreshCache()); } if (itypes.Contains((int)InvalidType.Email) || isAll) { ds.Tables.Add(EmailAddresses.RefreshCache()); ds.Tables.Add(EmailTemplates.RefreshCache()); } if (itypes.Contains((int)InvalidType.Employees) || isAll) { ds.Tables.Add(Employees.RefreshCache()); ds.Tables.Add(PayPeriods.RefreshCache()); } if (itypes.Contains((int)InvalidType.Employers) || isAll) { ds.Tables.Add(Employers.RefreshCache()); } if (itypes.Contains((int)InvalidType.Fees) || isAll) { ds.Tables.Add(Fees.RefreshCache()); } if (itypes.Contains((int)InvalidType.FeeScheds) || isAll) { ds.Tables.Add(FeeScheds.RefreshCache()); } if (itypes.Contains((int)InvalidType.HL7Defs) || isAll) { ds.Tables.Add(HL7Defs.RefreshCache()); ds.Tables.Add(HL7DefMessages.RefreshCache()); ds.Tables.Add(HL7DefSegments.RefreshCache()); ds.Tables.Add(HL7DefFields.RefreshCache()); } if (itypes.Contains((int)InvalidType.InsCats) || isAll) { ds.Tables.Add(CovCats.RefreshCache()); ds.Tables.Add(CovSpans.RefreshCache()); } if (itypes.Contains((int)InvalidType.InsFilingCodes) || isAll) { ds.Tables.Add(InsFilingCodes.RefreshCache()); ds.Tables.Add(InsFilingCodeSubtypes.RefreshCache()); } if (itypes.Contains((int)InvalidType.Languages) || isAll) { if (CultureInfo.CurrentCulture.Name != "en-US") { ds.Tables.Add(Lans.RefreshCache()); } } if (itypes.Contains((int)InvalidType.Letters) || isAll) { ds.Tables.Add(Letters.RefreshCache()); } if (itypes.Contains((int)InvalidType.LetterMerge) || isAll) { ds.Tables.Add(LetterMergeFields.RefreshCache()); ds.Tables.Add(LetterMerges.RefreshCache()); } if (itypes.Contains((int)InvalidType.Operatories) || isAll) { ds.Tables.Add(Operatories.RefreshCache()); } if (itypes.Contains((int)InvalidType.PatFields) || isAll) { ds.Tables.Add(PatFieldDefs.RefreshCache()); ds.Tables.Add(ApptFieldDefs.RefreshCache()); } if (itypes.Contains((int)InvalidType.Pharmacies) || isAll) { ds.Tables.Add(Pharmacies.RefreshCache()); } if (itypes.Contains((int)InvalidType.Prefs) || isAll) { ds.Tables.Add(Prefs.RefreshCache()); } if (itypes.Contains((int)InvalidType.ProcButtons) || isAll) { ds.Tables.Add(ProcButtons.RefreshCache()); ds.Tables.Add(ProcButtonItems.RefreshCache()); } if (itypes.Contains((int)InvalidType.ProcCodes) || isAll) { ds.Tables.Add(ProcedureCodes.RefreshCache()); ds.Tables.Add(ProcCodeNotes.RefreshCache()); } if (itypes.Contains((int)InvalidType.Programs) || isAll) { ds.Tables.Add(Programs.RefreshCache()); ds.Tables.Add(ProgramProperties.RefreshCache()); } if (itypes.Contains((int)InvalidType.ProviderIdents) || isAll) { ds.Tables.Add(ProviderIdents.RefreshCache()); } if (itypes.Contains((int)InvalidType.Providers) || isAll) { ds.Tables.Add(Providers.RefreshCache()); } if (itypes.Contains((int)InvalidType.QuickPaste) || isAll) { ds.Tables.Add(QuickPasteNotes.RefreshCache()); ds.Tables.Add(QuickPasteCats.RefreshCache()); } if (itypes.Contains((int)InvalidType.RecallTypes) || isAll) { ds.Tables.Add(RecallTypes.RefreshCache()); ds.Tables.Add(RecallTriggers.RefreshCache()); } if (itypes.Contains((int)InvalidType.ReplicationServers) || isAll) { ds.Tables.Add(ReplicationServers.RefreshCache()); } if (itypes.Contains((int)InvalidType.Security) || isAll) { ds.Tables.Add(Userods.RefreshCache()); ds.Tables.Add(UserGroups.RefreshCache()); } if (itypes.Contains((int)InvalidType.Sheets) || isAll) { ds.Tables.Add(SheetDefs.RefreshCache()); ds.Tables.Add(SheetFieldDefs.RefreshCache()); } if (itypes.Contains((int)InvalidType.Signals) || isAll) { ds.Tables.Add(SigElementDefs.RefreshCache()); ds.Tables.Add(SigButDefs.RefreshCache()); //includes SigButDefElements.Refresh() } if (itypes.Contains((int)InvalidType.Sites) || isAll) { ds.Tables.Add(Sites.RefreshCache()); } if (itypes.Contains((int)InvalidType.Sops) || isAll) { ds.Tables.Add(Sops.RefreshCache()); } //InvalidTypes.Tasks not handled here. if (itypes.Contains((int)InvalidType.TimeCardRules) || isAll) { ds.Tables.Add(TimeCardRules.RefreshCache()); } if (itypes.Contains((int)InvalidType.ToolBut) || isAll) { ds.Tables.Add(ToolButItems.RefreshCache()); } if (itypes.Contains((int)InvalidType.Vaccines) || isAll) { ds.Tables.Add(VaccineDefs.RefreshCache()); ds.Tables.Add(DrugManufacturers.RefreshCache()); ds.Tables.Add(DrugUnits.RefreshCache()); } if (itypes.Contains((int)InvalidType.Views) || isAll) { ds.Tables.Add(ApptViews.RefreshCache()); ds.Tables.Add(ApptViewItems.RefreshCache()); ds.Tables.Add(AppointmentRules.RefreshCache()); ds.Tables.Add(ProcApptColors.RefreshCache()); } if (itypes.Contains((int)InvalidType.Wiki) || isAll) { ds.Tables.Add(WikiListHeaderWidths.RefreshCache()); ds.Tables.Add(WikiPages.RefreshCache()); } if (itypes.Contains((int)InvalidType.ZipCodes) || isAll) { ds.Tables.Add(ZipCodes.RefreshCache()); } return(ds); }
///<summary>Attempts to return the fee that best matches the provided codeNum, feeSchedNum, clinicNum, and provNum. ///When doGetExactMatch is true, this will return either the fee that matches the parameters exactly, or null if no such fee exists. ///When doGetExactMatch is false, and the fee schedule is global, we ignore the clinicNum and provNum and return the HQ fee that matches the given codeNum and feeSchedNum. ///When doGetExactMatch is false, and the fee schedule is not global, and no exact match exists we attempt to return the closest matching fee in this order: ///1 - The fee with the same codeNum, feeSchedNum, and providerNum, with a clinicNum of 0 ///2 - The fee with the same codeNum, feeSchedNum, and clinicNum, with a providerNum of 0 ///3 - The fee with the same codeNum, feeSchedNum, and both a clinicNum and providerNum of 0 ///If no partial match can be found, return null.</summary> public Fee GetFee(long codeNum, long feeSchedNum, long clinicNum = 0, long provNum = 0, bool doGetExactMatch = false) { AddClinicNum(clinicNum); //Global fee schedules will never have clinicNum or provNum, so force them to equal 0 if they are not. if (FeeScheds.IsGlobal(feeSchedNum) && !doGetExactMatch) { clinicNum = 0; provNum = 0; } if (!_dict.ContainsFeeSched(feeSchedNum)) { //This is likely a hidden fee sched. We will add the fee sched to the cache now. List <Fee> listFeeSchedFees = Fees.GetByFeeSchedNumsClinicNums(new List <long> { feeSchedNum }, this._queueClinicNums.ToList()); if (listFeeSchedFees.Count == 0) { _dict.AddFeeSchedOnly(feeSchedNum); } else { this.Add(listFeeSchedFees); } } if (!_dict.ContainsFeeSchedAndClinic(feeSchedNum, clinicNum)) { _dict.AddFeeSchedClinicNumOnly(feeSchedNum, clinicNum); } RefreshInvalidFees(feeSchedNum); //If the logic changes here, then we need to change FeeNoCache.GetFee. FeeKey feeKey = new FeeKey(feeSchedNum, clinicNum, codeNum, provNum); Fee exactMatch; if (_dict.TryGetValue(feeKey, out exactMatch)) { return(exactMatch); //Found an exact match on clinic and provider } //Can't find exact an exact match if (doGetExactMatch) { return(null); } //We don't need an exact match, try same provider and codeNum with default clinic. feeKey = new FeeKey(feeSchedNum, 0, codeNum, provNum); Fee partialMatch; if (_dict.TryGetValue(feeKey, out partialMatch)) { return(partialMatch); } //Can't find a match for the provider, try same clinic with no provider. feeKey = new FeeKey(feeSchedNum, clinicNum, codeNum, 0); if (_dict.TryGetValue(feeKey, out partialMatch)) { return(partialMatch); } //Can't find a match for the clinic, try the default for this code. feeKey = new FeeKey(feeSchedNum, 0, codeNum, 0); if (_dict.TryGetValue(feeKey, out partialMatch)) { return(partialMatch); } return(null); //This fee sched does not have a default fee for this code. }
///<summary>Gets a list of procedure codes directly from the database. If categories.length==0, then we will get for all categories. Categories are defnums. FeeScheds are, for now, defnums.</summary> public static DataTable GetProcTable(string abbr, string desc, string code, List <long> categories, long feeSchedNum, long feeSched2Num, long feeSched3Num) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetTable(MethodBase.GetCurrentMethod(), abbr, desc, code, categories, feeSchedNum, feeSched2Num, feeSched3Num)); } string whereCat; if (categories.Count == 0) { whereCat = "1"; } else { whereCat = "("; for (int i = 0; i < categories.Count; i++) { if (i > 0) { whereCat += " OR "; } whereCat += "ProcCat=" + POut.Long(categories[i]); } whereCat += ")"; } FeeSched feeSched = FeeScheds.GetFirstOrDefault(x => x.FeeSchedNum == feeSchedNum); FeeSched feeSched2 = FeeScheds.GetFirstOrDefault(x => x.FeeSchedNum == feeSched2Num); FeeSched feeSched3 = FeeScheds.GetFirstOrDefault(x => x.FeeSchedNum == feeSched3Num); //Query changed to be compatible with both MySQL and Oracle (not tested). string command = "SELECT ProcCat,Descript,AbbrDesc,procedurecode.ProcCode,"; if (feeSched == null) { command += "-1 FeeAmt1,"; } else { command += "CASE "; if (!feeSched.IsGlobal && Clinics.ClinicNum != 0) //Use local clinic fee if there's one present { command += "WHEN (feeclinic1.Amount IS NOT NULL) THEN feeclinic1.Amount "; } command += "WHEN (feehq1.Amount IS NOT NULL) THEN feehq1.Amount ELSE -1 END FeeAmt1,"; } if (feeSched2 == null) { command += "-1 FeeAmt2,"; } else { command += "CASE "; if (!feeSched2.IsGlobal && Clinics.ClinicNum != 0) //Use local clinic fee if there's one present { command += "WHEN (feeclinic2.Amount IS NOT NULL) THEN feeclinic2.Amount "; } command += "WHEN (feehq2.Amount IS NOT NULL) THEN feehq2.Amount ELSE -1 END FeeAmt2,"; } if (feeSched3 == null) { command += "-1 FeeAmt3,"; } else { command += "CASE "; if (!feeSched3.IsGlobal && Clinics.ClinicNum != 0) //Use local clinic fee if there's one present { command += "WHEN (feeclinic3.Amount IS NOT NULL) THEN feeclinic3.Amount "; } command += "WHEN (feehq3.Amount IS NOT NULL) THEN feehq3.Amount ELSE -1 END FeeAmt3,"; } command += "procedurecode.CodeNum "; if (feeSched != null && !feeSched.IsGlobal && Clinics.ClinicNum != 0) { command += ",CASE WHEN (feeclinic1.Amount IS NOT NULL) THEN 1 ELSE 0 END IsClinic1 "; } if (feeSched2 != null && !feeSched2.IsGlobal && Clinics.ClinicNum != 0) { command += ",CASE WHEN (feeclinic2.Amount IS NOT NULL) THEN 1 ELSE 0 END IsClinic2 "; } if (feeSched3 != null && !feeSched3.IsGlobal && Clinics.ClinicNum != 0) { command += ",CASE WHEN (feeclinic3.Amount IS NOT NULL) THEN 1 ELSE 0 END IsClinic3 "; } command += "FROM procedurecode "; if (feeSched != null) { if (!feeSched.IsGlobal && Clinics.ClinicNum != 0) //Get local clinic fee if there's one present { command += "LEFT JOIN fee feeclinic1 ON feeclinic1.CodeNum=procedurecode.CodeNum AND feeclinic1.FeeSched=" + POut.Long(feeSched.FeeSchedNum) + " AND feeclinic1.ClinicNum=" + POut.Long(Clinics.ClinicNum) + " "; } //Get the hq clinic fee if there's one present command += "LEFT JOIN fee feehq1 ON feehq1.CodeNum=procedurecode.CodeNum AND feehq1.FeeSched=" + POut.Long(feeSched.FeeSchedNum) + " AND feehq1.ClinicNum=0 "; } if (feeSched2 != null) { if (!feeSched2.IsGlobal && Clinics.ClinicNum != 0) //Get local clinic fee if there's one present { command += "LEFT JOIN fee feeclinic2 ON feeclinic2.CodeNum=procedurecode.CodeNum AND feeclinic2.FeeSched=" + POut.Long(feeSched2.FeeSchedNum) + " AND feeclinic2.ClinicNum=" + POut.Long(Clinics.ClinicNum) + " "; } //Get the hq clinic fee if there's one present command += "LEFT JOIN fee feehq2 ON feehq2.CodeNum=procedurecode.CodeNum AND feehq2.FeeSched=" + POut.Long(feeSched2.FeeSchedNum) + " AND feehq2.ClinicNum=0 "; } if (feeSched3 != null) { if (!feeSched3.IsGlobal && Clinics.ClinicNum != 0) //Get local clinic fee if there's one present { command += "LEFT JOIN fee feeclinic3 ON feeclinic3.CodeNum=procedurecode.CodeNum AND feeclinic3.FeeSched=" + POut.Long(feeSched3.FeeSchedNum) + " AND feeClinic3.ClinicNum=" + POut.Long(Clinics.ClinicNum) + " "; } //Get the hq clinic fee if there's one present command += "LEFT JOIN fee feehq3 ON feehq3.CodeNum=procedurecode.CodeNum AND feehq3.FeeSched=" + POut.Long(feeSched3.FeeSchedNum) + " AND feehq3.ClinicNum=0 "; } command += "LEFT JOIN definition ON definition.DefNum=procedurecode.ProcCat " + "WHERE " + whereCat + " " + "AND Descript LIKE '%" + POut.String(desc) + "%' " + "AND AbbrDesc LIKE '%" + POut.String(abbr) + "%' " + "AND procedurecode.ProcCode LIKE '%" + POut.String(code) + "%' " + "ORDER BY definition.ItemOrder,procedurecode.ProcCode"; return(Db.GetTable(command)); }
///<summary>only if ClientWeb</summary> public static void FillCache(DataSet ds, params InvalidType[] arrayITypes) { List <InvalidType> listITypes = arrayITypes.ToList(); bool isAll = false; if (listITypes.Contains(InvalidType.AllLocal)) { isAll = true; } //All Internal OD Tables that are cached go here if (PrefC.IsODHQ) { if (listITypes.Contains(InvalidType.JobPermission) || isAll) { ds.Tables.Add(JobPermissions.RefreshCache()); } if (listITypes.Contains(InvalidType.PhoneComps) || isAll) { PhoneComps.FillCacheFromTable(ds.Tables["PhoneComp"]); } } if (listITypes.Contains(InvalidType.AccountingAutoPays) || isAll) { AccountingAutoPays.FillCacheFromTable(ds.Tables["AccountingAutoPay"]); } //if(listITypes.Contains(InvalidType.AlertItems) || isAll) {//THIS IS NOT CACHED. But is used to make server run the alert logic in OpenDentalService. // AlertSubs.FillCache(ds.Tables["AlertItem"]); //} if (listITypes.Contains(InvalidType.AlertCategories) || isAll) { AlertCategories.FillCacheFromTable(ds.Tables["AlertCategory"]); } if (listITypes.Contains(InvalidType.AlertCategoryLinks) || isAll) { AlertCategoryLinks.FillCacheFromTable(ds.Tables["AlertCategoryLink"]); } if (listITypes.Contains(InvalidType.AppointmentTypes) || isAll) { AppointmentTypes.FillCacheFromTable(ds.Tables["AppointmentType"]); } if (listITypes.Contains(InvalidType.AutoCodes) || isAll) { AutoCodes.FillCacheFromTable(ds.Tables["AutoCode"]); AutoCodeItems.FillCacheFromTable(ds.Tables["AutoCodeItem"]); AutoCodeConds.FillCacheFromTable(ds.Tables["AutoCodeCond"]); } if (listITypes.Contains(InvalidType.Automation) || isAll) { Automations.FillCacheFromTable(ds.Tables["Automation"]); } if (listITypes.Contains(InvalidType.AutoNotes) || isAll) { AutoNotes.FillCacheFromTable(ds.Tables["AutoNote"]); AutoNoteControls.FillCacheFromTable(ds.Tables["AutoNoteControl"]); } if (listITypes.Contains(InvalidType.Carriers) || isAll) { Carriers.FillCacheFromTable(ds.Tables["Carrier"]); //run on startup, after telephone reformat, after list edit. } if (listITypes.Contains(InvalidType.ClaimForms) || isAll) { ClaimFormItems.FillCacheFromTable(ds.Tables["ClaimFormItem"]); ClaimForms.FillCacheFromTable(ds.Tables["ClaimForm"]); } if (listITypes.Contains(InvalidType.ClearHouses) || isAll) { Clearinghouses.FillCacheFromTable(ds.Tables["Clearinghouse"]); } if (listITypes.Contains(InvalidType.ClinicErxs) || isAll) { ClinicErxs.FillCacheFromTable(ds.Tables["ClinicErx"]); } if (listITypes.Contains(InvalidType.ClinicPrefs) || isAll) { ClinicPrefs.FillCacheFromTable(ds.Tables["ClinicPref"]); } if (listITypes.Contains(InvalidType.Computers) || isAll) { Computers.FillCacheFromTable(ds.Tables["Computer"]); Printers.FillCacheFromTable(ds.Tables["Printer"]); } if (listITypes.Contains(InvalidType.Defs) || isAll) { Defs.FillCacheFromTable(ds.Tables["Def"]); } if (listITypes.Contains(InvalidType.DentalSchools) || isAll) { SchoolClasses.FillCacheFromTable(ds.Tables["SchoolClass"]); SchoolCourses.FillCacheFromTable(ds.Tables["SchoolCourse"]); } if (listITypes.Contains(InvalidType.DictCustoms) || isAll) { DictCustoms.FillCacheFromTable(ds.Tables["DictCustom"]); } if (listITypes.Contains(InvalidType.Diseases) || isAll) { DiseaseDefs.FillCacheFromTable(ds.Tables["DiseaseDef"]); ICD9s.FillCacheFromTable(ds.Tables["ICD9"]); } if (listITypes.Contains(InvalidType.DisplayFields) || isAll) { DisplayFields.FillCacheFromTable(ds.Tables["DisplayField"]); } if (listITypes.Contains(InvalidType.DisplayReports) || isAll) { DisplayReports.FillCacheFromTable(ds.Tables["DisplayReport"]); } if (listITypes.Contains(InvalidType.Ebills) || isAll) { Ebills.FillCacheFromTable(ds.Tables["Ebill"]); } if (listITypes.Contains(InvalidType.ElectIDs) || isAll) { ElectIDs.FillCacheFromTable(ds.Tables["ElectID"]); } if (listITypes.Contains(InvalidType.Email) || isAll) { EmailAddresses.FillCacheFromTable(ds.Tables["EmailAddress"]); EmailTemplates.FillCacheFromTable(ds.Tables["EmailTemplate"]); } if (listITypes.Contains(InvalidType.Employees) || isAll) { Employees.FillCacheFromTable(ds.Tables["Employee"]); PayPeriods.FillCacheFromTable(ds.Tables["PayPeriod"]); } if (listITypes.Contains(InvalidType.Employers) || isAll) { Employers.FillCacheFromTable(ds.Tables["Employer"]); } if (listITypes.Contains(InvalidType.Fees) || isAll) { Fees.FillCacheFromTable(ds.Tables["Fee"]); } if (listITypes.Contains(InvalidType.FeeScheds) || isAll) { FeeScheds.FillCacheFromTable(ds.Tables["FeeSched"]); } if (listITypes.Contains(InvalidType.HL7Defs) || isAll) { HL7Defs.FillCacheFromTable(ds.Tables["HL7Def"]); HL7DefMessages.FillCacheFromTable(ds.Tables["HL7DefMessage"]); HL7DefSegments.FillCacheFromTable(ds.Tables["HL7DefSegment"]); HL7DefFields.FillCacheFromTable(ds.Tables["HL7DefField"]); } if (listITypes.Contains(InvalidType.InsCats) || isAll) { CovCats.FillCacheFromTable(ds.Tables["CovCat"]); CovSpans.FillCacheFromTable(ds.Tables["CovSpan"]); } if (listITypes.Contains(InvalidType.InsFilingCodes) || isAll) { InsFilingCodes.FillCacheFromTable(ds.Tables["InsFilingCode"]); InsFilingCodeSubtypes.FillCacheFromTable(ds.Tables["InsFilingCodeSubtype"]); } if (listITypes.Contains(InvalidType.Languages) || isAll) { Lans.FillCacheFromTable(ds.Tables["Language"]); } if (listITypes.Contains(InvalidType.Letters) || isAll) { Letters.FillCacheFromTable(ds.Tables["Letter"]); } if (listITypes.Contains(InvalidType.LetterMerge) || isAll) { LetterMergeFields.FillCacheFromTable(ds.Tables["LetterMergeField"]); LetterMerges.FillCacheFromTable(ds.Tables["LetterMerge"]); } if (listITypes.Contains(InvalidType.Medications) || isAll) { Medications.FillCacheFromTable(ds.Tables["Medication"]); } if (listITypes.Contains(InvalidType.Operatories) || isAll) { Operatories.FillCacheFromTable(ds.Tables["Operatory"]); } if (listITypes.Contains(InvalidType.OrthoChartTabs) || isAll) { OrthoChartTabs.FillCacheFromTable(ds.Tables["OrthoChartTab"]); OrthoChartTabLinks.FillCacheFromTable(ds.Tables["OrthoChartTabLink"]); } if (listITypes.Contains(InvalidType.PatFields) || isAll) { PatFieldDefs.FillCacheFromTable(ds.Tables["PatFieldDef"]); ApptFieldDefs.FillCacheFromTable(ds.Tables["ApptFieldDef"]); } if (listITypes.Contains(InvalidType.Pharmacies) || isAll) { Pharmacies.FillCacheFromTable(ds.Tables["Pharmacy"]); } if (listITypes.Contains(InvalidType.Prefs) || isAll) { Prefs.FillCacheFromTable(ds.Tables["Pref"]); } if (listITypes.Contains(InvalidType.ProcButtons) || isAll) { ProcButtons.FillCacheFromTable(ds.Tables["ProcButton"]); ProcButtonItems.FillCacheFromTable(ds.Tables["ProcButtonItem"]); } if (listITypes.Contains(InvalidType.ProcCodes) || isAll) { ProcedureCodes.FillCacheFromTable(ds.Tables["ProcedureCode"]); ProcCodeNotes.FillCacheFromTable(ds.Tables["ProcCodeNote"]); } if (listITypes.Contains(InvalidType.Programs) || isAll) { Programs.FillCacheFromTable(ds.Tables["Program"]); ProgramProperties.FillCacheFromTable(ds.Tables["ProgramProperty"]); } if (listITypes.Contains(InvalidType.ProviderErxs) || isAll) { ProviderErxs.FillCacheFromTable(ds.Tables["ProviderErx"]); } if (listITypes.Contains(InvalidType.ProviderIdents) || isAll) { ProviderIdents.FillCacheFromTable(ds.Tables["ProviderIdent"]); } if (listITypes.Contains(InvalidType.Providers) || isAll) { Providers.FillCacheFromTable(ds.Tables["Provider"]); //Refresh the clinics as well because InvalidType.Providers has a comment that says "also includes clinics". Also, there currently isn't an itype for Clinics. Clinics.FillCacheFromTable(ds.Tables["clinic"]); //Case must match the table name in Clinics.RefrechCache(). } if (listITypes.Contains(InvalidType.QuickPaste) || isAll) { QuickPasteNotes.FillCacheFromTable(ds.Tables["QuickPasteNote"]); QuickPasteCats.FillCacheFromTable(ds.Tables["QuickPasteCat"]); } if (listITypes.Contains(InvalidType.RecallTypes) || isAll) { RecallTypes.FillCacheFromTable(ds.Tables["RecallType"]); RecallTriggers.FillCacheFromTable(ds.Tables["RecallTrigger"]); } if (listITypes.Contains(InvalidType.ReplicationServers) || isAll) { ReplicationServers.FillCacheFromTable(ds.Tables["ReplicationServer"]); } //if(itypes.Contains(InvalidType.RequiredFields) || isAll) { // RequiredFields.FillCache(ds.Tables["RequiredField"]); //} if (listITypes.Contains(InvalidType.Security) || isAll) { Userods.FillCacheFromTable(ds.Tables["Userod"]); UserGroups.FillCacheFromTable(ds.Tables["UserGroup"]); UserGroupAttaches.FillCacheFromTable(ds.Tables["UserGroupAttach"]); } if (listITypes.Contains(InvalidType.Sheets) || isAll) { SheetDefs.FillCacheFromTable(ds.Tables["SheetDef"]); SheetFieldDefs.FillCacheFromTable(ds.Tables["SheetFieldDef"]); } if (listITypes.Contains(InvalidType.SigMessages) || isAll) { SigElementDefs.FillCacheFromTable(ds.Tables["SigElementDef"]); SigButDefs.FillCacheFromTable(ds.Tables["SigButDef"]); } if (listITypes.Contains(InvalidType.Sites) || isAll) { Sites.FillCacheFromTable(ds.Tables["Site"]); if (PrefC.IsODHQ) { SiteLinks.FillCacheFromTable(ds.Tables["SiteLink"]); } } if (listITypes.Contains(InvalidType.SmsBlockPhones) || isAll) { SmsBlockPhones.FillCacheFromTable(ds.Tables["SmsBlockPhone"]); } if (listITypes.Contains(InvalidType.SmsPhones) || isAll) { SmsPhones.FillCacheFromTable(ds.Tables["SmsPhone"]); } if (listITypes.Contains(InvalidType.Sops) || isAll) { Sops.FillCacheFromTable(ds.Tables["Sop"]); } if (listITypes.Contains(InvalidType.StateAbbrs) || isAll) { StateAbbrs.FillCacheFromTable(ds.Tables["StateAbbr"]); } if (listITypes.Contains(InvalidType.TimeCardRules) || isAll) { TimeCardRules.FillCacheFromTable(ds.Tables["TimeCardRule"]); } //InvalidTypes.Tasks not handled here. if (listITypes.Contains(InvalidType.ToolBut) || isAll) { ToolButItems.FillCacheFromTable(ds.Tables["ToolButItem"]); } if (listITypes.Contains(InvalidType.UserClinics) || isAll) { UserClinics.FillCacheFromTable(ds.Tables["UserClinic"]); } if (listITypes.Contains(InvalidType.UserQueries) || isAll) { UserQueries.FillCacheFromTable(ds.Tables["UserQuery"]); } if (listITypes.Contains(InvalidType.Vaccines) || isAll) { VaccineDefs.FillCacheFromTable(ds.Tables["VaccineDef"]); DrugManufacturers.FillCacheFromTable(ds.Tables["DrugManufacturer"]); DrugUnits.FillCacheFromTable(ds.Tables["DrugUnit"]); } if (listITypes.Contains(InvalidType.Views) || isAll) { ApptViews.FillCacheFromTable(ds.Tables["ApptView"]); ApptViewItems.FillCacheFromTable(ds.Tables["ApptViewItem"]); AppointmentRules.FillCacheFromTable(ds.Tables["AppointmentRule"]); ProcApptColors.FillCacheFromTable(ds.Tables["ProcApptColor"]); } if (listITypes.Contains(InvalidType.Wiki) || isAll) { WikiListHeaderWidths.FillCacheFromTable(ds.Tables["WikiListHeaderWidth"]); WikiPages.FillCache(ds.Tables["WikiPage"]); } if (listITypes.Contains(InvalidType.ZipCodes) || isAll) { ZipCodes.FillCacheFromTable(ds.Tables["ZipCode"]); } }
///<summary>Load the dictionary with the non-hidden fee schedule fees for each of the clinics currently in the queue.</summary> public void Initialize() { List <long> listFeeScheds = FeeScheds.GetDeepCopy(true).Select(x => x.FeeSchedNum).ToList(); _dict = new FeeCacheDictionary(Fees.GetByFeeSchedNumsClinicNums(listFeeScheds, _queueClinicNums.ToList())); }
///<summary>If ClientWeb, then this method is instead run on the server, and the result passed back to the client. And since it's ClientWeb, FillCache will be run on the client.</summary> public static DataSet GetCacheDs(bool doRefreshServerCache, params InvalidType[] arrayITypes) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetDS(MethodBase.GetCurrentMethod(), doRefreshServerCache, arrayITypes)); } Logger.LogToPath("", LogPath.Signals, LogPhase.Start, "InvalidType(s): " + string.Join(" - ", arrayITypes.OrderBy(x => x.ToString()))); List <InvalidType> listITypes = arrayITypes.ToList(); //so this part below only happens if direct or server------------------------------------------------ bool isAll = false; if (listITypes.Contains(InvalidType.AllLocal)) { isAll = true; } DataSet ds = new DataSet(); //All Internal OD Tables that are cached go here if (PrefC.IsODHQ) { if (listITypes.Contains(InvalidType.JobPermission) || isAll) { ds.Tables.Add(JobPermissions.RefreshCache()); } if (listITypes.Contains(InvalidType.PhoneComps) || isAll) { ds.Tables.Add(PhoneComps.GetTableFromCache(doRefreshServerCache)); } } //All cached public tables go here if (listITypes.Contains(InvalidType.AccountingAutoPays) || isAll) { ds.Tables.Add(AccountingAutoPays.GetTableFromCache(doRefreshServerCache)); } //if(listITypes.Contains(InvalidType.AlertItems) || isAll) {//THIS IS NOT CACHED. But is used to make server run the alert logic in OpenDentalService. // ds.Tables.Add(AlertItems.RefreshCache()); //} if (listITypes.Contains(InvalidType.AlertCategories) || isAll) { ds.Tables.Add(AlertCategories.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.AlertCategoryLinks) || isAll) { ds.Tables.Add(AlertCategoryLinks.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.AppointmentTypes) || isAll) { ds.Tables.Add(AppointmentTypes.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.AutoCodes) || isAll) { ds.Tables.Add(AutoCodes.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(AutoCodeItems.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(AutoCodeConds.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Automation) || isAll) { ds.Tables.Add(Automations.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.AutoNotes) || isAll) { ds.Tables.Add(AutoNotes.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(AutoNoteControls.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Carriers) || isAll) { ds.Tables.Add(Carriers.GetTableFromCache(doRefreshServerCache)); //run on startup, after telephone reformat, after list edit. } if (listITypes.Contains(InvalidType.ClaimForms) || isAll) { ds.Tables.Add(ClaimFormItems.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(ClaimForms.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.ClearHouses) || isAll) { ds.Tables.Add(Clearinghouses.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.ClinicErxs) || isAll) { ds.Tables.Add(ClinicErxs.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.ClinicPrefs) || isAll) { ds.Tables.Add(ClinicPrefs.GetTableFromCache(doRefreshServerCache)); } //InvalidType.Clinics see InvalidType.Providers if (listITypes.Contains(InvalidType.Computers) || isAll) { ds.Tables.Add(Computers.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(Printers.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Defs) || isAll) { ds.Tables.Add(Defs.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.DentalSchools) || isAll) { ds.Tables.Add(SchoolClasses.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(SchoolCourses.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.DictCustoms) || isAll) { ds.Tables.Add(DictCustoms.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Diseases) || isAll) { ds.Tables.Add(DiseaseDefs.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(ICD9s.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.DisplayFields) || isAll) { ds.Tables.Add(DisplayFields.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.DisplayReports) || isAll) { ds.Tables.Add(DisplayReports.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Ebills) || isAll) { ds.Tables.Add(Ebills.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.EhrCodes)) { EhrCodes.UpdateList(); //Unusual pattern for an unusual "table". Not really a table, but a mishmash of hard coded partial code systems that are needed for CQMs. } if (listITypes.Contains(InvalidType.ElectIDs) || isAll) { ds.Tables.Add(ElectIDs.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Email) || isAll) { ds.Tables.Add(EmailAddresses.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(EmailTemplates.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(EmailAutographs.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Employees) || isAll) { ds.Tables.Add(Employees.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(PayPeriods.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Employers) || isAll) { ds.Tables.Add(Employers.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Fees) || isAll) { //Fee Cache follows an unusual pattern. This fills the cache with the HQ fees, and whatever clinics happen to be currently cached. ds.Tables.Add(Fees.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.FeeScheds) || isAll) { ds.Tables.Add(FeeScheds.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.HL7Defs) || isAll) { ds.Tables.Add(HL7Defs.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(HL7DefMessages.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(HL7DefSegments.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(HL7DefFields.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.InsCats) || isAll) { ds.Tables.Add(CovCats.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(CovSpans.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.InsFilingCodes) || isAll) { ds.Tables.Add(InsFilingCodes.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(InsFilingCodeSubtypes.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Languages) || isAll) { if (CultureInfo.CurrentCulture.Name != "en-US") { ds.Tables.Add(Lans.GetTableFromCache(doRefreshServerCache)); } } if (listITypes.Contains(InvalidType.Letters) || isAll) { ds.Tables.Add(Letters.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.LetterMerge) || isAll) { ds.Tables.Add(LetterMergeFields.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(LetterMerges.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Medications) || isAll) { ds.Tables.Add(Medications.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Operatories) || isAll) { ds.Tables.Add(Operatories.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.OrthoChartTabs) || isAll) { ds.Tables.Add(OrthoChartTabs.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(OrthoChartTabLinks.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.PatFields) || isAll) { ds.Tables.Add(PatFieldDefs.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(ApptFieldDefs.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Pharmacies) || isAll) { ds.Tables.Add(Pharmacies.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Prefs) || isAll) { ds.Tables.Add(Prefs.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.ProcButtons) || isAll) { ds.Tables.Add(ProcButtons.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(ProcButtonItems.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.ProcCodes) || isAll) { ds.Tables.Add(ProcedureCodes.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(ProcCodeNotes.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Programs) || isAll) { ds.Tables.Add(Programs.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(ProgramProperties.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.ProviderErxs) || isAll) { ds.Tables.Add(ProviderErxs.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.ProviderIdents) || isAll) { ds.Tables.Add(ProviderIdents.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Providers) || isAll) { ds.Tables.Add(Providers.GetTableFromCache(doRefreshServerCache)); //Refresh the clinics as well because InvalidType.Providers has a comment that says "also includes clinics". Also, there currently isn't an itype for Clinics. ds.Tables.Add(Clinics.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.QuickPaste) || isAll) { ds.Tables.Add(QuickPasteNotes.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(QuickPasteCats.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.RecallTypes) || isAll) { ds.Tables.Add(RecallTypes.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(RecallTriggers.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.ReplicationServers) || isAll) { ds.Tables.Add(ReplicationServers.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.RequiredFields) || isAll) { ds.Tables.Add(RequiredFields.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(RequiredFieldConditions.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Security) || isAll) { ds.Tables.Add(Userods.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(UserGroups.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(GroupPermissions.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(UserGroupAttaches.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Sheets) || isAll) { ds.Tables.Add(SheetDefs.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(SheetFieldDefs.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.SigMessages) || isAll) { ds.Tables.Add(SigElementDefs.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(SigButDefs.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Sites) || isAll) { ds.Tables.Add(Sites.GetTableFromCache(doRefreshServerCache)); if (PrefC.IsODHQ) { ds.Tables.Add(SiteLinks.GetTableFromCache(doRefreshServerCache)); } } if (listITypes.Contains(InvalidType.SmsBlockPhones) || isAll) { ds.Tables.Add(SmsBlockPhones.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.SmsPhones) || isAll) { ds.Tables.Add(SmsPhones.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Sops) || isAll) //InvalidType.Sops is currently never used 11/14/2014 { ds.Tables.Add(Sops.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.StateAbbrs) || isAll) { ds.Tables.Add(StateAbbrs.GetTableFromCache(doRefreshServerCache)); } //InvalidTypes.Tasks not handled here. if (listITypes.Contains(InvalidType.TimeCardRules) || isAll) { ds.Tables.Add(TimeCardRules.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.ToolBut) || isAll) { ds.Tables.Add(ToolButItems.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.UserClinics) || isAll) { ds.Tables.Add(UserClinics.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.UserQueries) || isAll) { ds.Tables.Add(UserQueries.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Vaccines) || isAll) { ds.Tables.Add(VaccineDefs.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(DrugManufacturers.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(DrugUnits.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Views) || isAll) { ds.Tables.Add(ApptViews.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(ApptViewItems.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(AppointmentRules.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(ProcApptColors.GetTableFromCache(doRefreshServerCache)); } if (listITypes.Contains(InvalidType.Wiki) || isAll) { ds.Tables.Add(WikiListHeaderWidths.GetTableFromCache(doRefreshServerCache)); ds.Tables.Add(WikiPages.RefreshCache()); } if (listITypes.Contains(InvalidType.ZipCodes) || isAll) { ds.Tables.Add(ZipCodes.GetTableFromCache(doRefreshServerCache)); } Logger.LogToPath("", LogPath.Signals, LogPhase.End); return(ds); }
///<summary>only if ClientWeb</summary> public static void FillCache(DataSet ds, string itypesStr) { List <int> itypes = new List <int>(); string[] strArray = itypesStr.Split(','); for (int i = 0; i < strArray.Length; i++) { itypes.Add(PIn.Int(strArray[i])); } bool isAll = false; if (itypes.Contains((int)InvalidType.AllLocal)) { isAll = true; } if (itypes.Contains((int)InvalidType.AccountingAutoPays) || isAll) { AccountingAutoPays.FillCache(ds.Tables["AccountingAutoPay"]); } if (itypes.Contains((int)InvalidType.AutoCodes) || isAll) { AutoCodes.FillCache(ds.Tables["AutoCode"]); AutoCodeItems.FillCache(ds.Tables["AutoCodeItem"]); AutoCodeConds.FillCache(ds.Tables["AutoCodeCond"]); } if (itypes.Contains((int)InvalidType.Automation) || isAll) { Automations.FillCache(ds.Tables["Automation"]); } if (itypes.Contains((int)InvalidType.AutoNotes) || isAll) { AutoNotes.FillCache(ds.Tables["AutoNote"]); AutoNoteControls.FillCache(ds.Tables["AutoNoteControl"]); } if (itypes.Contains((int)InvalidType.Carriers) || isAll) { Carriers.FillCache(ds.Tables["Carrier"]); //run on startup, after telephone reformat, after list edit. } if (itypes.Contains((int)InvalidType.ClaimForms) || isAll) { ClaimFormItems.FillCache(ds.Tables["ClaimFormItem"]); ClaimForms.FillCache(ds.Tables["ClaimForm"]); } if (itypes.Contains((int)InvalidType.ClearHouses) || isAll) { Clearinghouses.FillCache(ds.Tables["Clearinghouse"]); //kh wants to add an EasyHideClearHouses to disable this } if (itypes.Contains((int)InvalidType.Computers) || isAll) { Computers.FillCache(ds.Tables["Computer"]); Printers.FillCache(ds.Tables["Printer"]); } if (itypes.Contains((int)InvalidType.Defs) || isAll) { Defs.FillCache(ds.Tables["Def"]); } if (itypes.Contains((int)InvalidType.DentalSchools) || isAll) { SchoolClasses.FillCache(ds.Tables["SchoolClass"]); SchoolCourses.FillCache(ds.Tables["SchoolCourse"]); } if (itypes.Contains((int)InvalidType.DictCustoms) || isAll) { DictCustoms.FillCache(ds.Tables["DictCustom"]); } if (itypes.Contains((int)InvalidType.Diseases) || isAll) { DiseaseDefs.FillCache(ds.Tables["DiseaseDef"]); ICD9s.FillCache(ds.Tables["ICD9"]); } if (itypes.Contains((int)InvalidType.DisplayFields) || isAll) { DisplayFields.FillCache(ds.Tables["DisplayField"]); } if (itypes.Contains((int)InvalidType.ElectIDs) || isAll) { ElectIDs.FillCache(ds.Tables["ElectID"]); } if (itypes.Contains((int)InvalidType.Email) || isAll) { EmailAddresses.FillCache(ds.Tables["EmailAddress"]); EmailTemplates.FillCache(ds.Tables["EmailTemplate"]); } if (itypes.Contains((int)InvalidType.Employees) || isAll) { Employees.FillCache(ds.Tables["Employee"]); PayPeriods.FillCache(ds.Tables["PayPeriod"]); } if (itypes.Contains((int)InvalidType.Employers) || isAll) { Employers.FillCache(ds.Tables["Employer"]); } if (itypes.Contains((int)InvalidType.Fees) || isAll) { Fees.FillCache(ds.Tables["Fee"]); } if (itypes.Contains((int)InvalidType.FeeScheds) || isAll) { FeeScheds.FillCache(ds.Tables["FeeSched"]); } if (itypes.Contains((int)InvalidType.HL7Defs) || isAll) { HL7Defs.FillCache(ds.Tables["HL7Def"]); HL7DefMessages.FillCache(ds.Tables["HL7DefMessage"]); HL7DefSegments.FillCache(ds.Tables["HL7DefSegment"]); HL7DefFields.FillCache(ds.Tables["HL7DefField"]); } if (itypes.Contains((int)InvalidType.InsCats) || isAll) { CovCats.FillCache(ds.Tables["CovCat"]); CovSpans.FillCache(ds.Tables["CovSpan"]); } if (itypes.Contains((int)InvalidType.InsFilingCodes) || isAll) { InsFilingCodes.FillCache(ds.Tables["InsFilingCode"]); InsFilingCodeSubtypes.FillCache(ds.Tables["InsFilingCodeSubtype"]); } if (itypes.Contains((int)InvalidType.Languages) || isAll) { Lans.FillCache(ds.Tables["Language"]); } if (itypes.Contains((int)InvalidType.Letters) || isAll) { Letters.FillCache(ds.Tables["Letter"]); } if (itypes.Contains((int)InvalidType.LetterMerge) || isAll) { LetterMergeFields.FillCache(ds.Tables["LetterMergeField"]); LetterMerges.FillCache(ds.Tables["LetterMerge"]); } if (itypes.Contains((int)InvalidType.Operatories) || isAll) { Operatories.FillCache(ds.Tables["Operatory"]); } if (itypes.Contains((int)InvalidType.PatFields) || isAll) { PatFieldDefs.FillCache(ds.Tables["PatFieldDef"]); ApptFieldDefs.FillCache(ds.Tables["ApptFieldDef"]); } if (itypes.Contains((int)InvalidType.Pharmacies) || isAll) { Pharmacies.FillCache(ds.Tables["Pharmacy"]); } if (itypes.Contains((int)InvalidType.Prefs) || isAll) { Prefs.FillCache(ds.Tables["Pref"]); } if (itypes.Contains((int)InvalidType.ProcButtons) || isAll) { ProcButtons.FillCache(ds.Tables["ProcButton"]); ProcButtonItems.FillCache(ds.Tables["ProcButtonItem"]); } if (itypes.Contains((int)InvalidType.ProcCodes) || isAll) { ProcedureCodes.FillCache(ds.Tables["ProcedureCode"]); ProcCodeNotes.FillCache(ds.Tables["ProcCodeNote"]); } if (itypes.Contains((int)InvalidType.Programs) || isAll) { Programs.FillCache(ds.Tables["Program"]); ProgramProperties.FillCache(ds.Tables["ProgramProperty"]); } if (itypes.Contains((int)InvalidType.ProviderIdents) || isAll) { ProviderIdents.FillCache(ds.Tables["ProviderIdent"]); } if (itypes.Contains((int)InvalidType.Providers) || isAll) { Providers.FillCache(ds.Tables["Provider"]); } if (itypes.Contains((int)InvalidType.QuickPaste) || isAll) { QuickPasteNotes.FillCache(ds.Tables["QuickPasteNote"]); QuickPasteCats.FillCache(ds.Tables["QuickPasteCat"]); } if (itypes.Contains((int)InvalidType.RecallTypes) || isAll) { RecallTypes.FillCache(ds.Tables["RecallType"]); RecallTriggers.FillCache(ds.Tables["RecallTrigger"]); } if (itypes.Contains((int)InvalidType.ReplicationServers) || isAll) { ReplicationServers.FillCache(ds.Tables["ReplicationServer"]); } if (itypes.Contains((int)InvalidType.Security) || isAll) { Userods.FillCache(ds.Tables["Userod"]); UserGroups.FillCache(ds.Tables["UserGroup"]); } if (itypes.Contains((int)InvalidType.Sheets) || isAll) { SheetDefs.FillCache(ds.Tables["SheetDef"]); SheetFieldDefs.FillCache(ds.Tables["SheetFieldDef"]); } if (itypes.Contains((int)InvalidType.Signals) || isAll) { SigElementDefs.FillCache(ds.Tables["SigElementDef"]); SigButDefs.FillCache(ds.Tables["SigButDef"]); //includes SigButDefElements.Refresh() } if (itypes.Contains((int)InvalidType.Sites) || isAll) { Sites.FillCache(ds.Tables["Site"]); } if (itypes.Contains((int)InvalidType.Sops) || isAll) { Sops.FillCache(ds.Tables["Sop"]); } if (itypes.Contains((int)InvalidType.TimeCardRules) || isAll) { TimeCardRules.FillCache(ds.Tables["TimeCardRule"]); } //InvalidTypes.Tasks not handled here. if (itypes.Contains((int)InvalidType.ToolBut) || isAll) { ToolButItems.FillCache(ds.Tables["ToolButItem"]); } if (itypes.Contains((int)InvalidType.Vaccines) || isAll) { VaccineDefs.FillCache(ds.Tables["VaccineDef"]); DrugManufacturers.FillCache(ds.Tables["DrugManufacturer"]); DrugUnits.FillCache(ds.Tables["DrugUnit"]); } if (itypes.Contains((int)InvalidType.Views) || isAll) { ApptViews.FillCache(ds.Tables["ApptView"]); ApptViewItems.FillCache(ds.Tables["ApptViewItem"]); AppointmentRules.FillCache(ds.Tables["AppointmentRule"]); ProcApptColors.FillCache(ds.Tables["ProcApptColor"]); } if (itypes.Contains((int)InvalidType.Wiki) || isAll) { WikiListHeaderWidths.FillCache(ds.Tables["WikiListHeaderWidth"]); WikiPages.FillCache(ds.Tables["WikiPage"]); } if (itypes.Contains((int)InvalidType.ZipCodes) || isAll) { ZipCodes.FillCache(ds.Tables["ZipCode"]); } }