///<summary>Replaces all clinic-level fields in ClearinghouseHq with non-blank fields
///from the clinic-level clearinghouse for the passed-in clinicNum. Non clinic-level fields are not replaced.</summary>
public static Clearinghouse OverrideFields(Clearinghouse clearinghouseHq, long clinicNum)
{
//No need to check RemotingRole; no call to db.
Clearinghouse clearinghouseClin = Clearinghouses.GetForClinic(clearinghouseHq, clinicNum);
return(OverrideFields(clearinghouseHq, clearinghouseClin));
}
private static void RetrieveReportsAutomaticHelper(Clearinghouse clearinghouseClin, Clearinghouse clearinghouseHq, long defaultClearingHouseNum
, bool isTimeToRetrieve)
{
if (!Directory.Exists(clearinghouseClin.ResponsePath))
{
return;
}
if (clearinghouseHq.ClearinghouseNum == defaultClearingHouseNum) //If it's the default dental clearinghouse
{
RetrieveAndImport(clearinghouseClin, true, isTimeToRetrieve: isTimeToRetrieve);
}
else if (clearinghouseHq.Eformat == ElectronicClaimFormat.None) //And the format is "None" (accessed from all regions)
{
RetrieveAndImport(clearinghouseClin, true, isTimeToRetrieve: isTimeToRetrieve);
}
else if (clearinghouseHq.CommBridge == EclaimsCommBridge.BCBSGA)
{
BCBSGA.Retrieve(clearinghouseClin, true, new TerminalConnector());
}
else if (clearinghouseHq.Eformat == ElectronicClaimFormat.Canadian && CultureInfo.CurrentCulture.Name.EndsWith("CA"))
{
//Or the Eformat is Canadian and the region is Canadian. In Canada, the "Outstanding Reports" are received upon request.
//Canadian reports must be retrieved using an office num and valid provider number for the office,
//which will cause all reports for that office to be returned.
//Here we loop through all providers and find CDAnet providers with a valid provider number and office number, and we only send
//one report download request for one provider from each office. For most offices, the loop will only send a single request.
List <Provider> listProvs = Providers.GetDeepCopy(true);
List <string> listOfficeNums = new List <string>();
for (int j = 0; j < listProvs.Count; j++) //Get all unique office numbers from the providers.
{
if (!listProvs[j].IsCDAnet || listProvs[j].NationalProvID == "" || listProvs[j].CanadianOfficeNum == "")
{
continue;
}
if (!listOfficeNums.Contains(listProvs[j].CanadianOfficeNum)) //Ignore duplicate office numbers.
{
listOfficeNums.Add(listProvs[j].CanadianOfficeNum);
try {
clearinghouseHq = Eclaims.Canadian.GetCanadianClearinghouseHq(null);
clearinghouseClin = Clearinghouses.OverrideFields(clearinghouseHq, Clinics.ClinicNum);
Eclaims.CanadianOutput.GetOutstandingTransactions(clearinghouseClin, false, true, null, listProvs[j], true, null, null);
}
catch {
//Supress errors importing reports.
}
}
}
}
else if (clearinghouseHq.Eformat == ElectronicClaimFormat.Dutch && CultureInfo.CurrentCulture.Name.EndsWith("DE"))
{
//Or the Eformat is German and the region is German
RetrieveAndImport(clearinghouseClin, true, isTimeToRetrieve: isTimeToRetrieve);
}
else if (clearinghouseHq.Eformat != ElectronicClaimFormat.Canadian &&
clearinghouseHq.Eformat != ElectronicClaimFormat.Dutch &&
CultureInfo.CurrentCulture.Name.EndsWith("US")) //Or the Eformat is in any other format and the region is US
{
RetrieveAndImport(clearinghouseClin, true, isTimeToRetrieve: isTimeToRetrieve);
}
}
///<summary>Called from claimsend window and from Claim edit window. Use 0 to get all waiting claims, or an actual claimnum to get just one claim.</summary>
public static ClaimSendQueueItem[] GetQueueList(long claimNum, long clinicNum, long customTracking)
{
if (RemotingClient.RemotingRole == RemotingRole.ClientWeb)
{
return(Meth.GetObject <ClaimSendQueueItem[]>(MethodBase.GetCurrentMethod(), claimNum, clinicNum, customTracking));
}
string command =
"SELECT claim.ClaimNum,carrier.NoSendElect"
+ ",CONCAT(CONCAT(CONCAT(concat(patient.LName,', '),patient.FName),' '),patient.MiddleI)"
+ ",claim.ClaimStatus,carrier.CarrierName,patient.PatNum,carrier.ElectID,MedType,claim.DateService,claim.ClinicNum "
+ "FROM claim "
+ "Left join insplan on claim.PlanNum = insplan.PlanNum "
+ "Left join carrier on insplan.CarrierNum = carrier.CarrierNum "
+ "Left join patient on patient.PatNum = claim.PatNum ";
if (claimNum == 0)
{
command += "WHERE (claim.ClaimStatus = 'W' OR claim.ClaimStatus = 'P') ";
}
else
{
command += "WHERE claim.ClaimNum=" + POut.Long(claimNum) + " ";
}
if (clinicNum > 0)
{
command += "AND claim.ClinicNum=" + POut.Long(clinicNum) + " ";
}
if (customTracking > 0)
{
command += "AND claim.CustomTracking=" + POut.Long(customTracking) + " ";
}
command += "ORDER BY claim.DateService,patient.LName";
DataTable table = Db.GetTable(command);
ClaimSendQueueItem[] listQueue = new ClaimSendQueueItem[table.Rows.Count];
for (int i = 0; i < table.Rows.Count; i++)
{
listQueue[i] = new ClaimSendQueueItem();
listQueue[i].ClaimNum = PIn.Long(table.Rows[i][0].ToString());
listQueue[i].NoSendElect = PIn.Bool(table.Rows[i][1].ToString());
listQueue[i].PatName = PIn.String(table.Rows[i][2].ToString());
listQueue[i].ClaimStatus = PIn.String(table.Rows[i][3].ToString());
listQueue[i].Carrier = PIn.String(table.Rows[i][4].ToString());
listQueue[i].PatNum = PIn.Long(table.Rows[i][5].ToString());
string payorID = PIn.String(table.Rows[i]["ElectID"].ToString());
EnumClaimMedType medType = (EnumClaimMedType)PIn.Int(table.Rows[i]["MedType"].ToString());
listQueue[i].ClearinghouseNum = Clearinghouses.AutomateClearinghouseSelection(payorID, medType);
listQueue[i].MedType = medType;
listQueue[i].DateService = PIn.Date(table.Rows[i]["DateService"].ToString());
listQueue[i].ClinicNum = PIn.Long(table.Rows[i]["ClinicNum"].ToString());
}
return(listQueue);
}
///<summary>Replaces all clinic-level fields in ClearinghouseHq with non-blank fields
///from the clinic-level clearinghouse for the passed-in clinicNum. Non clinic-level fields are not replaced.
///If Clinics are disabled, uses clearinghouseHq settings.</summary>
public static Clearinghouse OverrideFields(Clearinghouse clearinghouseHq, long clinicNum)
{
//No need to check RemotingRole; no call to db.
//Do not use given clinicNum when clinics are disabled.
//Otherwise clinic level clearinghouse settings that were set when clinics were enabled would be used
//and user would have no way of fixing them unless they turned clinics back on.
//Use unassigned settings since they are what show in the UI when editing clearinghouse settings.
clinicNum = (PrefC.HasClinicsEnabled?clinicNum:0);
Clearinghouse clearinghouseClin = Clearinghouses.GetForClinic(clearinghouseHq, clinicNum);
return(OverrideFields(clearinghouseHq, clearinghouseClin));
}
///<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, 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>In progress. Probably needs a different name. Info must be validated first.
///Set dependent to the currently selected patient, compares dependent.PatNum to subscriber.PatNum to either contruct a subscriber based or dependent based benefit request.</summary>
public static string GenerateMessageText(Clearinghouse clearinghouseClin, Carrier carrier, Provider billProv, Clinic clinic, InsPlan insPlan, Patient subscriber, InsSub insSub, Patient patForRequest)
{
bool isSubscriberRequest = (subscriber.PatNum == patForRequest.PatNum);
int batchNum = Clearinghouses.GetNextBatchNumber(clearinghouseClin);
string groupControlNumber = batchNum.ToString(); //Must be unique within file. We will use batchNum
int transactionNum = 1;
StringBuilder strb = new StringBuilder();
//Interchange Control Header
strb.Append("ISA*00* *"); //ISA01,ISA02: 00 + 10 spaces
if (IsEmdeonDental(clearinghouseClin))
{
strb.Append("00*" + Sout(clearinghouseClin.Password, 10, 10) + "*" //ISA03,ISA04: 00 + emdeon password padded to 10 characters
+ clearinghouseClin.ISA05 + "*" //ISA05: Sender ID type: ZZ=mutually defined. 30=TIN. Validated
+ "316:" + Sout(clearinghouseClin.LoginID, 11, 11) + "*" //ISA06: Emdeon vendor number + username
+ clearinghouseClin.ISA07 + "*" //ISA07: Receiver ID type: ZZ=mutually defined. 30=TIN. Validated
+ Sout("EMDEONDENTAL", 15, 15) + "*"); //ISA08: Receiver ID. Validated to make sure length is at least 2.
}
else
{
strb.Append("00* *" //ISA03,ISA04: 00 + 10 spaces
+ clearinghouseClin.ISA05 + "*" //ISA05: Sender ID type: ZZ=mutually defined. 30=TIN. Validated
+ X12Generator.GetISA06(clearinghouseClin) + "*" //ISA06: Sender ID(TIN). Or might be TIN of Open Dental
+ clearinghouseClin.ISA07 + "*" //ISA07: Receiver ID type: ZZ=mutually defined. 30=TIN. Validated
+ Sout(clearinghouseClin.ISA08, 15, 15) + "*"); //ISA08: Receiver ID. Validated to make sure length is at least 2.
}
strb.AppendLine(DateTime.Today.ToString("yyMMdd") + "*" //ISA09: today's date
+ DateTime.Now.ToString("HHmm") + "*" //ISA10: current time
+ "U*00401*" //ISA11 and ISA12.
//ISA13: interchange control number, right aligned:
+ batchNum.ToString().PadLeft(9, '0') + "*"
+ "0*" //ISA14: no acknowledgment requested
+ clearinghouseClin.ISA15 + "*" //ISA15: T=Test P=Production. Validated.
+ ":~"); //ISA16: use ':'
//Functional Group Header
if (IsEmdeonDental(clearinghouseClin))
{
strb.Append("GS*HS*" //GS01: HS for 270 benefit inquiry
+ X12Generator.GetGS02(clearinghouseClin) + "*" //GS02: Senders Code. Sometimes Jordan Sparks. Sometimes the sending clinic.
+ Sout("EMDEONDENTAL", 15, 15) + "*"); //GS03: Application Receiver's Code
}
else
{
strb.Append("GS*HS*" //GS01: HS for 270 benefit inquiry
+ X12Generator.GetGS02(clearinghouseClin) + "*" //GS02: Senders Code. Sometimes Jordan Sparks. Sometimes the sending clinic.
+ Sout(clearinghouseClin.GS03, 15, 2) + "*"); //GS03: Application Receiver's Code
}
strb.AppendLine(DateTime.Today.ToString("yyyyMMdd") + "*" //GS04: today's date
+ DateTime.Now.ToString("HHmm") + "*" //GS05: current time
+ groupControlNumber + "*" //GS06: Group control number. Max length 9. No padding necessary.
+ "X*" //GS07: X
+ "004010X092~"); //GS08: Version
//Beginning of transaction--------------------------------------------------------------------------------
int seg = 0; //count segments for the ST-SE transaction
//Transaction Set Header
//ST02 Transact. control #. Must be unique within ISA
seg++;
strb.AppendLine("ST*270*" //ST01
+ transactionNum.ToString().PadLeft(4, '0') + "~"); //ST02
seg++;
strb.AppendLine("BHT*0022*13*" //BHT02: 13=request
+ transactionNum.ToString().PadLeft(4, '0') + "*" //BHT03. Can be same as ST02
+ DateTime.Now.ToString("yyyyMMdd") + "*" //BHT04: Date
+ DateTime.Now.ToString("HHmmss") + "~"); //BHT05: Time, BHT06: not used
//HL Loops-----------------------------------------------------------------------------------------------
int HLcount = 1;
//2000A HL: Information Source--------------------------------------------------------------------------
seg++;
strb.AppendLine("HL*" + HLcount.ToString() + "*" //HL01: Heirarchical ID. Here, it's always 1.
+ "*" //HL02: No parent. Not used
+ "20*" //HL03: Heirarchical level code. 20=Information source
+ "1~"); //HL04: Heirarchical child code. 1=child HL present
//2100A NM1
seg++;
strb.AppendLine("NM1*PR*" //NM101: PR=Payer
+ "2*" //NM102: 2=Non person
+ Sout(carrier.CarrierName, 35) + "*" //NM103: Name Last.
+ "****" //NM104-07 not used
+ "PI*" //NM108: PI=PayorID
+ Sout(carrier.ElectID, 80, 2) + "~"); //NM109: PayorID. Validated to be at least length of 2.
HLcount++;
//2000B HL: Information Receiver------------------------------------------------------------------------
seg++;
strb.AppendLine("HL*" + HLcount.ToString() + "*" //HL01: Heirarchical ID. Here, it's always 2.
+ "1*" //HL02: Heirarchical parent id number. 1 in this simple message.
+ "21*" //HL03: Heirarchical level code. 21=Information receiver
+ "1~"); //HL04: Heirarchical child code. 1=child HL present
seg++;
//2100B NM1: Information Receiver Name
strb.AppendLine("NM1*1P*" //NM101: 1P=Provider
+ (billProv.IsNotPerson?"2":"1") + "*" //NM102: 1=person,2=non-person
+ Sout(billProv.LName, 35) + "*" //NM103: Last name
+ Sout(billProv.FName, 25) + "*" //NM104: First name
+ Sout(billProv.MI, 25, 1) + "*" //NM105: Middle name
+ "*" //NM106: not used
+ "*" //NM107: Name suffix. not used
+ "XX*" //NM108: ID code qualifier. 24=EIN. 34=SSN, XX=NPI
+ Sout(billProv.NationalProvID, 80) + "~"); //NM109: ID code. NPI validated
//2100B REF: Information Receiver ID
if (IsEmdeonDental(clearinghouseClin) && IsDentiCalCarrier(carrier))
{
string ref4aSegment = "";
Clearinghouse clearinghouseDentiCalHQ = Clearinghouses.GetFirstOrDefault(x => IsDentiCalClearinghouse(x), true);
if (clearinghouseDentiCalHQ != null)
{
Clearinghouse clearinghouseDentiCalClin = Clearinghouses.OverrideFields(clearinghouseDentiCalHQ, clearinghouseClin.ClinicNum);
if (clearinghouseDentiCalClin != null)
{
ref4aSegment = clearinghouseDentiCalClin.Password;
}
}
seg++;
strb.Append("REF*4A*" + ref4aSegment + "~");
}
seg++;
strb.Append("REF*");
if (billProv.UsingTIN)
{
strb.Append("TJ*"); //REF01: qualifier. TJ=Federal TIN
}
else //SSN
{
strb.Append("SY*"); //REF01: qualifier. SY=SSN
}
strb.AppendLine(Sout(billProv.SSN, 30) + "~"); //REF02: ID
//2100B N3: Information Receiver Address
seg++;
if (PrefC.GetBool(PrefName.UseBillingAddressOnClaims))
{
strb.Append("N3*" + Sout(PrefC.GetString(PrefName.PracticeBillingAddress), 55)); //N301: Address
}
else if (clinic == null)
{
strb.Append("N3*" + Sout(PrefC.GetString(PrefName.PracticeAddress), 55)); //N301: Address
}
else
{
strb.Append("N3*" + Sout(clinic.Address, 55)); //N301: Address
}
if (PrefC.GetBool(PrefName.UseBillingAddressOnClaims))
{
if (PrefC.GetString(PrefName.PracticeBillingAddress2) == "")
{
strb.AppendLine("~");
}
else
{
//N302: Address2. Optional.
strb.AppendLine("*" + Sout(PrefC.GetString(PrefName.PracticeBillingAddress2), 55) + "~");
}
}
else if (clinic == null)
{
if (PrefC.GetString(PrefName.PracticeAddress2) == "")
{
strb.AppendLine("~");
}
else
{
//N302: Address2. Optional.
strb.AppendLine("*" + Sout(PrefC.GetString(PrefName.PracticeAddress2), 55) + "~");
}
}
else
{
if (clinic.Address2 == "")
{
strb.AppendLine("~");
}
else
{
//N302: Address2. Optional.
strb.AppendLine("*" + Sout(clinic.Address2, 55) + "~");
}
}
//2100B N4: Information Receiver City/State/Zip
seg++;
if (PrefC.GetBool(PrefName.UseBillingAddressOnClaims))
{
strb.AppendLine("N4*" + Sout(PrefC.GetString(PrefName.PracticeBillingCity), 30) + "*" //N401: City
+ Sout(PrefC.GetString(PrefName.PracticeBillingST), 2) + "*" //N402: State
+ Sout(PrefC.GetString(PrefName.PracticeBillingZip).Replace("-", ""), 15) + "~"); //N403: Zip
}
else if (clinic == null)
{
strb.AppendLine("N4*" + Sout(PrefC.GetString(PrefName.PracticeCity), 30) + "*" //N401: City
+ Sout(PrefC.GetString(PrefName.PracticeST), 2) + "*" //N402: State
+ Sout(PrefC.GetString(PrefName.PracticeZip).Replace("-", ""), 15) + "~"); //N403: Zip
}
else
{
strb.AppendLine("N4*" + Sout(clinic.City, 30) + "*" //N401: City
+ Sout(clinic.State, 2) + "*" //N402: State
+ Sout(clinic.Zip.Replace("-", ""), 15) + "~"); //N403: Zip
}
//2100B PRV: Information Receiver Provider Info
seg++;
//PRV*PE*ZZ*1223G0001X~
strb.AppendLine("PRV*PE*" //PRV01: Provider Code. PE=Performing. There are many other choices.
+ "ZZ*" //PRV02: ZZ=Mutually defined = health care provider taxonomy code
+ X12Generator.GetTaxonomy(billProv) + "~"); //PRV03: Specialty code
HLcount++;
//2000C HL: Subscriber-----------------------------------------------------------------------------------
seg++;
strb.AppendLine("HL*" + HLcount.ToString() + "*" //HL01: Heirarchical ID. Here, it's always 3.
+ "2*" //HL02: Heirarchical parent id number. 2 in this simple message.
+ "22*" //HL03: Heirarchical level code. 22=Subscriber
+ (isSubscriberRequest?"0~":"1~")); //HL04: Heirarchical child code. 0=no child HL present (no dependent) else 1
//2000C TRN: Subscriber Trace Number
seg++;
strb.AppendLine("TRN*1*" //TRN01: Trace Type Code. 1=Current Transaction Trace Numbers
+ "1*" //TRN02: Trace Number. We don't really have a good primary key yet. Keep it simple. Use 1.
+ "1" + billProv.SSN + "~"); //TRN03: Entity Identifier. First digit is 1=EIN. Next 9 digits are EIN. Length validated.
//2100C NM1: Subscriber Name
seg++;
strb.AppendLine("NM1*IL*" //NM101: IL=Insured or Subscriber
+ "1*" //NM102: 1=Person
+ Sout(subscriber.LName, 35) + "*" //NM103: LName
+ Sout(subscriber.FName, 25) + "*" //NM104: FName
+ Sout(subscriber.MiddleI, 25) + "*" //NM105: MiddleName
+ "*" //NM106: not used
+ "*" //NM107: suffix. Not present in Open Dental yet.
+ "MI*" //NM108: MI=MemberID
+ Sout(insSub.SubscriberID.Replace("-", ""), 80) + "~"); //NM109: Subscriber ID. Validated to be L>2.
//2100C REF: Subscriber Additional Information. Without this, old plans seem to be frequently returned.
seg++;
strb.AppendLine("REF*6P*" //REF01: 6P=GroupNumber
+ Sout(insPlan.GroupNum, 30) + "~"); //REF02: Supplemental ID. Validated.
//2100C DMG: Subscriber Demographic Information
seg++;
strb.AppendLine("DMG*D8*" //DMG01: Date Time Period Qualifier. D8=CCYYMMDD
+ subscriber.Birthdate.ToString("yyyyMMdd") + "~"); //DMG02: Subscriber birthdate. Validated
//DMG03: Gender code. Situational. F or M. Since this was left out in the example,
//and since we don't want to send the wrong gender, we will not send this element.
//2100C DTP: Subscriber Date. Deduced through trial and error that this is required by EHG even though not by X12 specs.
seg++;
strb.AppendLine("DTP*307*" //DTP01: Qualifier. 307=Eligibility
+ "D8*" //DTP02: Format Qualifier.
+ DateTime.Today.ToString("yyyyMMdd") + "~"); //DTP03: Date
//2000D HL: Dependent Level Hierarchical Level
if (isSubscriberRequest)
{
//2110C EQ: Subscriber Eligibility or Benefit Enquiry Information
//X12 documentation seems to say that we can loop this 99 times to request very specific benefits.
//ClaimConnect wants to see either an EQ*30 for "an eligibility request", or an EQ*35 for "a general benefits request".
//The director of vendor implementation at ClaimConnect has informed us that we should send an EQ*35 to get the full set of benefits.
seg++;
strb.AppendLine("EQ*35~"); //Dental Care
}
else //Dependent based request.
{
HLcount++;
seg++;
strb.AppendLine("HL*" + HLcount.ToString() + "*" //HL01: Heirarchical ID.
+ (HLcount - 1).ToString() + "*" //HL02: Heirarchical parent id number.
+ "23*" //HL03: Heirarchical level code. 23=Dependent
+ "0~"); //HL04: Heirarchical child code. 0=no child HL present (no dependent)
//2000D TRN: Dependent Trace Number
seg++;
strb.AppendLine("TRN*1*" //TRN01: Trace Type Code. 1=Current Transaction Trace Numbers
+ "1*" //TRN02: Trace Number. We don't really have a good primary key yet. Keep it simple. Use 1.
+ "1" + billProv.SSN + "~"); //TRN03: Entity Identifier. First digit is 1=EIN. Next 9 digits are EIN. Length validated.
//2100D NM1: Dependent Name
seg++;
strb.AppendLine("NM1*03*" //NM101: 03=Dependent
+ "1*" //NM102: 1=Person
+ Sout(patForRequest.LName, 35) + "*" //NM103: Name Last or Organization Name
+ Sout(patForRequest.FName, 25) + "*" //NM104: Name First
+ Sout(patForRequest.MiddleI, 25) + "~"); //NM105: Name Middle
//2100D REF: Dependent Additional Identification
seg++;
strb.AppendLine("REF*6P*" //REF01: 6P=GroupNumber
+ Sout(insPlan.GroupNum, 30) + "~"); //REF02: Supplemental ID. Validated.
//2100D DMG: Dependent Demographic Information
seg++;
strb.AppendLine("DMG*D8*" //DMG01: Date Time Period Qualifier. D8=CCYYMMDD
+ patForRequest.Birthdate.ToString("yyyyMMdd") + "~"); //DMG02: Dependent birthdate. Validated
//DMG03: Gender code. Situational. F or M. Since this was left out in the example,
//and since we don't want to send the wrong gender, we will not send this element.
//2100D DTP: DEPENDENT Date. Deduced through trial and error that this is required by EHG even though not by X12 specs.
seg++;
strb.AppendLine("DTP*307*" //DTP01: Qualifier. 307=Eligibility
+ "D8*" //DTP02: Format Qualifier.
+ DateTime.Today.ToString("yyyyMMdd") + "~"); //DTP03: Date
seg++;
strb.AppendLine("EQ*35~"); //Dental Care
}
//Transaction Trailer
seg++;
strb.AppendLine("SE*"
+ seg.ToString() + "*" //SE01: Total segments, including ST & SE
+ transactionNum.ToString().PadLeft(4, '0') + "~");
//End of transaction--------------------------------------------------------------------------------------
//Functional Group Trailer
strb.AppendLine("GE*" + transactionNum.ToString() + "*" //GE01: Number of transaction sets included
+ groupControlNumber + "~"); //GE02: Group Control number. Must be identical to GS06
//Interchange Control Trailer
strb.AppendLine("IEA*1*" //IEA01: number of functional groups
+ batchNum.ToString().PadLeft(9, '0') + "~"); //IEA02: Interchange control number
return(strb.ToString());
/*
* return @"
* ISA*00* *00* *30*AA0989922 *30*330989922 *030519*1608*U*00401*000012145*1*T*:~
* GS*HS*AA0989922*330989922*20030519*1608*12145*X*004010X092~
* ST*270*0001~
* BHT*0022*13*ASX012145WEB*20030519*1608~
* HL*1**20*1~
* NM1*PR*2*Metlife*****PI*65978~
* HL*2*1*21*1~
* NM1*1P*1*PROVLAST*PROVFIRST****XX*1234567893~
* REF*TJ*200384584~
* N3*JUNIT ROAD~
* N4*CHICAGO*IL*60602~
* PRV*PE*ZZ*1223G0001X~
* HL*3*2*22*0~
* TRN*1*12145*1AA0989922~
* NM1*IL*1*SUBLASTNAME*SUBFIRSTNAME****MI*123456789~
* DMG*D8*19750323~
* DTP*307*D8*20030519~
* EQ*30~
* SE*17*0001~
* GE*1*12145~
* IEA*1*000012145~";
*/
//return "ISA*00* *00* *30*AA0989922 *30*330989922 *030519*1608*U*00401*000012145*1*T*:~GS*HS*AA0989922*330989922*20030519*1608*12145*X*004010X092~ST*270*0001~BHT*0022*13*ASX012145WEB*20030519*1608~HL*1**20*1~NM1*PR*2*Metlife*****PI*65978~HL*2*1*21*1~NM1*1P*1*PROVLAST*PROVFIRST****XX*1234567893~REF*TJ*200384584~N3*JUNIT ROAD~N4*CHICAGO*IL*60602~PRV*PE*ZZ*1223G0001X~HL*3*2*22*0~TRN*1*12145*1AA0989922~NM1*IL*1*SUBLASTNAME*SUBFIRSTNAME****MI*123456789~DMG*D8*19750323~DTP*307*D8*20030519~EQ*30~SE*17*0001~GE*1*12145~IEA*1*000012145~";
}
///<summary>Returns a blank string if there were no errors while attempting to update internal carriers using iTrans n-cpl.json file.</summary>
public static string TryCarrierUpdate(bool isAutomatic = true, ItransImportFields fieldsToImport = ItransImportFields.None)
{
string json;
DateTime dateTimeTrans = DateTime.Now;
Clearinghouse clearinghouse = Clearinghouses.GetDefaultDental();
if (clearinghouse == null)
{
return(Lans.g("Clearinghosue", "Unable to update. No default dental clearinghouse set."));
}
//If ITRANS2 is fully setup, then use the local ITRANS2 install on server to import carrier data.
if (clearinghouse.CommBridge == EclaimsCommBridge.ITRANS && !string.IsNullOrEmpty(clearinghouse.ResponsePath))
{
if (!File.Exists(ODFileUtils.CombinePaths(clearinghouse.ResponsePath, "ITRANS Claims Director.exe")))
{
return(Lans.g("Clearinghouse", "Unable to find 'ITRANS Claims Director.exe'. Make sure the file exists and the path is correct."));
}
if (isAutomatic && PrefC.GetString(PrefName.WebServiceServerName).ToLower() != Dns.GetHostName().ToLower()) //Only server can run when isOnlyServer is true.
{
return(Lans.g("Clearinghouse", "Update can only run on the web service server " + PrefC.GetString(PrefName.WebServiceServerName)) +
". " + Lans.g("Clearinghouse", "Connect to the server and try again."));
}
Process process = new Process {
StartInfo = new ProcessStartInfo {
FileName = ODFileUtils.CombinePaths(clearinghouse.ResponsePath, "ITRANS Claims Director.exe"),
Arguments = " --getncpl"
}
};
process.Start();
process.WaitForExit();
string ncplFilePath = ODFileUtils.CombinePaths(clearinghouse.ResponsePath, "n-cpl.json");
json = File.ReadAllText(ncplFilePath); //Read n-cpl.json
dateTimeTrans = File.GetCreationTime(ncplFilePath);
}
else //ITRANS2 not used or not setup correctly, go to HQ for file content.
{
try {
string result = WebServiceMainHQProxy.GetWebServiceMainHQInstance().CanadaCarrierUpdate(PayloadHelper.CreatePayload("", eServiceCode.Undefined));
json = WebSerializer.DeserializePrimitiveOrThrow <string>(result);
}
catch (Exception ex) {
return(Lans.g("Clearinghouse", "Unable to update carrier list from HQ web services.") + "\r\n" + ex.Message.ToString());
}
}
EtransMessageText msgTextPrev = EtransMessageTexts.GetMostRecentForType(EtransType.ItransNcpl);
if (msgTextPrev != null && msgTextPrev.MessageText == json)
{
if (isAutomatic ||
ODMessageBox.Show("Carrier list has not changed since last checked.\r\nContinue?", "", MessageBoxButtons.YesNo) != DialogResult.Yes)
{
return(Lans.g("Clearinghouse", "Carrier list has not changed since last checked.")); //json has not changed since we last checked, no need to update.
}
}
//Save json as new etrans entry.
Etrans etrans = Etranss.CreateEtrans(dateTimeTrans, clearinghouse.HqClearinghouseNum, json, 0);
etrans.Etype = EtransType.ItransNcpl;
Etranss.Insert(etrans);
ItransNCpl iTransNCpl = null;
try {
iTransNCpl = JsonConvert.DeserializeObject <ItransNCpl>(json); //Deserialize n-cpl.json
}
catch (Exception ex) {
ex.DoNothing();
return(Lans.g("Clearinghouse", "Failed to import json."));
}
List <CanadianNetwork> listCanadianNetworks = CanadianNetworks.GetDeepCopy();
//List of carriers from json file that were matched by electId to multiple internal carriers
List <Carrier> listUnmatchedJsonCarriers = new List <Carrier>();
List <long> listMatchedDbCarrierNums = new List <long> ();
foreach (ItransNCpl.Carrier jsonCarrier in iTransNCpl.ListCarriers) //Update carriers.
{
string jsonCarrierPhone = jsonCarrier.Telephone?.First().Value; //Will be empty string if not found.
List <OpenDentBusiness.Carrier> listDbCarriers = Carriers.GetAllByElectId(jsonCarrier.Bin).FindAll(x => x.IsCDA);
if (listDbCarriers.Count > 1) //Some Canadian carriers share ElectId, need to filter further. This happens with carrier resellers.
{
#region Additional matching based on phone numbers, 'continues' loop if a single match is not found.
List <OpenDentBusiness.Carrier> listPhoneMatchedDbCarriers = listDbCarriers.FindAll(x =>
TelephoneNumbers.AreNumbersEqual(x.Phone, jsonCarrierPhone)
);
if (listPhoneMatchedDbCarriers.Count != 1) //Either 0 or multiple matches, either way do not update any carriers.
//When 0 matches found: jsonCarrier changed their phone number, can not determine which carrier to update.
//E.G. - JsonCarrier A matched to OD carriers B and C by electId.
//Phone number from JsonCarrier A did not match either carrier B or C due to jsonCarrier phone number change.
//Future iterations for jsonCarrier D might match to carrier B or C if phone number for jsonCarrier D did not change.
//If jsonCarrier D is matched to single OD carrier, then jsonCarrier A will attempt to match near end of method to a unmatched internal carrier.
//If ther are no future matches to OD carrier B or C then all unmatched jsonCarriers will not be imported and no OD carries will not be updated.
//----------------------------------------------------------------------//
//When greater than 1: jsonCarrier number not changed and both internal carriers have matching electIds and phone numbers.
//This should be rare, most likely a setup error.
//There should not be multiple carriers that share electId and phone numbers. User should change or remove one of the matched carriers.
{
listUnmatchedJsonCarriers.Add(jsonCarrier);
continue;
}
listDbCarriers = listPhoneMatchedDbCarriers;
#endregion
}
//At this point listDbCarriers should either be empty or contain a single OD carrier.
OpenDentBusiness.Carrier carrierInDb = listDbCarriers.FirstOrDefault(); //Null if list is empty.
if (carrierInDb == null) //Carrier can not be matched to internal Carrier based on ElectID.
{
#region Insert new carrier
if (!fieldsToImport.HasFlag(ItransImportFields.AddMissing))
{
continue;
}
OpenDentBusiness.Carrier carrierNew = new OpenDentBusiness.Carrier();
carrierNew.CanadianEncryptionMethod = 1; //Default. Deprecated for all Canadian carriers and will never be any other value.
TrySetCanadianNetworkNum(jsonCarrier, carrierNew, listCanadianNetworks);
carrierNew.ElectID = jsonCarrier.Bin;
carrierNew.IsCDA = true;
carrierNew.CarrierName = jsonCarrier.Name.En;
carrierNew.Phone = TelephoneNumbers.AutoFormat(jsonCarrierPhone);
if (jsonCarrier.Address.Count() > 0)
{
Address add = jsonCarrier.Address.First();
carrierNew.Address = add.Street1;
carrierNew.Address2 = add.Street2;
carrierNew.City = add.City;
carrierNew.State = add.Province;
carrierNew.Zip = add.Postal_Code;
}
carrierNew.CanadianSupportedTypes = GetSupportedTypes(jsonCarrier);
carrierNew.CDAnetVersion = POut.Int(jsonCarrier.Versions.Max(x => PIn.Int(x))).PadLeft(2, '0'); //Version must be in 2 digit format. ex. 02.
carrierNew.CarrierName = jsonCarrier.Name.En;
try {
Carriers.Insert(carrierNew);
}
catch (Exception ex) {
ex.DoNothing();
}
#endregion
continue;
}
listMatchedDbCarrierNums.Add(carrierInDb.CarrierNum);
UpdateCarrierInDb(carrierInDb, jsonCarrier, listCanadianNetworks, fieldsToImport, jsonCarrierPhone, isAutomatic);
}
foreach (Carrier jsonCarrier in listUnmatchedJsonCarriers)
{
List <OpenDentBusiness.Carrier> listDbCarriers = Carriers.GetWhere(x => x.IsCDA &&
x.ElectID == jsonCarrier.Bin && !listMatchedDbCarrierNums.Contains(x.CarrierNum)
);
if (listDbCarriers.Count != 1) //Either 0 or multiple matches, either way do not update any carriers.
{
continue;
}
OpenDentBusiness.Carrier carrierInDb = listDbCarriers.FirstOrDefault();
string jsonCarrierPhone = jsonCarrier.Telephone?.First().Value;
UpdateCarrierInDb(carrierInDb, jsonCarrier, listCanadianNetworks, fieldsToImport, jsonCarrierPhone, isAutomatic);
}
return(""); //Blank string represents a completed update.
}
protected override void FillCacheIfNeeded()
{
Clearinghouses.GetTableFromCache(false);
}
///<summary>Returns a blank string if there were no errors while attempting to update internal carriers using iTrans n-cpl.json file..</summary>
public static string TryCarrierUpdate(bool isAutomatic = true, ItransImportFields fieldsToImport = ItransImportFields.None)
{
Clearinghouse clearinghouse = Clearinghouses.GetDefaultDental();
if (clearinghouse.CommBridge != EclaimsCommBridge.ITRANS ||
string.IsNullOrEmpty(clearinghouse.ResponsePath) ||
!File.Exists(ODFileUtils.CombinePaths(clearinghouse.ResponsePath, "ITRANS Claims Director.exe")) ||
(isAutomatic && PrefC.GetString(PrefName.WebServiceServerName).ToLower() != Dns.GetHostName().ToLower())) //Only server can run when isOnlyServer is true.
{
return(Lans.g("Clearinghouse", "ITRANS must be the default dental clearinghouse and your Report Path must be set first."));
}
Process process = new Process {
StartInfo = new ProcessStartInfo {
FileName = ODFileUtils.CombinePaths(clearinghouse.ResponsePath, "ITRANS Claims Director.exe"),
Arguments = " --getncpl"
}
};
process.Start();
process.WaitForExit();
string ncplFilePath = ODFileUtils.CombinePaths(clearinghouse.ResponsePath, "n-cpl.json");
string json = File.ReadAllText(ncplFilePath);//Read n-cpl.json
EtransMessageText msgTextPrev = EtransMessageTexts.GetMostRecentForType(EtransType.ItransNcpl);
if (msgTextPrev != null && msgTextPrev.MessageText == json)
{
return(Lans.g("Clearinghouse", "Carrier list has not changed since last checked.")); //json has not changed since we last checked, no need to update.
}
//Save json as new etrans entry.
Etrans etrans = Etranss.CreateEtrans(File.GetCreationTime(ncplFilePath), clearinghouse.HqClearinghouseNum, json, 0);
etrans.Etype = EtransType.ItransNcpl;
Etranss.Insert(etrans);
ItransNCpl iTransNCpl = null;
try {
iTransNCpl = JsonConvert.DeserializeObject <ItransNCpl>(json); //Deserialize n-cpl.json
}
catch (Exception ex) {
ex.DoNothing();
return(Lans.g("Clearinghouse", "Failed to import json."));
}
foreach (ItransNCpl.Carrier jsonCarrier in iTransNCpl.ListCarriers) //Update providers.
{
OpenDentBusiness.Carrier odCarrier = Carriers.GetByElectId(jsonCarrier.Bin); //Cached
if (odCarrier == null) //Carrier can not be matched to internal Carrier based on ElectID.
{
if (!fieldsToImport.HasFlag(ItransImportFields.AddMissing))
{
continue;
}
OpenDentBusiness.Carrier carrierNew = new OpenDentBusiness.Carrier();
carrierNew.ElectID = jsonCarrier.Bin;
carrierNew.IsCDA = true;
carrierNew.CarrierName = jsonCarrier.Name.En;
carrierNew.Phone = TelephoneNumbers.ReFormat(jsonCarrier.Telephone?.First().Value);
if (jsonCarrier.Address.Count() > 0)
{
Address add = jsonCarrier.Address.First();
carrierNew.Address = add.Street1;
carrierNew.Address2 = add.Street2;
carrierNew.City = add.City;
carrierNew.State = add.Province;
carrierNew.Zip = add.PostalCode;
}
carrierNew.CanadianSupportedTypes = GetSupportedTypes(jsonCarrier);
carrierNew.CarrierName = jsonCarrier.Name.En;
try {
Carriers.Insert(carrierNew);
}
catch (Exception ex) {
ex.DoNothing();
}
continue;
}
else if (!odCarrier.IsCDA)
{
continue;
}
OpenDentBusiness.Carrier odCarrierOld = odCarrier.Copy();
odCarrier.CanadianSupportedTypes = GetSupportedTypes(jsonCarrier);
odCarrier.CDAnetVersion = POut.Int(jsonCarrier.Versions.Max(x => PIn.Int(x)));
List <ItransImportFields> listFields = Enum.GetValues(typeof(ItransImportFields)).Cast <ItransImportFields>().ToList();
foreach (ItransImportFields field in listFields)
{
if (fieldsToImport == ItransImportFields.None)
{
break; //No point in looping.
}
if (field == ItransImportFields.None || !fieldsToImport.HasFlag(field))
{
continue;
}
switch (field)
{
case ItransImportFields.Phone:
if (jsonCarrier.Telephone.Count > 0)
{
odCarrier.Phone = TelephoneNumbers.ReFormat(jsonCarrier.Telephone.First().Value);
}
break;
case ItransImportFields.Address:
if (jsonCarrier.Address.Count() > 0)
{
Address add = jsonCarrier.Address.First();
odCarrier.Address = add.Street1;
odCarrier.Address2 = add.Street2;
odCarrier.City = add.City;
odCarrier.State = add.Province;
odCarrier.Zip = add.PostalCode;
}
break;
case ItransImportFields.Name:
odCarrier.CarrierName = jsonCarrier.Name.En;
break;
}
}
try {
long userNum = 0;
if (!isAutomatic)
{
userNum = Security.CurUser.UserNum;
}
Carriers.Update(odCarrier, odCarrierOld, userNum);
}
catch (Exception ex) {
ex.DoNothing();
}
}
return(""); //Blank string represents a completed update.
}
///<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>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"]);
}
}