public static List <int> GetVersionsAfter(int majorVersion, int minorVersion) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <List <int> >(MethodBase.GetCurrentMethod(), majorVersion, minorVersion)); } string command = $@" SELECT * FROM versionrelease WHERE DateRelease < '1880-01-01' AND IsForeign = 0 " ; //Exclude black listed versions. for (int i = 0; i < _versionsBlackList.Count; i++) { command += "AND (MajorNum,MinorNum) != (" + POut.Int(_versionsBlackList[i].Major) + "," + POut.Int(_versionsBlackList[i].Minor) + ") "; } command += $@"AND MajorNum>={majorVersion} ORDER BY MajorNum DESC,MinorNum DESC,BuildNum DESC" ; List <VersionRelease> listVersions = new List <VersionRelease>(); DataAction.RunBugsHQ(() => listVersions = RefreshAndFill(command), false); List <int> retVal = new List <int>(); foreach (VersionRelease version in listVersions) { if (version.MajorNum <= majorVersion && version.MinorNum <= minorVersion) { continue; } retVal.Add(PIn.Int(version.MajorNum.ToString() + version.MinorNum.ToString())); } return(retVal); }
///<summary>Wrapper method to call the passed-in func in a seperate thread connected to the reporting server. ///This method should only be used for SELECT, with the exception DashboardAR. Using this for create/update/delete may cause duplicates. ///The return type of this function is whatever the return type of the method you passed in is. ///Throws an exception if anything went wrong executing func within the thread.</summary> ///<param name="doRunOnReportServer">If this false, the func will run against the currently connected server.</param> public static T RunFuncOnReportServer <T>(Func <T> func, bool doRunOnReportServer = true) { if (!doRunOnReportServer) { return(func()); } Exception ex = null; ODThread threadGetTable = new ODThread(new ODThread.WorkerDelegate((ODThread o) => { DataAction.Run(() => { o.Tag = func(); } //set the tag to the func's output. , ConnectionNames.DentalOfficeReportServer); //run on the report server. if not set up, automatically runs on the current server. })); threadGetTable.AddExceptionHandler(new ODThread.ExceptionDelegate((Exception e) => { ex = e; })); threadGetTable.Name = "ReportComplexGetTableThread"; threadGetTable.Start(true); threadGetTable.Join(Timeout.Infinite); //Now that we are back on the main thread, it is now safe to throw exceptions. if (ex != null) { ExceptionDispatchInfo.Capture(ex.InnerException ?? ex).Throw(); //This preserves the stack trace of the InnerException. } return((T)threadGetTable.Tag); }
///<summary>Returns a list of all versions ordered by MajorNum, MinorNum, BuildNum, and IsForeign.</summary> public static List <VersionRelease> Refresh(bool useConnectionStore = false) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <List <VersionRelease> >(MethodBase.GetCurrentMethod(), useConnectionStore)); } List <VersionRelease> listVersionReleases = new List <VersionRelease>(); DataAction.RunBugsHQ(() => { string command = "SELECT * FROM versionrelease "; //Exclude black listed versions. for (int i = 0; i < _versionsBlackList.Count; i++) { if (i == 0) { command += "WHERE "; } else { command += "AND "; } command += "(MajorNum,MinorNum) != (" + POut.Int(_versionsBlackList[i].Major) + "," + POut.Int(_versionsBlackList[i].Minor) + ") "; } //The order is very important to other entites calling this method. command += "ORDER BY MajorNum DESC,MinorNum DESC,BuildNum DESC,IsForeign"; listVersionReleases = RefreshAndFill(command); }, useConnectionStore); return(listVersionReleases); }
///<summary></summary> public static List <BugSubmission> GetAllInRange(DateTime dateFrom, DateTime dateTo, List <string> listVersionFilters = null, bool useConnectionStore = false) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <List <BugSubmission> >(MethodBase.GetCurrentMethod(), dateFrom, dateTo, listVersionFilters, useConnectionStore)); } bool hasSelections = (!listVersionFilters.IsNullOrEmpty()); List <BugSubmission> listBugSubs = new List <BugSubmission>(); DataAction.RunBugsHQ(() => { string command = $@"SELECT * FROM bugsubmission WHERE {DbHelper.BetweenDates("SubmissionDateTime",dateFrom,dateTo)} {(hasSelections ? $@" AND ({string.Join(" OR ",listVersionFilters.Select(x => (x=="Mobile" ? "DbInfoJson like '%\"DeviceId\":%' and DbInfoJson NOT LIKE '%\"DeviceId\":null%'" : "DbVersion LIKE '"+POut.String(x)+"%'" ))) })" : "" )} " ; listBugSubs = Crud.BugSubmissionCrud.SelectMany(command); }, useConnectionStore); return(listBugSubs); }
public static DateTime GetBetaReleaseDate() { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <DateTime>(MethodBase.GetCurrentMethod())); } DateTime releaseDate = DateTime.Now; DataAction.RunBugsHQ(() => { string command = "SELECT * FROM versionrelease " + "WHERE IsForeign=0 " + "AND BuildNum=1 "; //Exclude black listed versions. for (int i = 0; i < _versionsBlackList.Count; i++) { command += "AND (MajorNum,MinorNum) != (" + POut.Int(_versionsBlackList[i].Major) + "," + POut.Int(_versionsBlackList[i].Minor) + ") "; } command += "ORDER BY MajorNum DESC,MinorNum DESC,BuildNum DESC " + "LIMIT 3"; //Might not be 3. List <VersionRelease> listVersionReleases = RefreshAndFill(command); if (!listVersionReleases.IsNullOrEmpty()) { releaseDate = listVersionReleases[0].DateRelease; } }, false); return(releaseDate); }
///<summary></summary> public static void Update(Bug bug) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { Meth.GetVoid(MethodBase.GetCurrentMethod(), bug); return; } DataAction.RunBugsHQ(() => Crud.BugCrud.Update(bug), false); }
///<summary></summary> public static long Insert(Bug bug) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { bug.BugId = Meth.GetLong(MethodBase.GetCurrentMethod(), bug); return(bug.BugId); } DataAction.RunBugsHQ(() => Crud.BugCrud.Insert(bug), false); return(bug.BugId); }
///<summary></summary> public static void Delete(long bugId) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { Meth.GetVoid(MethodBase.GetCurrentMethod(), bugId); return; } JobLinks.DeleteForType(JobLinkType.Bug, bugId); DataAction.RunBugsHQ(() => Crud.BugCrud.Delete(bugId), false); }
///<summary>Gets one Bug from the db.</summary> public static Bug GetOne(long bugId) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <Bug>(MethodBase.GetCurrentMethod(), bugId)); } Bug bug = null; DataAction.RunBugsHQ(() => bug = Crud.BugCrud.SelectOne(bugId), false); return(bug); }
///<summary></summary> public static void InsertMany(List <BugSubmissionHash> listBugSubmissionHash, bool useConnectionStore = true) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { Meth.GetVoid(MethodBase.GetCurrentMethod(), listBugSubmissionHash, useConnectionStore); return; } DataAction.RunBugsHQ(() => { Crud.BugSubmissionHashCrud.InsertMany(listBugSubmissionHash); }, useConnectionStore); }
///<summary></summary> public static void Delete(long bugSubmissionHashNum, bool useConnectionStore) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { Meth.GetVoid(MethodBase.GetCurrentMethod(), bugSubmissionHashNum, useConnectionStore); return; } DataAction.RunBugsHQ(() => { Crud.BugSubmissionHashCrud.Delete(bugSubmissionHashNum); }, useConnectionStore); }
///<summary></summary> public static void Delete(long bugSubmissionId) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { Meth.GetVoid(MethodBase.GetCurrentMethod(), bugSubmissionId); return; } DataAction.RunBugsHQ(() => { Crud.BugSubmissionCrud.Delete(bugSubmissionId); }, false); }
///<summary></summary> public static void Update(BugSubmission subNew, BugSubmission subOld, bool useConnectionStore = false) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { Meth.GetVoid(MethodBase.GetCurrentMethod(), subNew, subOld, useConnectionStore); return; } DataAction.RunBugsHQ(() => { Crud.BugSubmissionCrud.Update(subNew, subOld); }, useConnectionStore); }
///<summary></summary> public static void Delete(long faqNum) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { Meth.GetVoid(MethodBase.GetCurrentMethod(), faqNum); return; } DataAction.RunManualPublisherHQ(() => { Crud.FaqCrud.Delete(faqNum); }); }
/// <summary> /// Returns the BugSubmissionResult result for a given bug submission hash check. /// </summary> /// <param name="sub"></param> /// <param name="matchedBugId"></param> /// <param name="matchedFixedVersions"></param> /// <param name="matchedBugSubmissionHashNum"></param> /// <param name="submissionVersionOverride"></param> /// <returns></returns> public static BugSubmissionResult ProcessSubmission(BugSubmission sub, out long matchedBugId, out string matchedFixedVersions , out long matchedBugSubmissionHashNum, Version submissionVersionOverride = null, bool useConnectionStore = true) { matchedBugId = -1; matchedFixedVersions = null; matchedBugSubmissionHashNum = -1; if (sub.ListMatchedBugInfos == null) //Not already defined (like in unit test) so query for it. { DataAction.RunBugsHQ(() => { DataTable table = Db.GetTable($@" SELECT bugSubmissionHashNum, COALESCE(bug.BugId,0) _bugId,COALESCE(bug.VersionsFixed,'') _versionsFixed FROM bugsubmissionhash LEFT JOIN bug on bug.BugId=bugsubmissionhash.BugId WHERE FullHash='{sub.HashedStackTrace}' AND PartialHash='{sub.HashedSimpleStackTrace}'" ); sub.ListMatchedBugInfos = table.Select().Select(x => new BugSubmission.MatchedBugInfo(x.GetLong("bugSubmissionHashNum"), x.GetLong("_bugId"), x.GetString("_versionsFixed") )).ToList(); }, useConnectionStore); } if (sub.ListPendingFixBugInfos.Count > 1) //There are too many pending bugs and a developer will have to decide which to associate with. { return(BugSubmissionResult.Failed); } else if (sub.ListPendingFixBugInfos.Count == 1) { matchedBugId = sub.ListPendingFixBugInfos.First().BugId; matchedBugSubmissionHashNum = sub.ListPendingFixBugInfos.First().BugSubmissionHashNum; return(BugSubmissionResult.SuccessMatched); } //At this point, there are no pending fixes. Decide if a new bug submission hash should be inserted or find a pertinent fix. BugSubmission.MatchedBugInfo bugInfo = sub.GetPertinentFixedVersion(submissionVersionOverride); if (bugInfo == null) //No previously fixed bugs apply to this submission version. { if (sub.ListMatchedBugInfos.Any(x => x.BugSubmissionHashNum > 0 && x.BugId == 0 && string.IsNullOrEmpty(x.VersionsFixed))) { //We have seen this submission/hash before but it has not been associated to an internal bug yet. matchedBugSubmissionHashNum = sub.ListMatchedBugInfos.First(x => x.BugSubmissionHashNum > 0 && x.BugId == 0 && string.IsNullOrEmpty(x.VersionsFixed)).BugSubmissionHashNum; return(BugSubmissionResult.SuccessHashFound); } //Insert new hash for submission that indicates that a previous fix did not work as intended or we have not seen this submission yet. return(BugSubmissionResult.SuccessHashNeeded); } if (!sub.ListMatchedBugInfos.Any(x => x.BugSubmissionHashNum > 0 && x.BugId == 0 && string.IsNullOrEmpty(x.VersionsFixed))) { //Even though we found a pertinent fix for the inbound submission there appears to be another hash that was created due to the bug resurfacing again. matchedFixedVersions = bugInfo.VersionsFixed; } matchedBugId = bugInfo.BugId; matchedBugSubmissionHashNum = bugInfo.BugSubmissionHashNum; return(BugSubmissionResult.SuccessMatchedFixed); }
///<summary>Gets one BugSubmission from the db.</summary> public static BugSubmission GetOne(long bugSubmissionId) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <BugSubmission>(MethodBase.GetCurrentMethod(), bugSubmissionId)); } BugSubmission bugSub = null; DataAction.RunBugsHQ(() => { bugSub = Crud.BugSubmissionCrud.SelectOne(bugSubmissionId); }, false); return(bugSub); }
///<summary>Gets one BugSubmissionHash from the db.</summary> public static BugSubmissionHash GetOne(long bugSubmissionHashNum, bool useConnectionStore = true) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <BugSubmissionHash>(MethodBase.GetCurrentMethod(), bugSubmissionHashNum, useConnectionStore)); } BugSubmissionHash bugHash = null; DataAction.RunBugsHQ(() => { bugHash = Crud.BugSubmissionHashCrud.SelectOne(bugSubmissionHashNum); }, useConnectionStore); return(bugHash); }
///<summary>Returns a list of bugs for given bugIds.</summary> public static List <Bug> GetMany(List <long> listBugIds) { if (listBugIds == null || listBugIds.Count == 0) { return(new List <Bug>()); } List <Bug> listBugs = new List <Bug>(); DataAction.RunBugsHQ(() => { listBugs = Crud.BugCrud.TableToList(DataCore.GetTable("SELECT * FROM bug WHERE BugID IN (" + string.Join(",", listBugIds) + ")")); }, false); return(listBugs); }
///<summary>Gets one Faq from the db.</summary> public static Faq GetOne(long faqNum) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <Faq>(MethodBase.GetCurrentMethod(), faqNum)); } Faq retVal = null; DataAction.RunManualPublisherHQ(() => { retVal = Crud.FaqCrud.SelectOne(faqNum); }); return(retVal); }
///<summary>Deletes all faqmanualpagelink rows that have the given faqNum</summary> public static void DeleteManualPageLinkForFaqNum(long faqNum) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { Meth.GetVoid(MethodBase.GetCurrentMethod(), faqNum); return; } string command = $@"DELETE FROM faqmanualpagelink WHERE FaqNum={faqNum}"; DataAction.RunManualPublisherHQ(() => { Db.NonQ(command); }); }
///<summary>Returns a list of bug submissions and their corresponding bugs. ///If a bugsubmission is not associated to a bug then the BugObj field on the bugsubmission object will be null. ///Performs grouping logic in order to minimize the amount of bugsubmissions in the return results.</summary> public static List <BugSubmission> GetBugSubsForRegKeys(List <string> listRegKeys, DateTime dateFrom, DateTime dateTo) { if (listRegKeys == null || listRegKeys.Count == 0) { return(new List <BugSubmission>()); //No point in going through middle tier. } if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <List <BugSubmission> >(MethodBase.GetCurrentMethod(), listRegKeys, dateFrom, dateTo)); } List <BugSubmission> listRetVals = new List <BugSubmission>(); DataAction.RunBugsHQ(() => { string command = "SELECT * FROM bugsubmission " + "LEFT JOIN bug ON bug.BugId=bugsubmission.BugId " + "WHERE bugsubmission.RegKey IN(" + string.Join(",", listRegKeys.Select(x => "'" + POut.String(x) + "'")) + ") " + "AND " + DbHelper.BetweenDates("SubmissionDateTime", dateFrom, dateTo) + " " + "ORDER BY bug.CreationDate DESC, bugsubmission.SubmissionDateTime DESC"; //The query selects all columns for the bugsubmission and bug tables in one query. Hopefully we never have conflicting columns that differ. DataTable table = Db.GetTable(command); //Make a clone of the table structure for the bug objects and only fill it with entries where the BugId row is valid. DataTable tableBugs = table.Clone(); foreach (DataRow row in table.Select().Where(x => PIn.Long(x["BugId"].ToString(), false) != 0)) { tableBugs.ImportRow(row); } //Extract all of the bug objects from the subset table. List <Bug> listBugs = Crud.BugCrud.TableToList(tableBugs); //Extract all of the bugsubmission objects from the results. List <BugSubmission> listBugSubs = Crud.BugSubmissionCrud.TableToList(table); //Associate any bug object with its corresponding bugsubmission object. listBugSubs.ForEach(x => x.BugObj = listBugs.FirstOrDefault(y => y.BugId == x.BugId)); //Group the bug submissions by RegKey, ExceptionStackTrace, and BugId. //Each grouping will be ordered by ProgramVersion individually. //Take the first bugsubmission from each group and add it to listGroupedBugSubs for the return value. foreach (BugSubmission bugSub in listBugSubs) { if (bugSub.TagCustom != null) //Used to skip already considered bug submissions via grouping logic. { continue; } List <BugSubmission> listGroupedSubs = listBugSubs.FindAll(x => x.RegKey == bugSub.RegKey && x.ExceptionStackTrace == bugSub.ExceptionStackTrace && x.BugId == bugSub.BugId); listGroupedSubs.ForEach(x => x.TagCustom = true); //Flag all bugsubmissions in this group as handled. //Only add the most pertinent item from the group to our return value. listRetVals.Add(listGroupedSubs.OrderByDescending(x => new Version(x.TryGetPrefValue(PrefName.ProgramVersion, "0.0.0.0"))).First()); } }, false); return(listRetVals); }
///<summary></summary> public static List <BugSubmission> GetAll(bool useConnectionStore = false) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <List <BugSubmission> >(MethodBase.GetCurrentMethod(), useConnectionStore)); } List <BugSubmission> listBugSubs = new List <BugSubmission>(); DataAction.RunBugsHQ(() => { string command = "SELECT * FROM bugsubmission"; listBugSubs = Crud.BugSubmissionCrud.SelectMany(command); }, useConnectionStore); return(listBugSubs); }
///<summary></summary> public static long Insert(BugSubmission bugSubmission) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetLong(MethodBase.GetCurrentMethod(), bugSubmission)); } long retVal = 0; //Always use the connection store config file because creating BugSubmissions should always happen via OpenDentalWebServiceHQ. DataAction.RunBugsHQ(() => { retVal = Crud.BugSubmissionCrud.Insert(bugSubmission); }); return(retVal); }
public static List <BugSubmission> GetAllAttached() { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <List <BugSubmission> >(MethodBase.GetCurrentMethod())); } List <BugSubmission> listBugSubs = new List <BugSubmission>(); DataAction.RunBugsHQ(() => { string command = "SELECT * FROM bugsubmission WHERE BugId!=0"; listBugSubs = Crud.BugSubmissionCrud.SelectMany(command); }, false); return(listBugSubs); }
///<summary></summary> public static List <BugSubmission> GetAll() { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <List <BugSubmission> >(MethodBase.GetCurrentMethod())); } List <BugSubmission> listBugSubs = new List <BugSubmission>(); DataAction.RunBugsHQ(() => { string command = "SELECT * FROM bugsubmission"; listBugSubs = Crud.BugSubmissionCrud.TableToList(DataCore.GetTable(command)); }, false); return(listBugSubs); }
///<summary></summary> public static List <BugSubmission> GetAllInRange(DateTime dateFrom, DateTime dateTo) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <List <BugSubmission> >(MethodBase.GetCurrentMethod(), dateFrom, dateTo)); } List <BugSubmission> listBugSubs = new List <BugSubmission>(); DataAction.RunBugsHQ(() => { string command = "SELECT * FROM bugsubmission WHERE " + DbHelper.BetweenDates("SubmissionDateTime", dateFrom, dateTo); listBugSubs = Crud.BugSubmissionCrud.TableToList(DataCore.GetTable(command)); }, false); return(listBugSubs); }
///<summary></summary> public static List <string> GetFilterPhrases() { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <List <string> >(MethodBase.GetCurrentMethod())); } List <string> listPhrases = null; //Query the database for all phrases that we don't accept and see if the exception text passed in contains any of the phrases from the database. DataAction.RunBugsHQ(() => { listPhrases = Db.GetListString("SELECT Phrase FROM bugsubmissionfilter WHERE Phrase!=''"); }); return(listPhrases); }
///<summary></summary> public static long Insert(Faq faq) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { faq.FaqNum = Meth.GetLong(MethodBase.GetCurrentMethod(), faq); return(faq.FaqNum); } long faqNum = 0; DataAction.RunManualPublisherHQ(() => { faqNum = Crud.FaqCrud.Insert(faq); }); return(faqNum); }
///<summary>Checks the manual publisher database to see if the manual pages for a given version exists. ///Used when releasing a new version of the OD FAQ system.</summary> public static bool PageForVersionExists(int manualVersion) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetBool(MethodBase.GetCurrentMethod(), manualVersion)); } string command = $"SELECT COUNT(*)>0 FROM manualpage WHERE VersionOd={manualVersion.ToString()}"; bool retVal = false; DataAction.RunManualPublisherHQ(() => { retVal = PIn.Bool(Db.GetScalar(command)); }); return(retVal); }
///<summary>Gets all faq from the database for a given version. Please note the manual publisher treats version as major+minor. ///For example, to get all faq's for version 19.1.45 version should be "191".</summary> public static List <Faq> GetAllForVersion(int version) { if (RemotingClient.RemotingRole == RemotingRole.ClientWeb) { return(Meth.GetObject <List <Faq> >(MethodBase.GetCurrentMethod(), version)); } string command = $"SELECT * FROM faq WHERE ManualVersion={version.ToString()}"; List <Faq> retVal = new List <Faq>(); DataAction.RunManualPublisherHQ(() => { retVal = Crud.FaqCrud.SelectMany(command); }); return(retVal); }