///<summary>Updates the links to wpOld to wpNew in the wikipage page wikiPageCur.</summary>
///<param name="wikiPageCurNum">This is the wikipage that will get updated.</param>
///<param name="wpOldNum">This is the wikipage that will be used to find references in wikiPageCur.</param>
///<param name="wpNewNum">This is the wikipage that will be used to replace the references to.</param>
public static void UpdateWikiPageReferences(long wikiPageCurNum, long wpOldNum, long wpNewNum)
{
//No need to check RemotingRole; no call to db.
WikiPage wikiPageCur = GetOne(wikiPageCurNum); //Getting from the database to ensure the WikiPageNums have not been replaced with PageTitles.
if (wikiPageCur == null)
{
return;
}
WikiPage wikiPageOld = wikiPageCur.Copy();
StringBuilder sbPageContent = new StringBuilder(wikiPageCur.PageContent);
sbPageContent.RegReplace($@"\[\[{wpOldNum}\]\]", "[[" + wpNewNum + "]]");
wikiPageCur.PageContent = sbPageContent.ToString();
WikiPages.Update(wikiPageCur, wikiPageOld);
}
public static WikiPage RevertFrom(WikiPageHist wikiPageHist)
{
//Get the existing WikiPage to ensure the WikiPageNum is preserved for links.
//See JobNum 4429 for the job that made this necessary.
WikiPage retVal = WikiPages.GetByTitle(wikiPageHist.PageTitle);
if (retVal == null)
{
retVal = new WikiPage();
}
//retVal.WikiPageNum
//retVal.UserNum
retVal.PageTitle = wikiPageHist.PageTitle;
retVal.PageContent = wikiPageHist.PageContent;
retVal.KeyWords = "";
Match m = Regex.Match(wikiPageHist.PageContent, @"\[\[(keywords:).*?\]\]");
if (m.Length > 0)
{
retVal.KeyWords = m.Value.Substring(11).TrimEnd(']');
}
//retVal.DateTimeSaved=DateTime.Now;//gets set when inserted.
return(retVal);
}
///<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>Surround with try/catch. Also aggregates the content into the master page (unless specified to not).
///If isPreviewOnly, then the internal links will not be checked to see if the page exists, as it would make the refresh sluggish.
///And isPreviewOnly also changes the pointer so that the page looks non-clickable.
///For emails, this only gets called while in the email edit window. The returned string will be used to switch between plain and html text.
///</summary>
public static string TranslateToXhtml(string markupText, bool isPreviewOnly, bool hasWikiPageTitles = false, bool isEmail = false, bool canAggregate = true)
{
//No need to check RemotingRole; no call to db.
#region Basic Xml Validation
string s = markupText;
MatchCollection matches;
//"<",">", and "&"-----------------------------------------------------------------------------------------------------------
s = s.Replace("&", "&");
s = s.Replace("&<", "<"); //because "&" was changed to "&" in the line above.
s = s.Replace("&>", ">"); //because "&" was changed to "&" in the line above.
s = "<body>" + s + "</body>";
XmlDocument doc = new XmlDocument();
using (StringReader reader = new StringReader(s)) {
doc.Load(reader);
}
#endregion
#region regex replacements
if (isEmail)
{
s = TranslateEmailImages(s); //handle email images and wiki images separately.
}
else
{
//[[img:myimage.gif]]------------------------------------------------------------------------------------------------------------
matches = Regex.Matches(s, _odWikiImage);
foreach (Match match in matches)
{
string imgName = match.Value.Substring(match.Value.IndexOf(":") + 1).TrimEnd("]".ToCharArray());
string wikiPath = "";
try {
wikiPath = WikiPages.GetWikiPath();
}
catch (Exception ex) {
ex.DoNothing();
throw;
}
string fullPath = FileAtoZ.CombinePaths(wikiPath, POut.String(imgName));
if (CloudStorage.IsCloudStorage)
{
//WebBrowser needs to have a local file to open, so we download the images to temp files.
OpenDentalCloud.Core.TaskStateDownload state = CloudStorage.Download(Path.GetDirectoryName(fullPath), Path.GetFileName(fullPath));
string tempFile = PrefC.GetRandomTempFile(Path.GetExtension(fullPath));
File.WriteAllBytes(tempFile, state.FileContent);
fullPath = tempFile;
}
s = s.Replace(match.Value, "<img src=\"file:///" + fullPath.Replace("\\", "/") + "\"></img>");
}
//[[keywords: key1, key2, etc.]]------------------------------------------------------------------------------------------------
matches = Regex.Matches(s, _odWikiKeyword);
foreach (Match match in matches) //should be only one
{
s = s.Replace(match.Value, "<span class=\"keywords\">keywords:" + match.Value.Substring(11).TrimEnd("]".ToCharArray()) + "</span>");
}
//[[file:C:\eaula.txt]]------------------------------------------------------------------------------------------------
matches = Regex.Matches(s, _odWikiFile);
foreach (Match match in matches)
{
string fileName = match.Value.Replace("[[file:", "").TrimEnd(']');
s = s.Replace(match.Value, "<a href=\"wikifile:" + fileName + "\">file:" + fileName + "</a>");
}
//[[folder:\\serverfiles\storage\]]------------------------------------------------------------------------------------------------
matches = Regex.Matches(s, _odWikiFolder);
foreach (Match match in matches)
{
string folderName = match.Value.Replace("[[folder:", "").TrimEnd(']');
s = s.Replace(match.Value, "<a href=\"folder:" + folderName + "\">folder:" + folderName + "</a>");
}
//[[filecloud:AtoZ/SheetImages/happyclown.jpg]]------------------------------------------------------------------------------------------------
matches = Regex.Matches(s, _odWikiFilecloud);
foreach (Match match in matches)
{
string fileName = CloudStorage.PathTidy(match.Value.Replace("[[filecloud:", "").TrimEnd(']'));
s = s.Replace(match.Value, "<a href=\"wikifilecloud:" + fileName + "\">filecloud:" + fileName + "</a>");
}
//[[foldercloud:AtoZ/PenguinPictures/]]------------------------------------------------------------------------------------------------
matches = Regex.Matches(s, _odWikiFoldercloud);
foreach (Match match in matches)
{
string folderName = CloudStorage.PathTidy(match.Value.Replace("[[foldercloud:", "").TrimEnd(']'));
s = s.Replace(match.Value, "<a href=\"foldercloud:" + folderName + "\">foldercloud:" + folderName + "</a>");
}
}
//Color and text are for both wiki and email. It's important we do this before Internal Link or else the translation may not work.
//[[color:red|text]]----------------------------------------------------------------------------------------------------------------
matches = Regex.Matches(s, _odWikiColor); //.*? matches as few as possible.
foreach (Match match in matches)
{
//string[] paragraphs = match.Value.Split(new string[] { "\n" },StringSplitOptions.None);
string tempText = "<span style=\"color:";
string[] tokens = match.Value.Split('|');
if (tokens.Length < 2) //not enough tokens
{
continue;
}
if (tokens[0].Split(':').Length != 2) //Must have a color token and a color value seperated by a colon, no more no less.
{
continue;
}
for (int i = 0; i < tokens.Length; i++)
{
if (i == 0)
{
tempText += tokens[0].Split(':')[1] + ";\">"; //close <span> tag
continue;
}
tempText += (i > 1?"|":"") + tokens[i];
}
tempText = tempText.TrimEnd(']');
tempText += "</span>";
s = s.Replace(match.Value, tempText);
}
//[[font-family:courier|text]]----------------------------------------------------------------------------------------------------------------
matches = Regex.Matches(s, _odWikiFont); //.*? matches as few as possible.
foreach (Match match in matches)
{
//string[] paragraphs = match.Value.Split(new string[] { "\n" },StringSplitOptions.None);
string tempText = "<span style=\"font-family:";
string[] tokens = match.Value.Split('|');
if (tokens.Length < 2) //not enough tokens
{
continue;
}
if (tokens[0].Split(':').Length != 2) //Must have a color token and a color value seperated by a colon, no more no less.
{
continue;
}
for (int i = 0; i < tokens.Length; i++)
{
if (i == 0)
{
tempText += tokens[0].Split(':')[1] + ";\">"; //close <span> tag
continue;
}
tempText += (i > 1?"|":"") + tokens[i];
}
tempText = tempText.TrimEnd(']');
tempText += "</span>";
s = s.Replace(match.Value, tempText);
}
if (!isEmail)
{
//[[InternalLink]]--------------------------------------------------------------------------------------------------------------
matches = Regex.Matches(s, @"\[\[.+?\]\]");
List <string> pageNamesToCheck = new List <string>();
List <bool> pageNamesExist = new List <bool>();
string styleNotExists = "";
if (hasWikiPageTitles)
{
if (!isPreviewOnly)
{
foreach (Match match in matches)
{
//The '&' was replaced with '&' above, so we change it back before looking for a wiki page with that name.
pageNamesToCheck.Add(match.Value.Trim('[', ']').Replace("&", "&"));
}
if (pageNamesToCheck.Count > 0)
{
pageNamesExist = WikiPages.CheckPageNamesExist(pageNamesToCheck); //this gets a list of bools for all pagenames in one shot. One query.
}
}
foreach (Match match in matches)
{
styleNotExists = "";
if (!isPreviewOnly)
{
//The '&' was replaced with '&' above, so we change it back before looking for a wiki page with that name.
string pageName = match.Value.Trim('[', ']').Replace("&", "&");
int idx = pageNamesToCheck.IndexOf(pageName);
if (!pageNamesExist[idx])
{
styleNotExists = "class='PageNotExists' ";
}
}
s = s.Replace(match.Value, "<a " + styleNotExists + "href=\"" + "wiki:" + match.Value.Trim('[', ']') /*.Replace(" ","_")*/
+ "\">" + match.Value.Trim('[', ']') + "</a>");
}
}
else
{
List <long> listWikiPageNums = WikiPages.GetWikiPageNumsFromPageContent(s);
List <WikiPage> listWikiPages = WikiPages.GetWikiPages(listWikiPageNums);
int numInvalid = 1;
foreach (Match match in matches)
{
WikiPage wp = listWikiPages.FirstOrDefault(x => x.WikiPageNum == PIn.Long(match.Value.TrimStart('[').TrimEnd(']')));
string pageName;
if (wp != null)
{
pageName = wp.PageTitle;
}
else
{
pageName = "INVALID WIKIPAGE LINK " + numInvalid++;
}
if (!isPreviewOnly)
{
styleNotExists = "";
if (wp == null)
{
styleNotExists = "class='PageNotExists' ";
}
}
pageName = pageName.Replace("&", "&").Replace("&<", "<").Replace("&>", ">");
string replace = "<a " + styleNotExists + "href=\"" + "wiki:" + pageName /*.Replace(" ","_")*/ + "\">" + pageName + "</a>";
Regex regex = new Regex(Regex.Escape(match.Value));
//Replace the first instance of the match with the wiki page name (or unknown if not found).
s = regex.Replace(s, replace, 1);
}
}
}
//Unordered List----------------------------------------------------------------------------------------------------------------
//Instead of using a regex, this will hunt through the rows in sequence.
//later nesting by running ***, then **, then *
s = ProcessList(s, "*");
//numbered list---------------------------------------------------------------------------------------------------------------------
s = ProcessList(s, "#");
//table-------------------------------------------------------------------------------------------------------------------------
//{|
//!Width="100"|Column Heading 1!!Width="150"|Column Heading 2!!Width=""|Column Heading 3
//|-
//|Cell 1||Cell 2||Cell 3
//|-
//|Cell A||Cell B||Cell C
//|}
//There are many ways to parse this. Our strategy is to do it in a way that the generated xml is never invalid.
//As the user types, the above example will frequently be in a state of partial completeness, and the parsing should gracefully continue anyway.
//rigorous enforcement only happens when validating during a save, not here.
matches = Regex.Matches(s, _odWikiTable, RegexOptions.Singleline);
foreach (Match match in matches)
{
//If there isn't a new line before the start of the table markup or after the end, the match group value will be an empty string
//Tables must start with "'newline'{|" and end with "|}'newline'"
string tableStrOrig = match.Value;
StringBuilder strbTable = new StringBuilder();
string[] lines = tableStrOrig.Split(new string[] { "{|\n", "\n|-\n", "\n|}" }, StringSplitOptions.RemoveEmptyEntries);
strbTable.AppendLine("<table>");
List <string> colWidths = new List <string>();
for (int i = 0; i < lines.Length; i++)
{
if (lines[i].StartsWith("!")) //header
{
strbTable.AppendLine("<tr>");
lines[i] = lines[i].Substring(1); //strips off the leading !
string[] cells = lines[i].Split(new string[] { "!!" }, StringSplitOptions.None);
colWidths.Clear();
for (int c = 0; c < cells.Length; c++)
{
if (Regex.IsMatch(cells[c], @"(Width="")\d+""\|")) //e.g. Width="90"|
{
strbTable.Append("<th ");
string width = cells[c].Substring(7); //90"|Column Heading 1
width = width.Substring(0, width.IndexOf("\"")); //90
colWidths.Add(width);
strbTable.Append("Width=\"" + width + "\">");
strbTable.Append(ProcessParagraph(cells[c].Substring(cells[c].IndexOf("|") + 1), false)); //surround with p tags. Allow CR in header.
strbTable.AppendLine("</th>");
}
else
{
strbTable.Append("<th>");
strbTable.Append(ProcessParagraph(cells[c], false)); //surround with p tags. Allow CR in header.
strbTable.AppendLine("</th>");
}
}
strbTable.AppendLine("</tr>");
}
else if (lines[i].Trim() == "|-")
{
//totally ignore these rows
}
else //normal row
{
strbTable.AppendLine("<tr>");
lines[i] = lines[i].Substring(1); //strips off the leading |
string[] cells = lines[i].Split(new string[] { "||" }, StringSplitOptions.None);
for (int c = 0; c < cells.Length; c++)
{
strbTable.Append("<td Width=\"" + colWidths[c] + "\">");
strbTable.Append(ProcessParagraph(cells[c], false));
strbTable.AppendLine("</td>");
}
strbTable.AppendLine("</tr>");
}
}
strbTable.Append("</table>");
s = s.Replace(tableStrOrig, strbTable.ToString());
}
#endregion regex replacements
#region paragraph grouping
StringBuilder strbSnew = new StringBuilder();
//a paragraph is defined as all text between sibling tags, even if just a \n.
int iScanInParagraph = 0; //scan starting at the beginning of s. S gets chopped from the start each time we grab a paragraph or a sibiling element.
//The scanning position represents the verified paragraph content, and does not advance beyond that.
//move <body> tag over.
strbSnew.Append("<body>");
s = s.Substring(6);
bool startsWithCR = false; //todo: handle one leading CR if there is no text preceding it.
if (s.StartsWith("\n"))
{
startsWithCR = true;
}
string tagName;
Match tagCurMatch;
while (true) //loop to either construct a paragraph, or to immediately add the next tag to strbSnew.
{
iScanInParagraph = s.IndexOf("<", iScanInParagraph); //Advance the scanner to the start of the next tag
if (iScanInParagraph == -1) //there aren't any more tags, so current paragraph goes to end of string. This won't happen
{
throw new ApplicationException(Lans.g("WikiPages", "No tags found."));
//strbSnew.Append(ProcessParagraph(s));
}
if (s.Substring(iScanInParagraph).StartsWith("</body>"))
{
strbSnew.Append(ProcessParagraph(s.Substring(0, iScanInParagraph), startsWithCR));
//startsWithCR=false;
//strbSnew.Append("</body>");
s = "";
iScanInParagraph = 0;
break;
}
tagName = "";
tagCurMatch = Regex.Match(s.Substring(iScanInParagraph), "^<.*?>"); //regMatch);//.*? means any char, zero or more, as few as possible
if (tagCurMatch == null)
{
//shouldn't happen unless closing bracket is missing
throw new ApplicationException(Lans.g("WikiPages", "Unexpected tag:") + " " + s.Substring(iScanInParagraph));
}
if (tagCurMatch.Value.Trim('<', '>').EndsWith("/"))
{
//self terminating tags NOT are allowed
//this should catch all non-allowed self-terminating tags i.e. <br />, <inherits />, etc...
throw new ApplicationException(Lans.g("WikiPages", "All elements must have a beginning and ending tag. Unexpected tag:") + " " + s.Substring(iScanInParagraph));
}
//Nesting of identical tags causes problems:
//<h1><h1>some text</h1></h1>
//The first <h1> will match with the first </h1>.
//We don't have time to support this outlier, so we will catch it in the validator when they save.
//One possible strategy here might be:
//idxNestedDuplicate=s.IndexOf("<"+tagName+">");
//if(idxNestedDuplicate<s.IndexOf("</"+tagName+">"){
//
//}
//Another possible strategy might be to use regular expressions.
tagName = tagCurMatch.Value.Split(new string[] { "<", " ", ">" }, StringSplitOptions.RemoveEmptyEntries)[0]; //works with tags like <i>, <span ...>, and <img .../>
if (s.IndexOf("</" + tagName + ">") == -1) //this will happen if no ending tag.
{
throw new ApplicationException(Lans.g("WikiPages", "No ending tag:") + " " + s.Substring(iScanInParagraph));
}
switch (tagName)
{
case "a":
case "b":
case "div":
case "i":
case "span":
iScanInParagraph = s.IndexOf("</" + tagName + ">", iScanInParagraph) + 3 + tagName.Length;
continue; //continues scanning this paragraph.
case "h1":
case "h2":
case "h3":
case "ol":
case "ul":
case "table":
case "img": //can NOT be self-terminating
if (iScanInParagraph == 0) //s starts with a non-paragraph tag, so there is no partially assembled paragraph to process.
//do nothing
{
}
else //we are already part way into assembling a paragraph.
{
strbSnew.Append(ProcessParagraph(s.Substring(0, iScanInParagraph), startsWithCR));
startsWithCR = false; //subsequent paragraphs will not need this
s = s.Substring(iScanInParagraph); //chop off start of s
iScanInParagraph = 0;
}
//scan to the end of this element
int iScanSibling = s.IndexOf("</" + tagName + ">") + 3 + tagName.Length;
//tags without a closing tag were caught above.
//move the non-paragraph content over to s new.
strbSnew.Append(s.Substring(0, iScanSibling));
s = s.Substring(iScanSibling);
//scanning will start a totally new paragraph
break;
default:
if (isEmail)
{
iScanInParagraph = s.IndexOf("</" + tagName + ">", iScanInParagraph) + 3 + tagName.Length;
continue; //continues scanning this paragraph
}
throw new ApplicationException(Lans.g("WikiPages", "Unexpected tag:") + " " + s.Substring(iScanInParagraph));
}
}
strbSnew.Append("</body>");
#endregion
#region aggregation
doc = new XmlDocument();
using (StringReader reader = new StringReader(strbSnew.ToString())) {
doc.Load(reader);
}
StringBuilder strbOut = new StringBuilder();
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.IndentChars = "\t";
settings.OmitXmlDeclaration = true;
settings.NewLineChars = "\n";
using (XmlWriter writer = XmlWriter.Create(strbOut, settings)) {
doc.WriteTo(writer);
}
//spaces can't be handled prior to this point because crashes the xml parser.
strbOut.Replace(" ", " "); //handle extra spaces.
strbOut.Replace("<td></td>", "<td> </td>"); //force blank table cells to show not collapsed
strbOut.Replace("<th></th>", "<th> </th>"); //and blank table headers
strbOut.Replace("{{nbsp}}", " "); //couldn't add the earlier because
strbOut.Replace("<p></p>", "<p> </p>"); //probably redundant but harmless
//aggregate with master
if (isEmail)
{
if (canAggregate)
{
s = PrefC.GetString(PrefName.EmailMasterTemplate).Replace("@@@body@@@", strbOut.ToString());
return(s);
}
return(strbOut.ToString());
}
else
{
s = WikiPages.MasterPage.PageContent.Replace("@@@body@@@", strbOut.ToString());
}
#endregion aggregation
/*
* //js This code is buggy. It will need very detailed comments and careful review before/if we ever turn it back on.
* if(isPreviewOnly) {
* //do not change cursor from pointer to IBeam to Hand as you move the cursor around the preview page
* s=s.Replace("*{\n\t","*{\n\tcursor:default;\n\t");
* //do not underline links if you hover over them in the preview window
* s=s.Replace("a:hover{\n\ttext-decoration:underline;","a:hover{\n\t");
* }*/
return(s);
}
///<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"]);
}
}