public static System.Boolean GetDBVersion(out System.String APetraDBVersion) { TDBTransaction ReadTransaction = null; APetraDBVersion = "Cannot retrieve DB version"; TLogging.LogAtLevel(9, "TSysManServerLookups.GetDatabaseVersion called!"); SSystemDefaultsTable SystemDefaultsDT = new SSystemDefaultsTable(); DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction( IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, ref ReadTransaction, delegate { // Load data SystemDefaultsDT = SSystemDefaultsAccess.LoadByPrimaryKey("CurrentDatabaseVersion", ReadTransaction); }); 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; }
private void RunOnceOnActivationManual() { // Start by dealing with the settings classes that will be displayed in the combo box filter DataTable settingsClassDT = FMainDS.SSystemDefaults.DefaultView.ToTable("SettingsClass", true, SSystemDefaultsTable.GetCategoryDBName()); if (Form.ModifierKeys == (Keys.Alt | Keys.Shift)) { // This is the back-door to showing all the system defaults FLaunchedInSysAdminMode = true; DataRow dr = settingsClassDT.NewRow(); dr[0] = "!SysAdmin!"; settingsClassDT.Rows.Add(dr); } cmbClass.DisplayMember = SSystemDefaultsTable.GetCategoryDBName(); cmbClass.ValueMember = SSystemDefaultsTable.GetCategoryDBName(); settingsClassDT.DefaultView.RowFilter = string.Format("{0} IS NOT NULL", SSystemDefaultsTable.GetCategoryDBName()); settingsClassDT.DefaultView.Sort = string.Format("{0}", cmbClass.DisplayMember); cmbClass.DataSource = settingsClassDT.DefaultView; // Select the first item in the class filter if (settingsClassDT.DefaultView.Count > 0) { cmbClass.SelectedIndex = 0; FActiveClass = cmbClass.GetSelectedString(); } // This will select the first row in the grid now that everything has been activated FSuppressClassChange = false; OnSettingsClassChange(null, null); }
public static SSystemDefaultsTable GetSystemDefaults() { SSystemDefaultsTable ReturnValue = null; TDBTransaction ReadTransaction = null; bool DBAccessCallSuccessful = false; DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction( IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, ref ReadTransaction, delegate { TServerBusyHelper.CoordinatedAutoRetryCall("Loading all SystemDefaults", ref DBAccessCallSuccessful, delegate { ReturnValue = SSystemDefaultsAccess.LoadAll(ReadTransaction); DBAccessCallSuccessful = true; }); }); if (!DBAccessCallSuccessful) { throw new EDBAccessLackingCoordinationException("Loading of System Default failed: server was too busy!"); } return(ReturnValue); }
public static TSubmitChangesResult SaveData(string ATablename, ref TTypedDataTable ASubmitTable, out TVerificationResultCollection AVerificationResult) { TSubmitChangesResult ReturnValue = TSubmitChangesResult.scrError; TDBTransaction WriteTransaction = null; TTypedDataTable SubmitTable = null; TVerificationResultCollection VerificationResult = null; SubmitTable = ASubmitTable; // Automatic handling of a DB Transaction - and also the automatic establishment and closing of a DB // Connection where a DB Transaction can be exectued (only if that should be needed). DBAccess.SimpleAutoTransactionWrapper("TCommonDataReader.SaveData", out WriteTransaction, ref ReturnValue, delegate { ReturnValue = SaveData(ATablename, ref SubmitTable, out VerificationResult, WriteTransaction); }); if ((ATablename == SSystemDefaultsTable.GetTableDBName()) && (ReturnValue == TSubmitChangesResult.scrOK)) { // Refresh the cache immediately so clients will get the changes TSystemDefaultsCache.GSystemDefaultsCache.ReloadSystemDefaultsTable(); } AVerificationResult = VerificationResult; return(ReturnValue); }
public static TSubmitChangesResult SaveData(string ATablename, ref TTypedDataTable ASubmitTable, out TVerificationResultCollection AVerificationResult) { // check access permissions for the current user TModuleAccessManager.CheckUserPermissionsForTable(ATablename, TTablePermissionEnum.eCanModify | TTablePermissionEnum.eCanModify | TTablePermissionEnum.eCanDelete); TSubmitChangesResult ReturnValue = TSubmitChangesResult.scrError; TTypedDataTable SubmitTable = null; TVerificationResultCollection VerificationResult = null; TDBTransaction WriteTransaction = new TDBTransaction(); TDataBase db = DBAccess.Connect("SaveData"); SubmitTable = ASubmitTable; bool submitOK = true; // Automatic handling of a DB Transaction - and also the automatic establishment and closing of a DB // Connection where a DB Transaction can be exectued (only if that should be needed). db.WriteTransaction( ref WriteTransaction, ref submitOK, delegate { ReturnValue = SaveData(ATablename, ref SubmitTable, out VerificationResult, WriteTransaction); submitOK = ReturnValue == TSubmitChangesResult.scrOK; }); AVerificationResult = VerificationResult; if ((ATablename == SSystemDefaultsTable.GetTableDBName()) && (ReturnValue == TSubmitChangesResult.scrOK)) { // TODO Reload the site key into the session, in case that was changed } return(ReturnValue); }
public static System.Boolean GetDBVersion(out System.String APetraDBVersion) { TDBTransaction ReadTransaction = null; APetraDBVersion = "Cannot retrieve DB version"; TLogging.LogAtLevel(9, "TSysManServerLookups.GetDatabaseVersion called!"); SSystemDefaultsTable SystemDefaultsDT = new SSystemDefaultsTable(); DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction( IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, ref ReadTransaction, delegate { // Load data SystemDefaultsDT = SSystemDefaultsAccess.LoadByPrimaryKey("CurrentDatabaseVersion", ReadTransaction); }); 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> /// Returns the value of the specified System Default. /// For that, the whole System Defaults DB table is read from the server - that's not a problem so long as there's not /// thousands of system defaults, and this method isn't called too often! /// </summary> /// <param name="ASystemDefaultName">The System Default for which the value should be returned.</param> /// <returns>The value of the System Default, or SYSDEFAULT_NOT_FOUND if the /// specified System Default was not found.</returns> public static String GetSystemDefault(String ASystemDefaultName) { SSystemDefaultsTable SystemDefaultsDT = null; SSystemDefaultsRow FoundSystemDefaultsRow; bool ServerCallSuccessful = false; TServerBusyHelper.CoordinatedAutoRetryCall("System Defaults", ref ServerCallSuccessful, delegate { SystemDefaultsDT = TRemote.MSysMan.Maintenance.SystemDefaults.WebConnectors.GetSystemDefaults(); ServerCallSuccessful = true; }); if (!ServerCallSuccessful) { TServerBusyHelperGui.ShowLoadingOfDataGotCancelledDialog(); return(SharedConstants.SYSDEFAULT_NOT_FOUND); } if (SystemDefaultsDT != null) { // Look up the System Default FoundSystemDefaultsRow = (SSystemDefaultsRow)SystemDefaultsDT.Rows.Find(ASystemDefaultName); return(FoundSystemDefaultsRow != null ? FoundSystemDefaultsRow.DefaultValue : SharedConstants.SYSDEFAULT_NOT_FOUND); } else { // 'Back-stop' - should never get here return(SharedConstants.SYSDEFAULT_NOT_FOUND); } }
private void FPetraUtilsObject_DataSavingValidated(object Sender, System.ComponentModel.CancelEventArgs e) { // Capture any rows that are going to be saved that we are interested in SSystemDefaultsTable submitDT = FMainDS.SSystemDefaults.GetChangesTyped(); FIncludesLocalisedCountyLabel = (SSystemDefaultsRow)submitDT.Rows.Find(SharedConstants.SYSDEFAULT_LOCALISEDCOUNTYLABEL); FIncludesDonorZero = (SSystemDefaultsRow)submitDT.Rows.Find(SharedConstants.SYSDEFAULT_DONORZEROISVALID); FIncludesRecipientZero = (SSystemDefaultsRow)submitDT.Rows.Find(SharedConstants.SYSDEFAULT_RECIPIENTZEROISVALID); }
private void OnSettingsClassChange(object sender, EventArgs e) { // We get called here when the settings class combo has changed if ((FFilterAndFindObject == null) || (FSuppressClassChange == true)) { return; } if (sender != null) { // We don't do this at startup, but after that we need to set the class back to what it was before if validation fails if (!ValidateAllData(false, TErrorProcessingMode.Epm_All)) { FSuppressClassChange = true; ((TCmbAutoComplete)sender).SetSelectedString(FActiveClass); FSuppressClassChange = false; return; } FActiveClass = ((TCmbAutoComplete)sender).GetSelectedString(); } // We need to know if we are displaying a sysAdmin row or not string sysAdminRowFilter = "12345"; string rowFilter = string.Format("{0}>0 AND ", FControlsCountName); if (cmbClass.SelectedValue == null) { rowFilter += "1=0"; } else if (FLaunchedInSysAdminMode && (cmbClass.SelectedIndex == 0)) { sysAdminRowFilter = string.Format("{0}=0 OR {1} IS NULL", FControlsCountName, SSystemDefaultsTable.GetCategoryDBName()); rowFilter = sysAdminRowFilter; } else { rowFilter += string.Format("{0}='{1}'", SSystemDefaultsTable.GetCategoryDBName(), cmbClass.SelectedValue.ToString()); } FFilterAndFindObject.FilterPanelControls.SetBaseFilter(rowFilter, true); // Both these will cause validation to run, but it should be ok because we checked it above FFilterAndFindObject.ApplyFilter(); SelectRowInGrid(1); // Depending on how validation worked out we now know whether we are displaying the sysAdmin codes or not FShowingSysAdminCodes = FMainDS.SSystemDefaults.DefaultView.RowFilter.StartsWith(sysAdminRowFilter); // Now we can show/hide columns 0 and 1 grdDetails.Columns[0].Visible = FShowingSysAdminCodes; grdDetails.Columns[1].Visible = !FShowingSysAdminCodes; grdDetails.AutoResizeGrid(); }
public static void SetSystemDefault(String AKey, String AValue) { Boolean NewTransaction = false; Boolean ShouldCommit = false; try { TDBTransaction Transaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, out NewTransaction); SSystemDefaultsTable tbl = SSystemDefaultsAccess.LoadByPrimaryKey(AKey, Transaction); if (tbl.Rows.Count > 0) // I already have this. (I expect this is the case usually!) { DataRow Row = tbl[0]; ((SSystemDefaultsRow)Row).DefaultValue = AValue; } else { DataRow Row = tbl.NewRowTyped(true); ((SSystemDefaultsRow)Row).DefaultCode = AKey; ((SSystemDefaultsRow)Row).DefaultDescription = "Created in OpenPetra"; ((SSystemDefaultsRow)Row).DefaultValue = AValue; tbl.Rows.Add(Row); } SSystemDefaultsAccess.SubmitChanges(tbl, Transaction); ShouldCommit = true; } catch (Exception Exc) { TLogging.Log("An Exception occured during the saving of a single System Default:" + Environment.NewLine + Exc.ToString()); ShouldCommit = false; throw; } finally { if (NewTransaction) { if (ShouldCommit) { DBAccess.GDBAccessObj.CommitTransaction(); } else { DBAccess.GDBAccessObj.RollbackTransaction(); } } } }
public static String GetSystemDefault(String ASystemDefaultName) { String ReturnValue = SharedConstants.SYSDEFAULT_NOT_FOUND; SSystemDefaultsTable SystemDefaultsTable = GetSystemDefaults(); // Look up the System Default SSystemDefaultsRow FoundSystemDefaultsRow = (SSystemDefaultsRow)SystemDefaultsTable.Rows.Find(ASystemDefaultName); if (FoundSystemDefaultsRow != null) { ReturnValue = FoundSystemDefaultsRow.DefaultValue; } return(ReturnValue); }
/// <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() { TDataBase DBAccessObj = new Ict.Common.DB.TDataBase(); TDBTransaction ReadTransaction = null; // 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 { DBAccessObj.EstablishDBConnection(TSrvSetting.RDMBSType, TSrvSetting.PostgreSQLServer, TSrvSetting.PostgreSQLServerPort, TSrvSetting.PostgreSQLDatabaseName, TSrvSetting.DBUsername, TSrvSetting.DBPassword, "", "SystemDefaultsCache DB Connection"); DBAccessObj.BeginAutoReadTransaction(IsolationLevel.RepeatableRead, ref ReadTransaction, delegate { FSystemDefaultsDT = SSystemDefaultsAccess.LoadAll(ReadTransaction); }); } finally { DBAccessObj.CloseDBConnection(); } // 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(); } }
/// <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() { TDataBase DBAccessObj = DBAccess.Connect("LoadSystemDefaultsTable", FDataBase); TDBTransaction ReadTransaction = new TDBTransaction(); if (FSystemDefaultsDT != null) { FSystemDefaultsDT.Clear(); } DBAccessObj.ReadTransaction(ref ReadTransaction, delegate { FSystemDefaultsDT = SSystemDefaultsAccess.LoadAll(ReadTransaction); }); if (FDataBase == null) { DBAccessObj.CloseDBConnection(); } }
/// <summary> /// Returns the value of the specified System Default. /// /// The whole table is read from the server - it's not a problem so long as there's not /// thousands of system defaults, and this method isn't called too often! /// /// </summary> /// <param name="ASystemDefaultName">The System Default for which the value should be returned</param> /// <returns>The value of the System Default, or SYSDEFAULT_NOT_FOUND if the /// specified System Default was not found /// </returns> public static String GetSystemDefault(String ASystemDefaultName) { String ReturnValue; SSystemDefaultsRow FoundSystemDefaultsRow; SSystemDefaultsTable SystemDefaultsDT = TRemote.MSysMan.Maintenance.SystemDefaults.WebConnectors.GetSystemDefaults(); // Look up the System Default FoundSystemDefaultsRow = (SSystemDefaultsRow)SystemDefaultsDT.Rows.Find(ASystemDefaultName); if (FoundSystemDefaultsRow != null) { ReturnValue = FoundSystemDefaultsRow.DefaultValue; } else { ReturnValue = SharedConstants.SYSDEFAULT_NOT_FOUND; } return(ReturnValue); }
/// <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(); } }
/// <summary> /// Saves changes to the submitted Typed SystemDefaults DataTable to the DB. /// /// @comment Currently always returns false because the function needs to be /// rewritten! /// /// @todo Rewrite this function so that it saves entries that originally came /// from the s_system_parameter table in the DB to this table instead of /// writing them to the s_system_defaults table! Also use the DataStore to /// save the data instead of using SQL queries!!! /// /// </summary> /// <param name="ASystemDefaultsDataTable">Typed SystemDefaults DataTable</param> /// <returns>true if the System Defaults could be saved successfully /// </returns> public Boolean SaveSystemDefaults(SSystemDefaultsTable ASystemDefaultsDataTable) { // var // Transaction: OdbcTransaction; // ParametersArray: array of OdbcParameter; // Counter, // DefaultInDataBaseCount: Int16; // AllSubmissionsOK: Boolean; /* TODO 2 oChristanK cDB : Rewrite this function so that it saves entries that originally came from the s_system_parameter table * in the DB to this table instead of writing them to the s_system_defaults table! Also use the DataStore to * save the data instead of using SQL queries!!! */ // Currently always returns false because the function needs to be rewritten! return false; // AllSubmissionsOK := false; // DefaultInDataBaseCount := 0; // // if (ASystemDefaultsDataTable <> nil) and (ASystemDefaultsDataTable.Rows.Count > 0) then // begin // $IFDEF DEBUGMODE if TLogging.DL >= 8 then Console.WriteLine('Saving ' + (ASystemDefaultsDataTable.Rows.Count).ToString + ' System Defaults...'); $ENDIF // // Transaction := DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.ReadCommitted); // // Loop over all changed/added System Defaults // for Counter := 0 to ASystemDefaultsDataTable.Rows.Count 1 do // begin // Look whether the System Default already exists in the DB // SetLength(ParametersArray, 1); // ParametersArray[0] := new OdbcParameter('', OdbcType.VarChar, 32); // ParametersArray[0].Value := ASystemDefaultsDataTable.Rows[Counter].Item['s_default_code_c'].ToString; // // try // DefaultInDataBaseCount := Convert.ToInt16( DBAccess.GDBAccessObj.ExecuteScalar( // 'SELECT COUNT) ' + // 'FROM PUB_s_system_defaults ' + // 'WHERE s_default_code_c = ?', Transaction, false, ParametersArray) ); // except // on exp: Exception do // begin // Result := false; // $IFDEF DEBUGMODE if TLogging.DL >= 9 then Console.WriteLine(this.GetType.FullName + '.SaveSystemDefaults: Error running count query!!! ' + // 'Possible cause: ' + exp.ToString); $ENDIF // Exit; // end; // end; // // if DefaultInDataBaseCount = 0 then // begin // System Default doesn't exist yet > create it /* $IFDEF DEBUGMODE if TLogging.DL >= 8 then Console.WriteLine('Inserting SystemDefault ' + ASystemDefaultsDataTable.Rows[Counter].Item['s_default_code_c'].ToString + '; Value: ' + *ASystemDefaultsDataTable.Rows[Counter].Item['s_default_value_c'].ToString);$ENDIF */ // SetLength(ParametersArray, 3); // ParametersArray[0] := new OdbcParameter('', OdbcType.VarChar, 32); // ParametersArray[0].Value := ASystemDefaultsDataTable.Rows[Counter].Item['s_default_code_c'].ToString; // ParametersArray[0] := new OdbcParameter('', OdbcType.VarChar, 48); // ParametersArray[0].Value := ASystemDefaultsDataTable.Rows[Counter].Item['s_default_description_c'].ToString; // ParametersArray[2] := new OdbcParameter('', OdbcType.VarChar, 96); // ParametersArray[2].Value := ASystemDefaultsDataTable.Rows[Counter].Item['s_default_value_c'].ToString; // // try // DBAccess.GDBAccessObj.ExecuteNonQuery( // 'INSERT INTO PUB_s_system_defaults ' + // '(s_default_code_c, s_default_description_c, s_default_value_c) ' + // 'VALUES (?, ?, ?)', Transaction, false, ParametersArray); // except // on exp: Exception do // begin // Result := false; // $IFDEF DEBUGMODE if TLogging.DL >= 9 then Console.WriteLine(this.GetType.FullName + '.SaveSystemDefaults: Error running insert query!!! ' + // 'Possible cause: ' + exp.ToString); $ENDIF // Exit; // end; // end; // end // else // begin // System Default exists > update it /* $IFDEF DEBUGMODE if TLogging.DL >= 8 then Console.WriteLine('Updating SystemDefault ' + ASystemDefaultsDataTable.Rows[Counter].Item['s_default_code_c'].ToString + '; Value: ' + *ASystemDefaultsDataTable.Rows[Counter].Item['s_default_value_c'].ToString);$ENDIF */ // SetLength(ParametersArray, 3); // ParametersArray[0] := new OdbcParameter('', OdbcType.VarChar, 48); // ParametersArray[0].Value := ASystemDefaultsDataTable.Rows[Counter].Item['s_default_description_c']; // ParametersArray[1] := new OdbcParameter('', OdbcType.VarChar, 96); // ParametersArray[1].Value := ASystemDefaultsDataTable.Rows[Counter].Item['s_default_value_c']; // ParametersArray[2] := new OdbcParameter('', OdbcType.VarChar, 32); // ParametersArray[2].Value := ASystemDefaultsDataTable.Rows[Counter].Item['s_default_code_c']; // // try // DBAccess.GDBAccessObj.ExecuteNonQuery( // 'UPDATE PUB_s_system_defaults ' + // 'SET s_default_description_c = ?, s_default_value_c = ? ' + // 'WHERE s_default_code_c = ?', Transaction, false, ParametersArray); // except // on exp: Exception do // begin // Result := false; // $IFDEF DEBUGMODE if TLogging.DL >= 9 then Console.WriteLine(this.GetType.FullName + '.SaveSystemDefaults: Error runing insert query!!! ' + // 'Possible cause: ' + exp.ToString); $ENDIF // Exit; // end; // end; // end; // end; // // DBAccess.GDBAccessObj.CommitTransaction; // Result := AllSubmissionsOK; // end // else // begin // nothing to save! // Result := false; // end; }
public static void GetData(string ATablename, TSearchCriteria[] ASearchCriteria, out TTypedDataTable AResultTable, TDBTransaction AReadTransaction) { AResultTable = null; string context = string.Format("GetData {0}", SharedConstants.MODULE_ACCESS_MANAGER); // check access permissions for the current user TModuleAccessManager.CheckUserPermissionsForTable(ATablename, TTablePermissionEnum.eCanRead); // TODO: auto generate if (ATablename == AApSupplierTable.GetTableDBName()) { AResultTable = AApSupplierAccess.LoadUsingTemplate(ASearchCriteria, AReadTransaction); } else if (ATablename == AApDocumentTable.GetTableDBName()) { AResultTable = AApDocumentAccess.LoadUsingTemplate(ASearchCriteria, AReadTransaction); } else if (ATablename == ATransactionTypeTable.GetTableDBName()) { AResultTable = ATransactionTypeAccess.LoadUsingTemplate(ASearchCriteria, AReadTransaction); } else if (ATablename == ACurrencyTable.GetTableDBName()) { AResultTable = ACurrencyAccess.LoadAll(AReadTransaction); } else if (ATablename == ADailyExchangeRateTable.GetTableDBName()) { AResultTable = ADailyExchangeRateAccess.LoadAll(AReadTransaction); } else if (ATablename == ACorporateExchangeRateTable.GetTableDBName()) { AResultTable = ACorporateExchangeRateAccess.LoadAll(AReadTransaction); } else if (ATablename == ACurrencyLanguageTable.GetTableDBName()) { AResultTable = ACurrencyLanguageAccess.LoadAll(AReadTransaction); } else if (ATablename == AFeesPayableTable.GetTableDBName()) { AResultTable = AFeesPayableAccess.LoadAll(AReadTransaction); } else if (ATablename == AFeesReceivableTable.GetTableDBName()) { AResultTable = AFeesReceivableAccess.LoadAll(AReadTransaction); } else if (ATablename == AAnalysisTypeTable.GetTableDBName()) { AResultTable = AAnalysisTypeAccess.LoadUsingTemplate(ASearchCriteria, AReadTransaction); } else if (ATablename == AGiftBatchTable.GetTableDBName()) { AResultTable = AGiftBatchAccess.LoadAll(AReadTransaction); } else if (ATablename == AJournalTable.GetTableDBName()) { AResultTable = AJournalAccess.LoadAll(AReadTransaction); } else if (ATablename == ALedgerTable.GetTableDBName()) { AResultTable = ALedgerAccess.LoadAll(AReadTransaction); } else if (ATablename == MExtractMasterTable.GetTableDBName()) { if (ASearchCriteria == null) { AResultTable = MExtractMasterAccess.LoadAll(AReadTransaction); } else { AResultTable = MExtractMasterAccess.LoadUsingTemplate(ASearchCriteria, AReadTransaction); } } else if (ATablename == MExtractTable.GetTableDBName()) { // it does not make sense to load ALL extract rows for all extract masters so search criteria needs to be set if (ASearchCriteria != null) { AResultTable = MExtractAccess.LoadUsingTemplate(ASearchCriteria, AReadTransaction); } } else if (ATablename == PcAttendeeTable.GetTableDBName()) { AResultTable = PcAttendeeAccess.LoadUsingTemplate(ASearchCriteria, AReadTransaction); } else if (ATablename == PcConferenceCostTable.GetTableDBName()) { AResultTable = PcConferenceCostAccess.LoadUsingTemplate(ASearchCriteria, AReadTransaction); } else if (ATablename == PcEarlyLateTable.GetTableDBName()) { AResultTable = PcEarlyLateAccess.LoadUsingTemplate(ASearchCriteria, AReadTransaction); } else if (ATablename == PcSupplementTable.GetTableDBName()) { AResultTable = PcSupplementAccess.LoadUsingTemplate(ASearchCriteria, AReadTransaction); } else if (ATablename == PcDiscountTable.GetTableDBName()) { AResultTable = PcDiscountAccess.LoadUsingTemplate(ASearchCriteria, AReadTransaction); } else if (ATablename == PCountryTable.GetTableDBName()) { AResultTable = PCountryAccess.LoadAll(AReadTransaction); } else if (ATablename == PFormTable.GetTableDBName()) { string[] columns = TTypedDataTable.GetColumnStringList(PFormTable.TableId); StringCollection fieldList = new StringCollection(); for (int i = 0; i < columns.Length; i++) { // Do not load the template document - we don't display it and it is big! if (columns[i] != PFormTable.GetTemplateDocumentDBName()) { fieldList.Add(columns[i]); } } AResultTable = PFormAccess.LoadAll(fieldList, AReadTransaction); } else if (ATablename == PInternationalPostalTypeTable.GetTableDBName()) { AResultTable = PInternationalPostalTypeAccess.LoadAll(AReadTransaction); } else if (ATablename == PtApplicationTypeTable.GetTableDBName()) { AResultTable = PtApplicationTypeAccess.LoadAll(AReadTransaction); } else if (ATablename == PFormalityTable.GetTableDBName()) { AResultTable = PFormalityAccess.LoadAll(AReadTransaction); } else if (ATablename == PMailingTable.GetTableDBName()) { AResultTable = PMailingAccess.LoadAll(AReadTransaction); } else if (ATablename == PPartnerGiftDestinationTable.GetTableDBName()) { AResultTable = PPartnerGiftDestinationAccess.LoadUsingTemplate(ASearchCriteria, AReadTransaction); } else if (ATablename == PmDocumentTypeTable.GetTableDBName()) { AResultTable = PmDocumentTypeAccess.LoadAll(AReadTransaction); } else if (ATablename == SGroupTable.GetTableDBName()) { TSecurityChecks.CheckUserModulePermissions(SharedConstants.PETRAMODULE_SYSADMIN, context); AResultTable = SGroupAccess.LoadAll(AReadTransaction); } else if (ATablename == SSystemDefaultsTable.GetTableDBName()) { TSecurityChecks.CheckUserModulePermissions(SharedConstants.PETRAMODULE_SYSADMIN, context); AResultTable = SSystemDefaultsAccess.LoadAll(AReadTransaction); } else if (ATablename == SSystemDefaultsGuiTable.GetTableDBName()) { AResultTable = SSystemDefaultsGuiAccess.LoadAll(AReadTransaction); } else { throw new Exception("TCommonDataReader.GetData: unknown table " + ATablename); } // Accept row changes here so that the Client gets 'unmodified' rows AResultTable.AcceptChanges(); }
public static TSubmitChangesResult SaveData(string ATablename, ref TTypedDataTable ASubmitTable, out TVerificationResultCollection AVerificationResult, TDBTransaction AWriteTransaction) { AVerificationResult = null; // TODO: check write permissions string context = string.Format("SaveData {0}", SharedConstants.MODULE_ACCESS_MANAGER); if (ASubmitTable != null) { AVerificationResult = new TVerificationResultCollection(); try { if (ATablename == AAccountingPeriodTable.GetTableDBName()) { AAccountingPeriodAccess.SubmitChanges((AAccountingPeriodTable)ASubmitTable, AWriteTransaction); TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing( TCacheableFinanceTablesEnum.AccountingPeriodList.ToString()); } else if (ATablename == ACurrencyTable.GetTableDBName()) { ACurrencyAccess.SubmitChanges((ACurrencyTable)ASubmitTable, AWriteTransaction); } else if (ATablename == ADailyExchangeRateTable.GetTableDBName()) { TSecurityChecks.CheckUserModulePermissions( string.Format("AND({0},{1})", SharedConstants.PETRAGROUP_FINANCE1, SharedConstants.PETRAMODULE_FINEXRATE), context); ADailyExchangeRateAccess.SubmitChanges((ADailyExchangeRateTable)ASubmitTable, AWriteTransaction); } else if (ATablename == ACorporateExchangeRateTable.GetTableDBName()) { // AlanP: I don't think this is used any more. There is a TDS Save method instead ACorporateExchangeRateAccess.SubmitChanges((ACorporateExchangeRateTable)ASubmitTable, AWriteTransaction); } else if (ATablename == ACurrencyLanguageTable.GetTableDBName()) { ACurrencyLanguageAccess.SubmitChanges((ACurrencyLanguageTable)ASubmitTable, AWriteTransaction); } else if (ATablename == AFeesPayableTable.GetTableDBName()) { AFeesPayableAccess.SubmitChanges((AFeesPayableTable)ASubmitTable, AWriteTransaction); TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing( TCacheableFinanceTablesEnum.FeesPayableList.ToString()); } else if (ATablename == AFeesReceivableTable.GetTableDBName()) { AFeesReceivableAccess.SubmitChanges((AFeesReceivableTable)ASubmitTable, AWriteTransaction); TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing( TCacheableFinanceTablesEnum.FeesReceivableList.ToString()); } else if (ATablename == AGiftBatchTable.GetTableDBName()) { // This method is called from ADailyExchangeRate Setup - please do not remove // The method is not required for changes made to the gift batch screens, which use a TDS AGiftBatchAccess.SubmitChanges((AGiftBatchTable)ASubmitTable, AWriteTransaction); } else if (ATablename == AJournalTable.GetTableDBName()) { // This method is called from ADailyExchangeRate Setup - please do not remove // The method is not required for changes made to the journal screens, which use a TDS AJournalAccess.SubmitChanges((AJournalTable)ASubmitTable, AWriteTransaction); } else if (ATablename == ARecurringJournalTable.GetTableDBName()) { // This method is called from Submit Recurring GL Batch form - please do not remove // The method is not required for changes made to the journal screens, which use a TDS ARecurringJournalAccess.SubmitChanges((ARecurringJournalTable)ASubmitTable, AWriteTransaction); } else if (ATablename == ALedgerTable.GetTableDBName()) { // This method is called from ADailyExchangeRate Testing - please do not remove ALedgerAccess.SubmitChanges((ALedgerTable)ASubmitTable, AWriteTransaction); } else if (ATablename == AAnalysisTypeTable.GetTableDBName()) { AAnalysisTypeAccess.SubmitChanges((AAnalysisTypeTable)ASubmitTable, AWriteTransaction); } else if (ATablename == ASuspenseAccountTable.GetTableDBName()) { ASuspenseAccountAccess.SubmitChanges((ASuspenseAccountTable)ASubmitTable, AWriteTransaction); TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing( TCacheableFinanceTablesEnum.SuspenseAccountList.ToString()); } else if (ATablename == PcAttendeeTable.GetTableDBName()) { PcAttendeeAccess.SubmitChanges((PcAttendeeTable)ASubmitTable, AWriteTransaction); } else if (ATablename == PcConferenceTable.GetTableDBName()) { PcConferenceAccess.SubmitChanges((PcConferenceTable)ASubmitTable, AWriteTransaction); } else if (ATablename == PcConferenceCostTable.GetTableDBName()) { PcConferenceCostAccess.SubmitChanges((PcConferenceCostTable)ASubmitTable, AWriteTransaction); } else if (ATablename == PcEarlyLateTable.GetTableDBName()) { PcEarlyLateAccess.SubmitChanges((PcEarlyLateTable)ASubmitTable, AWriteTransaction); } else if (ATablename == PcSupplementTable.GetTableDBName()) { PcSupplementAccess.SubmitChanges((PcSupplementTable)ASubmitTable, AWriteTransaction); } else if (ATablename == PcDiscountTable.GetTableDBName()) { PcDiscountAccess.SubmitChanges((PcDiscountTable)ASubmitTable, AWriteTransaction); } else if (ATablename == PInternationalPostalTypeTable.GetTableDBName()) { ValidateInternationalPostalType(ref AVerificationResult, ASubmitTable); ValidateInternationalPostalTypeManual(ref AVerificationResult, ASubmitTable); if (TVerificationHelper.IsNullOrOnlyNonCritical(AVerificationResult)) { PInternationalPostalTypeAccess.SubmitChanges((PInternationalPostalTypeTable)ASubmitTable, AWriteTransaction); } } else if (ATablename == PtApplicationTypeTable.GetTableDBName()) { PtApplicationTypeAccess.SubmitChanges((PtApplicationTypeTable)ASubmitTable, AWriteTransaction); // mark dependent lists for needing to be refreshed since there was a change in base list TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing( TCacheablePersonTablesEnum.EventApplicationTypeList.ToString()); TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing( TCacheablePersonTablesEnum.FieldApplicationTypeList.ToString()); } else if (ATablename == PFormTable.GetTableDBName()) { PFormAccess.SubmitChanges((PFormTable)ASubmitTable, AWriteTransaction); } else if (ATablename == PFormalityTable.GetTableDBName()) { PFormalityAccess.SubmitChanges((PFormalityTable)ASubmitTable, AWriteTransaction); } else if (ATablename == PMailingTable.GetTableDBName()) { PMailingAccess.SubmitChanges((PMailingTable)ASubmitTable, AWriteTransaction); } else if (ATablename == PPartnerGiftDestinationTable.GetTableDBName()) { PPartnerGiftDestinationAccess.SubmitChanges((PPartnerGiftDestinationTable)ASubmitTable, AWriteTransaction); } else if (ATablename == PmDocumentTypeTable.GetTableDBName()) { PmDocumentTypeAccess.SubmitChanges((PmDocumentTypeTable)ASubmitTable, AWriteTransaction); } else if (ATablename == SGroupTable.GetTableDBName()) { SGroupAccess.SubmitChanges((SGroupTable)ASubmitTable, AWriteTransaction); } else if (ATablename == SSystemDefaultsTable.GetTableDBName()) { SSystemDefaultsAccess.SubmitChanges((SSystemDefaultsTable)ASubmitTable, AWriteTransaction); } else if (ATablename == SSystemDefaultsGuiTable.GetTableDBName()) { SSystemDefaultsGuiAccess.SubmitChanges((SSystemDefaultsGuiTable)ASubmitTable, AWriteTransaction); } else { throw new EOPAppException("TCommonDataReader.SaveData: unknown table '" + ATablename + "'"); } } catch (Exception Exc) { AVerificationResult.Add( new TVerificationResult(null, "Cannot SubmitChanges:" + Environment.NewLine + Exc.Message, "UNDEFINED", TResultSeverity.Resv_Critical)); } } if ((AVerificationResult != null) && (AVerificationResult.Count > 0)) { // Downgrade TScreenVerificationResults to TVerificationResults in order to allow // Serialisation (needed for .NET Remoting). TVerificationResultCollection.DowngradeScreenVerificationResults(AVerificationResult); return(AVerificationResult.HasCriticalErrors ? TSubmitChangesResult.scrError : TSubmitChangesResult.scrOK); } return(TSubmitChangesResult.scrOK); }
/// <summary> /// Stores a System Default in the DB. If it was already there it gets updated, if it wasn't there it gets added. /// </summary> /// <remarks>The change gets reflected in the System Defaults Cache the next time the System Defaults Cache /// gets accessed.</remarks> /// <param name="AKey">Name of the System Default.</param> /// <param name="AValue">Value of the System Default.</param> /// <param name="AAdded">True if the System Default got added, false if it already existed.</param> /// <param name="ADataBase"></param> /// <remarks>SystemDefault Names are not case sensitive.</remarks> public void SetSystemDefault(String AKey, String AValue, out bool AAdded, TDataBase ADataBase = null) { TDataBase DBConnectionObj = null; TDBTransaction WriteTransaction = new TDBTransaction(); bool SubmissionOK = false; SSystemDefaultsTable SystemDefaultsDT; Boolean Added = false; try { // Open a separate DB Connection... DBConnectionObj = DBAccess.Connect("SetSystemDefault", ADataBase); // ...and start a DB Transaction on that separate DB Connection DBConnectionObj.WriteTransaction(ref WriteTransaction, ref SubmissionOK, delegate { SystemDefaultsDT = SSystemDefaultsAccess.LoadAll(WriteTransaction); // This will find the row that matches a case-insensitive search of the table primary keys SystemDefaultsDT.CaseSensitive = false; // It is anyway SSystemDefaultsRow match = (SSystemDefaultsRow)SystemDefaultsDT.Rows.Find(AKey); if (match != null) { // I already have this System Default in the DB --> simply update the Value in the DB. // (This will often be the case!) match.DefaultValue = AValue; Added = false; } else { // The System Default isn't in the DB yet --> store it in the DB. var SystemDefaultsDR = SystemDefaultsDT.NewRowTyped(true); SystemDefaultsDR.DefaultCode = AKey; SystemDefaultsDR.DefaultDescription = "Created in OpenPetra"; SystemDefaultsDR.DefaultValue = AValue; SystemDefaultsDT.Rows.Add(SystemDefaultsDR); Added = true; } SSystemDefaultsAccess.SubmitChanges(SystemDefaultsDT, WriteTransaction); SubmissionOK = true; }); AAdded = Added; } catch (Exception Exc) { TLogging.Log( "TSystemDefaultCache.SetSystemDefault: An Exception occured during the saving of the System Default '" + AKey + "'. Value to be saved: + '" + AValue + "'" + Environment.NewLine + Exc.ToString()); throw; } finally { if (ADataBase == null) { DBConnectionObj.CloseDBConnection(); } if (SubmissionOK && (FSystemDefaultsDT != null)) { // We need to ensure that the next time the System Defaults Caches gets accessed it is refreshed from the DB!!! FSystemDefaultsDT.Clear(); FSystemDefaultsDT = null; } } }
/// <summary> /// Determines the 'Last Reminder Date', that is the date when PartnerReminders last ran. /// <para> /// This is done by reading a certain SystemDefault. If PartnerReminders was never run before, /// this SystemDefault is created. /// </para> /// </summary> /// <param name="ALastReminderDate">Date when PartnerReminders last ran. Will be January 1st, 1980 /// if PartnerReminders never ran before.</param> /// <param name="ASystemDefaultsDR">SystemDefaults DataRow containing the date. This is used later for updating /// the date.</param> /// <param name="AReadWriteTransaction">Already instantiated DB Transaction.</param> /// <returns>True if the 'Last Reminder Date' could be read/created. False if PartnerReminders was never run before /// AND creation of the new SystemDefault record failed for some reason.</returns> private static bool GetLastReminderDate(out DateTime ALastReminderDate, out SSystemDefaultsRow ASystemDefaultsDR, TDBTransaction AReadWriteTransaction) { const string UNDEFINED_SYSTEMDEFAULT_LAST_REMINDER_DATE = "1980,1,1"; // Double check order! SSystemDefaultsTable SystemDefaultsDT = new SSystemDefaultsTable(); string LastReminderDateStr; string[] DateParts; bool ReturnValue = true; ASystemDefaultsDR = null; // Check if there is already a SystemDefault for the Last Reminder Date (most likely there is!) if (SSystemDefaultsAccess.Exists(SYSTEMDEFAULT_LAST_REMINDER_DATE, AReadWriteTransaction)) { if (TLogging.DebugLevel >= 6) { TLogging.Log("GetLastReminderDate: System Default for the Last Reminder Date exists: use it."); } // There is already a SystemDefault for the Last Reminder Date: read its value SystemDefaultsDT = SSystemDefaultsAccess.LoadByPrimaryKey(SYSTEMDEFAULT_LAST_REMINDER_DATE, AReadWriteTransaction); // Used later to update the row ASystemDefaultsDR = SystemDefaultsDT[0]; } else { // System Default for the Last Reminder Date doesn't exist: add a new SystemDefault for future use if (TLogging.DebugLevel >= 6) { TLogging.Log("GetLastReminderDate: System Default for the Last Reminder Date doesn't exist yet: creating it."); } ASystemDefaultsDR = SystemDefaultsDT.NewRowTyped(); ASystemDefaultsDR.DefaultCode = SYSTEMDEFAULT_LAST_REMINDER_DATE; ASystemDefaultsDR.DefaultDescription = SYSTEMDEFAULT_LAST_REMINDER_DATE_DESC; ASystemDefaultsDR.DefaultValue = UNDEFINED_SYSTEMDEFAULT_LAST_REMINDER_DATE; try { SSystemDefaultsAccess.SubmitChanges(SystemDefaultsDT, AReadWriteTransaction); } catch (Exception Exc) { TLogging.Log("TProcessPartnerReminders.GetLastReminderDate: An Exception occured:" + Environment.NewLine + Exc.ToString()); throw; } } LastReminderDateStr = ASystemDefaultsDR.DefaultValue; // Last Reminder Date is stored as YEAR,MONTH,DAY DateParts = LastReminderDateStr.Split(','); ALastReminderDate = new DateTime( Convert.ToInt32(DateParts[0]), Convert.ToInt32(DateParts[1]), Convert.ToInt32(DateParts[2]), 0, 0, 1); // One second past midnight if (TLogging.DebugLevel >= 6) { TLogging.Log(String.Format("GetLastReminderDate: DB Field value: {0}; Parsed date: {1}", LastReminderDateStr, ALastReminderDate)); } return(ReturnValue); }
/// <summary> /// Determines the 'Last Reminder Date', that is the date when PartnerReminders last ran. /// <para> /// This is done by reading a certain SystemDefault. If PartnerReminders was never run before, /// this SystemDefault is created. /// </para> /// </summary> /// <param name="ALastReminderDate">Date when PartnerReminders last ran. Will be January 1st, 1980 /// if PartnerReminders never ran before.</param> /// <param name="ASystemDefaultsDR">SystemDefaults DataRow containing the date. This is used later for updating /// the date.</param> /// <param name="AReadWriteTransaction">Already instantiated DB Transaction.</param> /// <returns>True if the 'Last Reminder Date' could be read/created. False if PartnerReminders was never run before /// AND creation of the new SystemDefault record failed for some reason.</returns> private static bool GetLastReminderDate(out DateTime ALastReminderDate, out SSystemDefaultsRow ASystemDefaultsDR, TDBTransaction AReadWriteTransaction) { const string UNDEFINED_SYSTEMDEFAULT_LAST_REMINDER_DATE = "1980,1,1"; // Double check order! SSystemDefaultsTable SystemDefaultsDT = new SSystemDefaultsTable(); string LastReminderDateStr; string[] DateParts; bool ReturnValue = true; ASystemDefaultsDR = null; // Check if there is already a SystemDefault for the Last Reminder Date (most likely there is!) if (SSystemDefaultsAccess.Exists(SYSTEMDEFAULT_LAST_REMINDER_DATE, AReadWriteTransaction)) { if (TLogging.DebugLevel >= 6) { TLogging.Log("GetLastReminderDate: System Default for the Last Reminder Date exists: use it."); } // There is already a SystemDefault for the Last Reminder Date: read its value SystemDefaultsDT = SSystemDefaultsAccess.LoadByPrimaryKey(SYSTEMDEFAULT_LAST_REMINDER_DATE, AReadWriteTransaction); // Used later to update the row ASystemDefaultsDR = SystemDefaultsDT[0]; } else { // System Default for the Last Reminder Date doesn't exist: add a new SystemDefault for future use if (TLogging.DebugLevel >= 6) { TLogging.Log("GetLastReminderDate: System Default for the Last Reminder Date doesn't exist yet: creating it."); } ASystemDefaultsDR = SystemDefaultsDT.NewRowTyped(); ASystemDefaultsDR.DefaultCode = SYSTEMDEFAULT_LAST_REMINDER_DATE; ASystemDefaultsDR.DefaultDescription = SYSTEMDEFAULT_LAST_REMINDER_DATE_DESC; ASystemDefaultsDR.DefaultValue = UNDEFINED_SYSTEMDEFAULT_LAST_REMINDER_DATE; try { SSystemDefaultsAccess.SubmitChanges(SystemDefaultsDT, AReadWriteTransaction); } catch (Exception Exc) { TLogging.Log("TProcessPartnerReminders.GetLastReminderDate: An Exception occured:" + Environment.NewLine + Exc.ToString()); throw; } } LastReminderDateStr = ASystemDefaultsDR.DefaultValue; // Last Reminder Date is stored as YEAR,MONTH,DAY DateParts = LastReminderDateStr.Split(','); ALastReminderDate = new DateTime( Convert.ToInt32(DateParts[0]), Convert.ToInt32(DateParts[1]), Convert.ToInt32(DateParts[2]), 0, 0, 1); // One second past midnight if (TLogging.DebugLevel >= 6) { TLogging.Log(String.Format("GetLastReminderDate: DB Field value: {0}; Parsed date: {1}", LastReminderDateStr, ALastReminderDate)); } return ReturnValue; }
/// <summary> /// Saves changes to the submitted Typed SystemDefaults DataTable to the DB. /// /// @comment Currently always returns false because the function needs to be /// rewritten! /// /// @todo Rewrite this function so that it saves entries that originally came /// from the s_system_parameter table in the DB to this table instead of /// writing them to the s_system_defaults table! Also use the DataStore to /// save the data instead of using SQL queries!!! /// /// </summary> /// <param name="ASystemDefaultsDataTable">Typed SystemDefaults DataTable</param> /// <returns>true if the System Defaults could be saved successfully /// </returns> public Boolean SaveSystemDefaults(SSystemDefaultsTable ASystemDefaultsDataTable) { // var // Transaction: OdbcTransaction; // ParametersArray: array of OdbcParameter; // Counter, // DefaultInDataBaseCount: Int16; // AllSubmissionsOK: Boolean; /* TODO 2 oChristanK cDB : Rewrite this function so that it saves entries that originally came from the s_system_parameter table * in the DB to this table instead of writing them to the s_system_defaults table! Also use the DataStore to * save the data instead of using SQL queries!!! */ // Currently always returns false because the function needs to be rewritten! return(false); // AllSubmissionsOK := false; // DefaultInDataBaseCount := 0; // // if (ASystemDefaultsDataTable <> nil) and (ASystemDefaultsDataTable.Rows.Count > 0) then // begin // $IFDEF DEBUGMODE if TLogging.DL >= 8 then Console.WriteLine('Saving ' + (ASystemDefaultsDataTable.Rows.Count).ToString + ' System Defaults...'); $ENDIF // // Transaction := DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.ReadCommitted); // // Loop over all changed/added System Defaults // for Counter := 0 to ASystemDefaultsDataTable.Rows.Count 1 do // begin // Look whether the System Default already exists in the DB // SetLength(ParametersArray, 1); // ParametersArray[0] := new OdbcParameter('', OdbcType.VarChar, 32); // ParametersArray[0].Value := ASystemDefaultsDataTable.Rows[Counter].Item['s_default_code_c'].ToString; // // try // DefaultInDataBaseCount := Convert.ToInt16( DBAccess.GDBAccessObj.ExecuteScalar( // 'SELECT COUNT) ' + // 'FROM PUB_s_system_defaults ' + // 'WHERE s_default_code_c = ?', Transaction, false, ParametersArray) ); // except // on exp: Exception do // begin // Result := false; // $IFDEF DEBUGMODE if TLogging.DL >= 9 then Console.WriteLine(this.GetType.FullName + '.SaveSystemDefaults: Error running count query!!! ' + // 'Possible cause: ' + exp.ToString); $ENDIF // Exit; // end; // end; // // if DefaultInDataBaseCount = 0 then // begin // System Default doesn't exist yet > create it /* $IFDEF DEBUGMODE if TLogging.DL >= 8 then Console.WriteLine('Inserting SystemDefault ' + ASystemDefaultsDataTable.Rows[Counter].Item['s_default_code_c'].ToString + '; Value: ' + * ASystemDefaultsDataTable.Rows[Counter].Item['s_default_value_c'].ToString);$ENDIF */ // SetLength(ParametersArray, 3); // ParametersArray[0] := new OdbcParameter('', OdbcType.VarChar, 32); // ParametersArray[0].Value := ASystemDefaultsDataTable.Rows[Counter].Item['s_default_code_c'].ToString; // ParametersArray[0] := new OdbcParameter('', OdbcType.VarChar, 48); // ParametersArray[0].Value := ASystemDefaultsDataTable.Rows[Counter].Item['s_default_description_c'].ToString; // ParametersArray[2] := new OdbcParameter('', OdbcType.VarChar, 96); // ParametersArray[2].Value := ASystemDefaultsDataTable.Rows[Counter].Item['s_default_value_c'].ToString; // // try // DBAccess.GDBAccessObj.ExecuteNonQuery( // 'INSERT INTO PUB_s_system_defaults ' + // '(s_default_code_c, s_default_description_c, s_default_value_c) ' + // 'VALUES (?, ?, ?)', Transaction, false, ParametersArray); // except // on exp: Exception do // begin // Result := false; // $IFDEF DEBUGMODE if TLogging.DL >= 9 then Console.WriteLine(this.GetType.FullName + '.SaveSystemDefaults: Error running insert query!!! ' + // 'Possible cause: ' + exp.ToString); $ENDIF // Exit; // end; // end; // end // else // begin // System Default exists > update it /* $IFDEF DEBUGMODE if TLogging.DL >= 8 then Console.WriteLine('Updating SystemDefault ' + ASystemDefaultsDataTable.Rows[Counter].Item['s_default_code_c'].ToString + '; Value: ' + * ASystemDefaultsDataTable.Rows[Counter].Item['s_default_value_c'].ToString);$ENDIF */ // SetLength(ParametersArray, 3); // ParametersArray[0] := new OdbcParameter('', OdbcType.VarChar, 48); // ParametersArray[0].Value := ASystemDefaultsDataTable.Rows[Counter].Item['s_default_description_c']; // ParametersArray[1] := new OdbcParameter('', OdbcType.VarChar, 96); // ParametersArray[1].Value := ASystemDefaultsDataTable.Rows[Counter].Item['s_default_value_c']; // ParametersArray[2] := new OdbcParameter('', OdbcType.VarChar, 32); // ParametersArray[2].Value := ASystemDefaultsDataTable.Rows[Counter].Item['s_default_code_c']; // // try // DBAccess.GDBAccessObj.ExecuteNonQuery( // 'UPDATE PUB_s_system_defaults ' + // 'SET s_default_description_c = ?, s_default_value_c = ? ' + // 'WHERE s_default_code_c = ?', Transaction, false, ParametersArray); // except // on exp: Exception do // begin // Result := false; // $IFDEF DEBUGMODE if TLogging.DL >= 9 then Console.WriteLine(this.GetType.FullName + '.SaveSystemDefaults: Error runing insert query!!! ' + // 'Possible cause: ' + exp.ToString); $ENDIF // Exit; // end; // end; // end; // end; // // DBAccess.GDBAccessObj.CommitTransaction; // Result := AllSubmissionsOK; // end // else // begin // nothing to save! // Result := false; // end; }