/// <summary> /// Callback Method that gets called from the 'FirstChanceException' Event if the Exception meant that /// a DB Connection got broken and hence attempts to restore it automatically should be performed. /// </summary> /// <param name="ASource">Provided automatically by .NET - not used.</param> /// <param name="AException">Provided automatically by .NET (holds the Exception that just occurred) /// - not used.</param> public void ExceptionHandling_DBConnectionBrokenCallback(object ASource, Exception AException) { bool FlagWasntSet = false; Thread PerformDBReconnectionThread; lock (FDBConnectionBrokenLock) { if (!FDBConnectionBroken) { FDBConnectionBroken = true; FlagWasntSet = true; } } // Guard against reentry (this callback can be called numerous times [possibly in very quick succession]!): // --> Only take measures if this is the first call in a row! if (FlagWasntSet) { // Ensure we are starting a Thread for DB re-connection attempts only if the Server's DB Polling // DB Connection is actually broken. (Reason for this check: This Event Handler can get called because a // Client's AppDomain has come across a broken DB Connection *which since has been automatically restored*... // if we wouldn't do this check here then we would in this case start re-connection attempts on a perfectly // fine Server's DB Polling connection, which could have adverse side effects if DB commands are getting // executed on it while this would happen!) if (!IsDBConnectionOK()) { StopCheckDBConnectionTimer(); QueueClientTaskForAllClientsRegardingBrokenDBConnection(true); TDBReconnectionThread ParameterisedThreadWithCallback = new TDBReconnectionThread(this, FDBConnectionEstablishmentAtStartup, new TDBReconnectionThreadCallback(DBReconnectionCallback)); PerformDBReconnectionThread = new Thread( new ThreadStart(ParameterisedThreadWithCallback.PerformDBReconnection)); PerformDBReconnectionThread.Name = UserInfo.GUserInfo.UserID + "__DBReconnectionThread"; TLogging.LogAtLevel(7, PerformDBReconnectionThread.Name + " starting."); PerformDBReconnectionThread.Start(); } } }
public static Boolean VerifyPartner(Int64 APartnerKey) { TDBTransaction ReadTransaction; Boolean NewTransaction; PPartnerTable PartnerTable; Boolean ReturnValue = true; // initialise outout Arguments if (APartnerKey != 0) { ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, out NewTransaction); try { PartnerTable = PPartnerAccess.LoadByPrimaryKey(APartnerKey, ReadTransaction); } finally { if (NewTransaction) { DBAccess.GDBAccessObj.CommitTransaction(); TLogging.LogAtLevel(7, "TPartnerServerLookups.VerifyPartner: committed own transaction."); } } if (PartnerTable.Rows.Count == 0) { ReturnValue = false; } else { ReturnValue = true; } } else { // Return result as valid if Partner Key is 0. ReturnValue = true; } return(ReturnValue); }
/// <summary> /// Passes data as a Typed DataSet to the Screen, containing multiple DataTables. /// /// </summary> /// <returns>void</returns> public OfficeSpecificDataLabelsTDS GetData() { OfficeSpecificDataLabelsTDS ReturnValue; TDBTransaction ReadTransaction; Boolean NewTransaction; ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.RepeatableRead, TEnforceIsolationLevel.eilMinimum, out NewTransaction); ReturnValue = GetData(ReadTransaction); if (NewTransaction) { DBAccess.GDBAccessObj.CommitTransaction(); TLogging.LogAtLevel(7, "TOfficeSpecificDataLabelsUIConnector.GetData: committed own transaction."); } return(ReturnValue); }
public static System.Boolean GetInstalledPatches(out Ict.Petra.Shared.MSysMan.Data.SPatchLogTable APatchLogDT) { SPatchLogTable TmpTable = new SPatchLogTable(); APatchLogDT = new SPatchLogTable(); TDBTransaction ReadTransaction; Boolean NewTransaction = false; TLogging.LogAtLevel(9, "TSysManServerLookups.GetInstalledPatches called!"); ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.Serializable, TEnforceIsolationLevel.eilMinimum, out NewTransaction); try { // Load data TmpTable = SPatchLogAccess.LoadAll(ReadTransaction); } finally { if (NewTransaction) { DBAccess.GDBAccessObj.CommitTransaction(); TLogging.LogAtLevel(7, "TSysManServerLookups.GetInstalledPatches: committed own transaction."); } } /* Sort the data... */ TmpTable.DefaultView.Sort = SPatchLogTable.GetDateRunDBName() + " DESC, " + SPatchLogTable.GetPatchNameDBName() + " DESC"; /* ...and put it in the output table. */ for (int Counter = 0; Counter < TmpTable.DefaultView.Count; ++Counter) { TLogging.LogAtLevel(7, "Patch: " + TmpTable.DefaultView[Counter][0]); APatchLogDT.ImportRow(TmpTable.DefaultView[Counter].Row); } return(true); }
public static PBankingDetailsTable GetPartnerBankingDetails(long AFromPartnerKey, long AToPartnerKey) { TDBTransaction Transaction = DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.ReadCommitted); PBankingDetailsTable ReturnTable = new PBankingDetailsTable(); try { PBankingDetailsTable FromBankingDetailsTable = PBankingDetailsAccess.LoadViaPPartner(AFromPartnerKey, Transaction); PBankingDetailsTable ToBankingDetailsTable = PBankingDetailsAccess.LoadViaPPartner(AToPartnerKey, Transaction); // clone the data in each table and add them to a new table to combine the data foreach (DataRow Row in FromBankingDetailsTable.Rows) { object[] RowArray = Row.ItemArray; object[] RowArrayClone = (object[])RowArray.Clone(); DataRow RowClone = ReturnTable.NewRowTyped(false); RowClone.ItemArray = RowArrayClone; ReturnTable.Rows.Add(RowClone); } foreach (DataRow Row in ToBankingDetailsTable.Rows) { object[] RowArray = Row.ItemArray; object[] RowArrayClone = (object[])RowArray.Clone(); DataRow RowClone = ReturnTable.NewRowTyped(false); RowClone.ItemArray = RowArrayClone; ReturnTable.Rows.Add(RowClone); } } catch (Exception e) { TLogging.Log(e.ToString()); } finally { DBAccess.GDBAccessObj.RollbackTransaction(); TLogging.LogAtLevel(7, "TMergePartnersWebConnector.GetPartnerBankingDetails: rollback own transaction."); } return(ReturnTable); }
public static BankTDS GetPBankRecords() { TDBTransaction ReadTransaction; Boolean NewTransaction; BankTDS ReturnValue = new BankTDS(); ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, out NewTransaction); try { string QueryBankRecords = "SELECT PUB_p_bank.*, PUB_p_partner.p_status_code_c, PUB_p_location.* " + "FROM PUB_p_bank JOIN PUB_p_partner ON PUB_p_partner.p_partner_key_n = PUB_p_bank.p_partner_key_n " + "LEFT OUTER JOIN PUB_p_partner_location ON PUB_p_bank.p_partner_key_n = PUB_p_partner_location.p_partner_key_n " + "AND (PUB_p_partner_location.p_date_good_until_d IS NULL OR PUB_p_partner_location.p_date_good_until_d >= DATE(NOW())) " + "JOIN PUB_p_location ON PUB_p_partner_location.p_site_key_n = PUB_p_location.p_site_key_n " + "AND PUB_p_partner_location.p_location_key_i = PUB_p_location.p_location_key_i"; DBAccess.GDBAccessObj.Select(ReturnValue, QueryBankRecords, ReturnValue.PBank.TableName, ReadTransaction, null); foreach (BankTDSPBankRow Row in ReturnValue.PBank.Rows) { // mark inactive bank accounts if (Row.StatusCode != SharedTypes.StdPartnerStatusCodeEnumToString(TStdPartnerStatusCode.spscACTIVE)) { Row.BranchCode = SharedConstants.INACTIVE_VALUE_WITH_QUALIFIERS + " " + Row.BranchCode; } } } finally { if (NewTransaction) { DBAccess.GDBAccessObj.RollbackTransaction(); TLogging.LogAtLevel(7, "TPartnerDataReaderWebConnector.GetPBankRecords: committed own transaction."); } } return(ReturnValue); }
public static IndividualDataTDS GetData(Int64 APartnerKey, TIndividualDataItemEnum AIndivDataItem) { IndividualDataTDS ReturnValue; TDBTransaction ReadTransaction; Boolean NewTransaction; ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.RepeatableRead, TEnforceIsolationLevel.eilMinimum, out NewTransaction); ReturnValue = GetData(APartnerKey, AIndivDataItem, ReadTransaction); if (NewTransaction) { DBAccess.GDBAccessObj.CommitTransaction(); TLogging.LogAtLevel(7, "TIndividualDataWebConnector.GetData: committed own transaction."); } return(ReturnValue); }
private static String GetConferencePrefix(long AConferenceKey) { TDBTransaction ReadTransaction; Boolean NewTransaction = false; String ConferencePrefix = "-----"; PUnitTable UnitTable; TLogging.LogAtLevel(9, "TConferenceOptions.GetOutreachPrefix: called."); TDataBase db = DBAccess.Connect("GetConferencePrefix"); ReadTransaction = db.GetNewOrExistingTransaction(IsolationLevel.RepeatableRead, out NewTransaction); try { UnitTable = PUnitAccess.LoadByPrimaryKey(AConferenceKey, ReadTransaction); if (UnitTable.Rows.Count > 0) { if (UnitTable.Rows[0][PUnitTable.GetOutreachCodeDBName()] != System.DBNull.Value) { ConferencePrefix = (string)UnitTable.Rows[0][PUnitTable.GetOutreachCodeDBName()]; if (ConferencePrefix.Length > 5) { ConferencePrefix = ConferencePrefix.Substring(0, 5); } } } } finally { if (NewTransaction) { ReadTransaction.Commit(); TLogging.LogAtLevel(7, "TConferenceOptions.GetOutreachPrefix: committed own transaction."); } } return(ConferencePrefix); }
/// <summary> /// Checks whether an Extract with a certain Extract Name exists. /// </summary> /// <param name="AExtractName">Name of the Extract to check for.</param> /// <returns>True if an Extract with the specified Extract Name exists, /// otherwise false.</returns> public static bool CheckExtractExists(string AExtractName) { TDBTransaction ReadTransaction; Boolean NewTransaction; Boolean ReturnValue = false; MExtractMasterRow TemplateRow; ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, out NewTransaction); // Check if there is already an extract with the extract name try { TemplateRow = new MExtractMasterTable().NewRowTyped(false); TemplateRow.ExtractName = AExtractName; if (MExtractMasterAccess.CountUsingTemplate(TemplateRow, null, ReadTransaction) > 0) { ReturnValue = true; } if (NewTransaction) { DBAccess.GDBAccessObj.CommitTransaction(); TLogging.LogAtLevel(8, "TExtractsHandling.CheckExtractExists: committed own transaction!"); } } catch (Exception Exc) { TLogging.Log("An Exception occured during the checking whether an Extract exists:" + Environment.NewLine + Exc.ToString()); if (NewTransaction) { DBAccess.GDBAccessObj.RollbackTransaction(); } throw; } return(ReturnValue); }
/// <summary> /// Constructor for passing in parameters. /// </summary> public TClientStillAliveCheck(TConnectedClient AConnectedClient, TClientServerConnectionType AClientServerConnectionType, TDelegateTearDownAppDomain ATearDownAppDomain) { FClientObject = AConnectedClient; ClientName = FClientObject.ClientName; Int32 ClientStillAliveTimeout; TLogging.LogAtLevel(2, "TClientStillAliveCheck (for ClientName '" + ClientName + "'') created"); // Determine timeout limit (different for Clients connected via LAN or Remote) if (AClientServerConnectionType == TClientServerConnectionType.csctRemote) { ClientStillAliveTimeout = TSrvSetting.ClientKeepAliveTimeoutAfterXSecondsRemote; } else if (AClientServerConnectionType == TClientServerConnectionType.csctLAN) { ClientStillAliveTimeout = TSrvSetting.ClientKeepAliveTimeoutAfterXSecondsLAN; } else { ClientStillAliveTimeout = TSrvSetting.ClientKeepAliveTimeoutAfterXSecondsLAN; } UClientStillAliveTimeout = ClientStillAliveTimeout; UClientStillAliveCheckInterval = TSrvSetting.ClientKeepAliveCheckIntervalInSeconds; UTearDownAppDomain = ATearDownAppDomain; // UTearDownAppDomainToken = ATearDownAppDomainToken; TLogging.LogAtLevel(2, "ClientStillAliveTimeout: " + ClientStillAliveTimeout.ToString() + "; " + "ClientKeepAliveCheckIntervalInSeconds: " + UClientStillAliveCheckInterval.ToString()); // Start ClientStillAliveCheckThread UKeepServerAliveCheck = true; UClientStillAliveCheckThread = new Thread(new ThreadStart(ClientStillAliveCheckThread)); UClientStillAliveCheckThread.Name = "ClientStillAliveCheckThread" + Guid.NewGuid().ToString(); UClientStillAliveCheckThread.IsBackground = true; UClientStillAliveCheckThread.Start(); TLogging.LogAtLevel(2, "TClientStillAliveCheck (for ClientName '" + ClientName + "'): started ClientStillAliveCheckThread."); }
/// <summary> /// Procedure to execute a Find query. Although the full /// query results are retrieved from the DB and stored internally in an object, /// data will be returned in 'pages' of data, each page holding a defined number /// of records. /// </summary> /// <param name="ACriteriaData">HashTable containing non-empty Partner Find parameters</param> public void PerformSearch(DataTable ACriteriaData) { String CustomWhereCriteria; OdbcParameter[] ParametersArray; FPagedDataSetObject = new TPagedDataSet(new PartnerFindTDSSearchResultTable()); // Pass the TAsynchronousExecutionProgress object to FPagedDataSetObject so that it // Build WHERE criteria string based on AFindCriteria CustomWhereCriteria = BuildCustomWhereCriteria(ACriteriaData, out ParametersArray); TLogging.LogAtLevel(6, "WHERE CLAUSE: " + CustomWhereCriteria); FPagedDataSetObject.FindParameters = new TPagedDataSet.TAsyncFindParameters( " p_city_c, p_postal_code_c, p_locality_c, p_street_name_c, p_address_3_c, p_county_c, p_country_code_c, p_location_key_i, p_site_key_n ", "PUB_p_location ", " p_location_key_i<>-1 " + CustomWhereCriteria + ' ', "p_city_c ", null, ParametersArray); // fields // table // where // order by // both empty for now string session = TSession.GetSessionID(); string configfilename = TAppSettingsManager.ConfigFileName; // // Start the Find Thread // ThreadStart myThreadStart = delegate { FPagedDataSetObject.ExecuteQuery(configfilename, session); }; FFindThread = new Thread(myThreadStart); FFindThread.Name = "PartnerLocationFind" + Guid.NewGuid().ToString(); }
/// <summary> /// todoComment /// </summary> /// <param name="AInspectDT"></param> public void SubmitChangesAsync(PSubscriptionTable AInspectDT) { Thread TheThread; // Cleanup (might be left in a certain state from a possible earlier call) FSubmitException = null; FSubmissionDT = null; FVerificationResult = null; FResponseDT = null; FInspectDT = null; FProgressID = Guid.NewGuid().ToString(); TProgressTracker.InitProgressTracker(FProgressID, string.Empty, 100.0m); FInspectDT = AInspectDT; ThreadStart ThreadStartDelegate = new ThreadStart(SubmitChangesInternal); TheThread = new Thread(ThreadStartDelegate); TheThread.Name = "ExtractsAddSubscriptionsSubmitChanges" + Guid.NewGuid().ToString(); TheThread.Start(); TLogging.LogAtLevel(6, "TExtractsAddSubscriptionsUIConnector.SubmitChangesAsync thread started."); }
private static BankImportTDS LoadData(Int32 ALedgerNumber, Int32 AStatementKey) { TDBTransaction dbtransaction = DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.ReadCommitted); BankImportTDS MatchDS = new BankImportTDS(); // TODO: would it help not to load all? use a_recent_match_d? AEpMatchAccess.LoadViaALedger(MatchDS, ALedgerNumber, dbtransaction); TLogging.LogAtLevel(1, "loaded " + MatchDS.AEpMatch.Rows.Count.ToString() + " a_ep_match rows"); AEpTransactionAccess.LoadViaAEpStatement(MatchDS, AStatementKey, dbtransaction); DBAccess.GDBAccessObj.RollbackTransaction(); MatchDS.AEpMatch.AcceptChanges(); MatchDS.AEpTransaction.AcceptChanges(); return(MatchDS); }
/// <summary> /// todoComment /// </summary> /// <param name="AInspectDT"></param> public void SubmitChangesAsync(PSubscriptionTable AInspectDT) { Thread TheThread; // Cleanup (might be left in a certain state from a possible earlier call) FSubmitException = null; FSubmissionDT = null; FAsyncExecProgress = null; FVerificationResult = null; FResponseDT = null; FInspectDT = null; this.FAsyncExecProgress = new TAsynchronousExecutionProgress(); this.FAsyncExecProgress.ProgressState = TAsyncExecProgressState.Aeps_ReadyToStart; FInspectDT = AInspectDT; ThreadStart ThreadStartDelegate = new ThreadStart(SubmitChangesInternal); TheThread = new Thread(ThreadStartDelegate); TheThread.Start(); TLogging.LogAtLevel(6, "TExtractsAddSubscriptionsUIConnector.SubmitChangesAsync thread started."); }
private static void StoreSessionCookie(CookieContainer AContainer, string AUrl) { // store the session cookie only if we don't have one if (OverallCookie == null) { foreach (Cookie c in AContainer.GetCookies(new Uri(AUrl))) { if (c.Name == "OpenPetraSessionID") { TLogging.LogAtLevel(1, "returned cookie\r\n" + "Name: " + c.Name + "\r\n" + "Value: " + c.Value + "\r\n" + "Path: " + c.Path + "\r\n" + "Domain: " + c.Domain); OverallCookie = new Cookie(c.Name, c.Value, c.Path, c.Domain); } } } }
/// <summary> /// clear the current session /// </summary> static public void Clear() { // HttpContext.Current.Session.Clear(); TLogging.LogAtLevel(1, "TSession.Clear got called"); string sessionId = GetSessionID(); TLogging.LogAtLevel(1, "TSession.Clear: sessionID = " + sessionId); if (sessionId.Length > 0) { FSessionObjects.Remove(sessionId); HttpContext.Current.Request.Cookies.Remove("OpenPetraSessionID"); HttpContext.Current.Response.Cookies.Remove("OpenPetraSessionID"); // thread might be reused??? FSessionID = null; TLogging.LogAtLevel(1, "TSession.Clear: cleared session with sessionID = " + sessionId); } }
public static System.Boolean GetDBVersion(out System.String APetraDBVersion) { TDBTransaction ReadTransaction; Boolean NewTransaction; APetraDBVersion = "Can not retrieve DB version"; TLogging.LogAtLevel(9, "TSysManServerLookups.GetDatabaseVersion called!"); SSystemDefaultsTable SystemDefaultsDT = new SSystemDefaultsTable(); ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, out NewTransaction); // Load data SystemDefaultsDT = SSystemDefaultsAccess.LoadByPrimaryKey("CurrentDatabaseVersion", ReadTransaction); if (NewTransaction) { DBAccess.GDBAccessObj.CommitTransaction(); TLogging.LogAtLevel(7, "TSysManServerLookups.GetDatabaseVersion: committed own transaction."); } if (SystemDefaultsDT.Rows.Count < 1) { throw new EOPAppException( "TSysManServerLookups.GetDBVersion: s_system_defaults DB Table is empty; this is unexpected and can lead to sever malfunction of OpenPetra. Contact your Support Team."); } SSystemDefaultsRow sysrow = SystemDefaultsDT.Rows[0] as SSystemDefaultsRow; if (sysrow == null) { throw new EOPAppException( "TSysManServerLookups.GetDBVersion: s_system_defaults DB Table is empty; this is unexpected and can lead to sever malfunction of OpenPetra. Contact your Support Team."); } APetraDBVersion = sysrow.DefaultValue; return(true); }
/// <summary> /// Displays a general error message in a MessageBox. /// </summary> /// <param name="AErrorText">Error text to be displayed.</param> /// <param name="ATitle">Title of the MessageBox.</param> /// <param name="AMessageNumber">Message Number.</param> /// <param name="ATypeWhichRaisesError">Instance of an object which raises the Error.</param> /// <param name="AIcon">Icon to show in the MessageBox.</param> public static void MsgGeneralError(String AErrorText, String ATitle, String AMessageNumber, System.Type ATypeWhichRaisesError, MessageBoxIcon AIcon) { if (ATypeWhichRaisesError == null) { ATypeWhichRaisesError = new StackTrace(false).GetFrame(2).GetMethod().DeclaringType; } // Remove possible trailing double Environment.NewLines // (Double Environment.NewLines happen if several error messages are concatenated and they are each separated by double Environment.NewLines) if (AErrorText.EndsWith(Environment.NewLine + Environment.NewLine)) { AErrorText = AErrorText.Substring(0, AErrorText.Length - Environment.NewLine.Length); } string message = AErrorText + BuildMessageFooter(AMessageNumber, ATypeWhichRaisesError.Name); TLogging.LogAtLevel(1, ATitle + ": " + message); MessageBox.Show(message, ATitle, MessageBoxButtons.OK, AIcon); }
private void CopyRowsInPage(Int16 APage, Int16 APageSize) { TLogging.LogAtLevel(7, String.Format("TPagedDataSet.CopyRowsInPage called (APage: {0}, APageSize={1})", APage, APageSize)); Int32 RowInPage; Int32 MaxRowInPage; MaxRowInPage = (APageSize * APage) + APageSize; if (MaxRowInPage > FTotalRecords) { MaxRowInPage = FTotalRecords; } for (RowInPage = (APageSize * APage); RowInPage <= MaxRowInPage - 1; RowInPage += 1) { FPageDataTable.ImportRow(FTmpDataTable.Rows[RowInPage]); } TLogging.LogAtLevel(7, String.Format("TPagedDataSet.CopyRowsInPage imported {0} rows into FPageDataTable", RowInPage)); }
/// <summary> /// Closes the Database connection for this AppDomain. /// /// @comment WARNING: If you need to rename this method or change its parameters, /// you also need to change the String with its name and the parameters in the /// .NET Reflection call in TClientAppDomainConnection! /// /// </summary> /// <returns>void</returns> public void CloseDBConnection() { // Console.WriteLine('TClientDomainManager.CloseDBConnection in AppDomain: ' + Thread.GetDomain().FriendlyName); TLogging.LogAtLevel(9, "TClientDomainManager.CloseDBConnection: before calling GDBAccessObj.CloseDBConnection"); try { DBAccess.GDBAccessObj.CloseDBConnection(); } catch (EDBConnectionNotAvailableException) { // The DB connection was never opened. Since this is no problem here, ignore this Exception. TLogging.LogAtLevel(9, "TClientDomainManager.CloseDBConnection: Info: DB Connection was never opened, so can't close."); } catch (Exception) { throw; } TLogging.LogAtLevel(9, "TClientDomainManager.CloseDBConnection: after calling GDBAccessObj.CloseDBConnection"); }
public static PUnitTable GetActiveFieldUnits() { PUnitTable UnitTable = new PUnitTable(); PUnitRow UnitRow; TLogging.LogAtLevel(9, "TPartnerDataReaderWebConnector.GetActiveFieldUnits called!"); TDBTransaction Transaction = null; DBAccess.GDBAccessObj.BeginAutoReadTransaction(IsolationLevel.ReadCommitted, ref Transaction, delegate { // Load data string SqlStmt = "SELECT pub_" + PUnitTable.GetTableDBName() + "." + PUnitTable.GetPartnerKeyDBName() + ", pub_" + PUnitTable.GetTableDBName() + "." + PUnitTable.GetUnitNameDBName() + " FROM " + PUnitTable.GetTableDBName() + ", " + PPartnerTable.GetTableDBName() + " WHERE ((" + PUnitTable.GetOutreachCodeDBName() + " IS NULL)" + " OR(" + PUnitTable.GetOutreachCodeDBName() + " = ''))" + " AND " + PUnitTable.GetUnitTypeCodeDBName() + " <> 'KEY-MIN'" + " AND pub_" + PUnitTable.GetTableDBName() + "." + PUnitTable.GetPartnerKeyDBName() + " = pub_" + PPartnerTable.GetTableDBName() + "." + PPartnerTable.GetPartnerKeyDBName() + " AND " + PPartnerTable.GetStatusCodeDBName() + " = 'ACTIVE'"; // sort rows according to name SqlStmt = SqlStmt + " ORDER BY " + PUnitTable.GetUnitNameDBName(); DataTable events = DBAccess.GDBAccessObj.SelectDT(SqlStmt, "fields", Transaction); foreach (DataRow eventRow in events.Rows) { UnitRow = (PUnitRow)UnitTable.NewRow(); UnitRow.PartnerKey = Convert.ToInt64(eventRow[0]); UnitRow.UnitName = Convert.ToString(eventRow[1]); UnitTable.Rows.Add(UnitRow); } }); return(UnitTable); }
public static DataTable GetOutreachTypes(long APartnerKey) { TDBTransaction ReadTransaction; ReadTransaction = DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.ReadCommitted); DataTable Table = new PUnitTable(); try { string OutreachPrefixCode = ((PcConferenceRow)PcConferenceAccess.LoadByPrimaryKey(APartnerKey, ReadTransaction).Rows[0]).OutreachPrefix; PUnitTable UnitTable = PUnitAccess.LoadAll(ReadTransaction); // add PUnit rows with matching OutreachPrefixCode to the new DataTable foreach (PUnitRow Row in UnitTable.Rows) { if ((Row.OutreachCode.Length == 13) && (Row.OutreachCode.Substring(0, 5) == OutreachPrefixCode)) { DataRow CopyRow = Table.NewRow(); ((PUnitRow)CopyRow).PartnerKey = Row.PartnerKey; ((PUnitRow)CopyRow).OutreachCode = Row.OutreachCode.Substring(5, 6); ((PUnitRow)CopyRow).UnitName = Row.UnitName; Table.Rows.Add(CopyRow); } } } catch (Exception e) { TLogging.Log(e.ToString()); } finally { DBAccess.GDBAccessObj.RollbackTransaction(); TLogging.LogAtLevel(7, "TConferenceDataReaderWebConnector.GetOutreachTypes: commit own transaction."); } return(Table); }
/// <summary> /// Stops the query execution. /// <remarks>It might take some time until the executing query is cancelled by the DB, but this procedure returns /// immediately. The reason for this is that we consider the query cancellation as done since the application can /// 'forget' about the result of the cancellation process (but beware of executing another query while the other is /// stopping - this leads to ADO.NET errors that state that a ADO.NET command is still executing!). /// </remarks> /// </summary> public void StopSearch() { Thread StopQueryThread; /* Start a separate Thread that should cancel the executing query * (Microsoft recommends doing it this way!) */ TLogging.LogAtLevel(7, "TPartnerLocationFindUIConnector.StopSearch: Starting StopQuery thread..."); StopQueryThread = new Thread(new ThreadStart(FPagedDataSetObject.StopQuery)); StopQueryThread.Name = UserInfo.GUserInfo.UserID + "__ParnterFind_StopSearch_Thread"; StopQueryThread.Start(); /* It might take some time until the executing query is cancelled by the DB, * but we consider it as done since the application can 'forget' about the * result of the cancellation process (but beware of executing another query * while the other is stopping - this leads to ADO.NET errors that state that * a ADO.NET command is still executing! */ TLogging.LogAtLevel(7, "TPartnerLocationFindUIConnector.StopSearch: Query cancelled!"); }
public TSubmitChangesResult PrepareChangesServerSide( DataTable AInspectDT, TDBTransaction AReadTransaction) { TSubmitChangesResult SubmissionResult = TSubmitChangesResult.scrOK; // TODO: once we have centrally cached data tables on the server then get the data // from there. Until then just load it on the spot here! PDataLabelTable DataLabelDT = PDataLabelAccess.LoadAll(AReadTransaction); if (AInspectDT != null) { // Run through all rows of the value table and see if the significant column is empty/null. If so // then delete the row from the table (these rows are not needed any longer in order to save space // in the database) int NumRows = AInspectDT.Rows.Count; for (int RowIndex = NumRows - 1; RowIndex >= 0; RowIndex -= 1) { DataRow InspectedDataRow = AInspectDT.Rows[RowIndex]; // only check modified or added rows because the deleted ones are deleted anyway if ((InspectedDataRow.RowState == DataRowState.Modified) || (InspectedDataRow.RowState == DataRowState.Added)) { if (IsRowObsolete(DataLabelDT, InspectedDataRow, (AInspectDT.TableName == PDataLabelValuePartnerTable.GetTableName()))) { InspectedDataRow.Delete(); } } } } else { TLogging.LogAtLevel(8, "AInspectDS = null!"); SubmissionResult = TSubmitChangesResult.scrNothingToBeSaved; } return(SubmissionResult); }
public static int CanFamilyMergeIntoDifferentClass(long APartnerKey) { TDBTransaction Transaction = DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.ReadCommitted); try { PPersonTable PersonTable = PPersonAccess.LoadViaPFamily(APartnerKey, Transaction); if (PersonTable.Rows.Count > 0) { return(1); } AGiftDetailTable GiftDetailTable = AGiftDetailAccess.LoadViaPPartnerRecipientKey(APartnerKey, Transaction); if (GiftDetailTable.Rows.Count > 0) { return(2); } PBankingDetailsTable BankingDetailsTable = PBankingDetailsAccess.LoadViaPPartner(APartnerKey, Transaction); if (BankingDetailsTable.Rows.Count > 0) { return(3); } } catch (Exception e) { TLogging.Log(e.ToString()); } finally { DBAccess.GDBAccessObj.RollbackTransaction(); TLogging.LogAtLevel(7, "TMergePartnersWebConnector.CanFamilyMergeIntoDifferentClass: rollback own transaction."); } return(0); }
/// <summary> /// Loads the System Defaults into the cached Typed DataTable. /// /// The System Defaults are retrieved from the s_system_defaults table and are /// put into a Typed DataTable that has the structure of this table. /// /// </summary> /// <returns>void</returns> private void LoadSystemDefaultsTable() { TDBTransaction ReadTransaction; Boolean NewTransaction = false; // Prevent other threads from obtaining a read lock on the cache table while we are (re)loading the cache table! FReadWriteLock.AcquireWriterLock(SharedConstants.THREADING_WAIT_INFINITE); try { if (FSystemDefaultsDT != null) { FSystemDefaultsDT.Clear(); } try { ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.RepeatableRead, TEnforceIsolationLevel.eilMinimum, out NewTransaction); FSystemDefaultsDT = SSystemDefaultsAccess.LoadAll(ReadTransaction); } finally { if (NewTransaction) { DBAccess.GDBAccessObj.CommitTransaction(); TLogging.LogAtLevel(7, "TSystemDefaultsCache.LoadSystemDefaultsTable: commited own transaction."); } } // Thread.Sleep(5000); uncomment this for debugging. This allows checking whether read access to FSystemDefaultsDT actually waits until we release the WriterLock in the finally block. } finally { // Other threads are now free to obtain a read lock on the cache table. FReadWriteLock.ReleaseWriterLock(); } }
public static PPartnerTable SharedBankAccountPartners(int ABankingDetailsKey, long APartnerKey) { TDBTransaction ReadTransaction; Boolean NewTransaction; PPartnerTable PartnerTable = new PPartnerTable(); ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, out NewTransaction); try { PPartnerBankingDetailsTable PartnerBankingDetailsTable = PPartnerBankingDetailsAccess.LoadViaPBankingDetails(ABankingDetailsKey, ReadTransaction); foreach (PPartnerBankingDetailsRow Row in PartnerBankingDetailsTable.Rows) { // if record exists with a different partner key then the Bank Account is shared if (Row.PartnerKey != APartnerKey) { PPartnerRow PartnerRow = (PPartnerRow)PPartnerAccess.LoadByPrimaryKey(Row.PartnerKey, ReadTransaction).Rows[0]; PPartnerRow NewRow = PartnerTable.NewRowTyped(false); NewRow.PartnerKey = Row.PartnerKey; NewRow.PartnerShortName = PartnerRow.PartnerShortName; PartnerTable.Rows.Add(NewRow); } } } finally { if (NewTransaction) { DBAccess.GDBAccessObj.CommitTransaction(); TLogging.LogAtLevel(7, "TPartnerDataReaderWebConnector.IsBankingDetailsRowShared: committed own transaction."); } } return(PartnerTable); }
/// <summary> /// Cancels an asynchronously executing query. This might take some time; /// therefore always execute this procedure in a separate Thread! /// /// </summary> /// <returns>void</returns> public void StopQuery() { TLogging.LogAtLevel(7, (this.GetType().FullName + ".StopQuery: ProgressState = " + Enum.GetName(typeof(TAsyncExecProgressState), FAsyncExecProgress.ProgressState))); try { if (FAsyncExecProgress.ProgressState == TAsyncExecProgressState.Aeps_Stopping) { // Cancel the executing query. TLogging.LogAtLevel(7, "TPagedDataSet.StopQuery called..."); FDataAdapter.SelectCommand.Cancel(); TLogging.LogAtLevel(7, "TPagedDataSet.StopQuery finished."); } else { TLogging.LogAtLevel(7, this.GetType().FullName + ".StopQuery: Query got cancelled after returning records."); } FAsyncExecProgress.ProgressInformation = "Query cancelled!"; FAsyncExecProgress.ProgressState = TAsyncExecProgressState.Aeps_Stopped; } catch (Exception exp) { TLogging.Log(this.GetType().FullName + ".StopQuery: Exception occured: " + exp.ToString()); /* * WE MUST 'SWALLOW' ANY EXCEPTION HERE, OTHERWISE THE WHOLE * PETRASERVER WILL GO DOWN!!! (THIS BEHAVIOUR IS NEW WITH .NET 2.0.) * * --> ANY EXCEPTION THAT WOULD LEAVE THIS METHOD WOULD BE SEEN AS AN <-- * --> UNHANDLED EXCEPTION IN A THREAD, AND THE .NET/MONO RUNTIME <-- * --> WOULD BRING DOWN THE WHOLE PETRASERVER PROCESS AS A CONSEQUENCE! <-- * */ } }
private static bool GetReceivingFieldsForOneConference(long AConferenceKey, ref DataTable AFieldsTable) { TDBTransaction ReadTransaction; Boolean NewTransaction = false; TLogging.LogAtLevel(9, "TConferenceOptions.GetReceivingFieldsForOneConference called!"); TDataBase db = DBAccess.Connect("GetReceivingFieldsForOneConference"); ReadTransaction = db.GetNewOrExistingTransaction(IsolationLevel.RepeatableRead, out NewTransaction); try { String PartnerKeyDBName = PcAttendeeTable.GetPartnerKeyDBName(); PcAttendeeTable AttendeeTable; StringCollection FieldList = new StringCollection(); FieldList.Add(PartnerKeyDBName); AttendeeTable = PcAttendeeAccess.LoadViaPcConference(AConferenceKey, FieldList, ReadTransaction); foreach (DataRow Row in AttendeeTable.Rows) { long PartnerKey = (long)Row[PartnerKeyDBName]; GetReceivingFieldFromGiftDestination(PartnerKey, ref AFieldsTable); GetReceivingFieldFromShortTermTable(PartnerKey, ref AFieldsTable); } } finally { if (NewTransaction) { ReadTransaction.Commit(); TLogging.LogAtLevel(7, "TConferenceOptions.GetReceivingFieldsForOneConference: committed own transaction."); } } return(true); }
private static SortedList <string, string> FSessionValues; // STATIC_OK: will be set for each request /// <summary> /// Set the session id for this current thread. /// Each request has its own thread. /// Threads can be reused for different users. /// </summary> /// <param name="ASessionID"></param> public static void InitThread(string ASessionID = null) { TLogging.LogAtLevel(1, "Running InitThread for thread id " + Thread.CurrentThread.ManagedThreadId.ToString()); FSessionID = ASessionID; FSessionValues = null; string sessionID; if (ASessionID == null) { sessionID = FindSessionID(); } else { sessionID = ASessionID; } TDataBase db = ConnectDB("SessionInitThread"); TDBTransaction t = new TDBTransaction(); bool SubmissionOK = false; db.WriteTransaction(ref t, ref SubmissionOK, delegate { // get the session ID, or start a new session // load the session values from the database // update the session last access in the database // clean old sessions InitSession(sessionID, t); SubmissionOK = true; }); db.CloseDBConnection(); }