private void SaveObject()
{
DatabaseError e = obj.Insert();
if (e != DatabaseError.NoError)
{
CRichMsgBox.Show("An error has occured while saving the object to the database. See below for more details.",
"Error", e.ToDescriptionString(), MessageBoxButtons.OK, Resources.error_64x64);
return;
}
StatusUpdate?.Invoke(this, new StatusArgs($"{entity} {obj} created successfully."));
CheckForAssociation();
if (CMessageBox.Show("Create another?", "", MessageBoxButtons.YesNo, Resources.info_64x64) == DialogResult.Yes)
{
Clear();
}
else
{
if (RuntimeVars.Instance.MainForm.DockingWorkspace.DockingManager.FindDockingFloating("Floating")
.DockingManager.ContainsPage(RuntimeVars.Instance.SelectedPageUniqueName))
{
RuntimeVars.Instance.MainForm.DockingWorkspace.DockingManager.FindDockingFloating("Floating")
.DockingManager.RemovePage(RuntimeVars.Instance.SelectedPageUniqueName, true);
}
else
{
RuntimeVars.Instance.MainForm.DockingWorkspace.RemovePage(RuntimeVars.Instance.SelectedPageUniqueName, true);
}
}
}
public void OnCancelled(DatabaseError error)
{
Raised?.Invoke(this, new FirebaseEventArgs()
{
error = error
});
}
public DatabaseError ReadRecord(IDBCollection record)
{
m_ErrorCode = DatabaseError.NoError;
SQLiteCommand sqlite_cmd = (SQLiteCommand)m_conn.CreateCommand();
sqlite_cmd.CommandText = record.GetDBQuery();
try
{
SQLiteDataReader sqlite_datareader = sqlite_cmd.ExecuteReader();
if (sqlite_datareader.Read())
{
record.FillRecords(sqlite_datareader);
}
else
{
m_ErrorCode = DatabaseError.NoRecordsFound;
}
}
catch (System.Data.SQLite.SQLiteException e)
{
string msg = e.Message;
m_ErrorCode = DatabaseError.ExceptionSQL;
}
return(m_ErrorCode);
}
// TEST CODE FUNCTIONS...................
public DatabaseError TestRead(string sql)
{
m_ErrorCode = DatabaseError.NoError;
SQLiteCommand sqlite_cmd = (SQLiteCommand)m_conn.CreateCommand();
sqlite_cmd.CommandText = sql;
try
{
SQLiteDataReader sqlite_datareader = sqlite_cmd.ExecuteReader();
if (sqlite_datareader.Read())
{
do
{
for (int i = 0; i < sqlite_datareader.FieldCount; ++i)
{
string field = sqlite_datareader.GetName(i);
string value = sqlite_datareader.GetValue(i).ToString();
Console.WriteLine(field + " ==> " + value);
}
} while (sqlite_datareader.Read());
}
else
{
m_ErrorCode = DatabaseError.NoRecordsFound;
}
}
catch (System.Data.SQLite.SQLiteException e)
{
string msg = e.Message;
m_ErrorCode = DatabaseError.ExceptionSQL;
}
return(m_ErrorCode);
}
public void OnComplete(DatabaseError error, DatabaseReference @ref)
{
Raised?.Invoke(this, new FirebaseEventArgs()
{
error = error, @ref = @ref
});
}
public void OnComplete(DatabaseError error, bool committed, DataSnapshot currentData)
{
onCompletion?.OnComplete(error == null);
if (error != null)
{
onCompletion?.OnError(new FirebaseException(error));
}
}
public static string ToDescriptionString(this DatabaseError val)
{
DescriptionAttribute[] attributes = (DescriptionAttribute[])val
.GetType()
.GetField(val.ToString())
.GetCustomAttributes(typeof(DescriptionAttribute), false);
return(attributes.Length > 0 ? attributes[0].Description : string.Empty);
}
/// <summary>
/// Delete this survey from the database, along with the associated files and billing line items.
/// </summary>
/// <returns>A <see cref="DatabaseError"/> with the result of the Delete operation.</returns>
public DatabaseError Delete()
{
DatabaseError e = DeleteObjects();
if (e != DatabaseError.NoError)
{
return(e);
}
return(Database.DeleteSurvey(this) ? DatabaseError.NoError : DatabaseError.SurveyDelete);
}
void DatabaseReference.ICompletionListener.OnComplete(DatabaseError error, DatabaseReference @ref)
{
if (error == null)
{
saveTask.TrySetResult(true);
}
else
{
saveTask.TrySetResult(false);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="lastInsertId"></param>
/// <param name="rowsAffected"></param>
public MySQLResponse(long lastInsertId, long rowsAffected, int fieldCount, DatabaseError err = null)
{
_lastInsertId = lastInsertId;
_rowsAffected = rowsAffected;
_fieldCount = fieldCount;
_error = err;
if (err != null)
{
_success = false;
}
}
public void OnCancelled_StateUnderTest_ExpectedBehavior()
{
// Arrange
var unitUnderTest = this.CreateMessagingActivity();
DatabaseError error = TODO;
// Act
unitUnderTest.OnCancelled(
error);
// Assert
Assert.Fail();
}
private static bool VerifyDatabase()
{
if (database == null)
{
return(false);
}
if (database.Version != SneezeDatabase.currentVersionNumber)
{
NetworkComms.CloseAllConnections();
database = null;
DatabaseError?.Invoke(DatabaseErrorType.VersionNumberConflict);
return(false);
}
return(true);
}
private void HandledProgressSaved(BasicResult result)
{
if (result.Success)
{
if (ProgressSaved != null)
{
ProgressSaved.Invoke();
}
}
else
{
if (DatabaseError != null)
{
DatabaseError.Invoke(result.Exception);
}
}
}
public DatabaseError ExecuteCommand(string sql)
{
m_ErrorCode = DatabaseError.NoError;
SQLiteCommand sqlite_cmd = (SQLiteCommand)m_conn.CreateCommand();
try
{
sqlite_cmd.CommandText = sql;
sqlite_cmd.ExecuteNonQuery();
}
catch (System.Data.SQLite.SQLiteException e)
{
string msg = e.Message;
m_ErrorCode = DatabaseError.ExceptionSQL;
}
return(m_ErrorCode);
}
public DatabaseError UpdateRecord(IDBRecord record)
{
m_ErrorCode = DatabaseError.NoError;
SQLiteCommand sqlite_cmd = (SQLiteCommand)m_conn.CreateCommand();
try
{
sqlite_cmd.CommandText = record.GetDBUpdate();
sqlite_cmd.ExecuteNonQuery();
}
catch (System.Data.SQLite.SQLiteException e)
{
string msg = e.Message;
m_ErrorCode = DatabaseError.ExceptionSQL;
}
return(m_ErrorCode);
}
private void HandledProgressLoaded(LoadProgressResult result)
{
if (result.Success)
{
if (ProgressLoaded != null)
{
ProgressLoaded.Invoke(result.WorkbenchState);
}
DoDiscoveredElementsChanged();
}
else
{
if (DatabaseError != null)
{
DatabaseError.Invoke(result.Exception);
}
}
}
private void HandledDatabaseLoaded(BasicResult result)
{
if (result.Success)
{
if (DatabaseLoaded != null)
{
DatabaseLoaded.Invoke();
}
DoDiscoveredElementsChanged();
}
else
{
if (DatabaseError != null)
{
DatabaseError.Invoke(result.Exception);
}
}
}
public DatabaseError InsertRecord(IDBRecord record)
{
m_ErrorCode = DatabaseError.NoError;
SQLiteCommand sqlite_cmd = (SQLiteCommand)m_conn.CreateCommand();
try
{
sqlite_cmd.CommandText = record.GetDBInsert();
sqlite_cmd.ExecuteNonQuery();
sqlite_cmd.CommandText = "SELECT last_insert_rowid();";
record.SetValueString(record.GetIDQueryValue(), sqlite_cmd.ExecuteScalar());
}
catch (System.Data.SQLite.SQLiteException e)
{
string msg = e.Message;
m_ErrorCode = DatabaseError.ExceptionSQL;
}
return(m_ErrorCode);
}
private void SaveBackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
if (CurrentJob.ID == 0)
{
saveError = CurrentJob.Insert();
}
else
{
saveError = CurrentJob.Update();
}
if (saveError == DatabaseError.NoError)
{
_jobState = JobState.Saved;
}
else
{
_jobState = JobState.SaveError;
}
}
// collection indexes will not be updated with this call
public DatabaseError InsertRecord(IDBCollectionContents contents)
{
m_ErrorCode = DatabaseError.NoError;
SQLiteCommand sqlite_cmd = (SQLiteCommand)m_conn.CreateCommand();
for (int i = 0; i < contents.Count(); ++i)
{
try
{
sqlite_cmd.CommandText = contents.GetRecordInterface(i).GetDBInsert();
sqlite_cmd.ExecuteNonQuery();
}
catch (System.Data.SQLite.SQLiteException e)
{
m_ErrorCode = DatabaseError.ExceptionSQL;
Logger.ReportError(sqlite_cmd.CommandText);
Logger.ReportError(e.Message);
}
}
return(m_ErrorCode);
}
public override Exception TranslateException(Exception err)
{
err = base.TranslateException(err);
var ex = err as SqlException;
if (ex != null)
{
DatabaseError res = new DatabaseError(err);
foreach (SqlError e in ex.Errors)
{
res.Items.Add(new DatabaseErrorItem
{
ErrorCode = e.Number,
LineNumber = e.LineNumber - 1,
Message = e.Message,
Procedure = e.Procedure,
});
}
return(res);
}
return(err);
}
public DatabaseError ExecuteCommandWithResult(string sql, ref SQLiteDataReader reader)
{
m_ErrorCode = DatabaseError.NoError;
SQLiteCommand sqlite_cmd = (SQLiteCommand)m_conn.CreateCommand();
sqlite_cmd.CommandText = sql;
try
{
reader = sqlite_cmd.ExecuteReader();
if (!reader.Read())
{
m_ErrorCode = DatabaseError.NoRecordsFound;
reader = null;
}
}
catch (System.Data.SQLite.SQLiteException e)
{
string msg = e.Message;
m_ErrorCode = DatabaseError.ExceptionSQL;
}
return(m_ErrorCode);
}
/// <summary>
/// Handles insertion of this survey and any files associated with it.
/// </summary>
/// <returns>A <see cref="DatabaseError"/> with the result of the Insert operation.</returns>
public DatabaseError Insert()
{
if (IsValidSurvey)
{
DatabaseError e = UpdateObjects();
if (e != DatabaseError.NoError)
{
return(e);
}
if (ID == 0)
{
ID = Database.InsertSurvey(this);
e = ID != 0 ? DatabaseError.NoError : DatabaseError.SurveyInsert;
}
else
{
e = Database.UpdateSurvey(this) ? DatabaseError.NoError : DatabaseError.SurveyUpdate;
}
return(e);
}
return(DatabaseError.SurveyIncomplete);
}
private DatabaseError CheckVersion()
{
VersionCollection ver = new VersionCollection();
IDBCollection icol = ver as IDBCollection;
icol.SetConstraint((long)Version.QueryValues.TableName,
new DBConstraint(DBConstraint.QueryConstraints.Equal, "Version"));
DatabaseError err = ReadRecord(icol);
if (DatabaseError.NoRecordsFound == err || DatabaseError.ExceptionSQL == err)
{
return(m_ErrorCode = DatabaseError.CheckFailed_Unidentifiable);
}
IDBCollectionContents icolcon = ver as IDBCollectionContents;
VersionObject vobj = icolcon.GetRecordInterface(0).GetDataObject() as VersionObject;
if (vobj.VersionNumber != Version.VersionNumber)
{
return(m_ErrorCode = DatabaseError.CheckFailed_IncorrectVersion);
}
return(m_ErrorCode = DatabaseError.NoError);
}
public void OnCancelled(DatabaseError error)
{
}
public void OnCancelled(DatabaseError error)
{
//TODO: maybe log error here?
}
public void OnCancelled(DatabaseError error)
{
System.Diagnostics.Debug.WriteLine("Workspace Database Eroor: " + error.Message);
}
public void OnCancelled(DatabaseError error)
{
_onCancelled?.Invoke(error);
}
public void OnCancelled(DatabaseError error)
{
throw new NotImplementedException();
}
public void OnCancelled(DatabaseError error)
{
//"Failed To Get User Information For User "
}