public async Task <int> UpdateAsync(bool fireOnAfterSaveData = true, bool validateData = false, TransactionObject transaction = null)
{
return(await Task.Run(() => this.Update(fireOnAfterSaveData, validateData, transaction)));
}
public int Update(bool fireOnAfterSaveData = true, bool validateData = false, TransactionObject transaction = null)
{
#if !PCL
var _table = TableDefinition.GetTableDefinition(typeof(T));
var _function = _table.DefaultDataFunction;
if (validateData)
{
if (!this.OnValidateData())
{
return(0);
}
}
var _ret = _function.Update(this, transaction);
ThrowException(_ret);
if (fireOnAfterSaveData)
{
this.OnAfterSaveData(new NotifyRecordChangesEventArgs(_ret.RecordsAffected, _ret.ChangeType, transaction));
}
return(_ret.RecordsAffected);
#else
return(0);
#endif
}
public async Task <int> InsertAsync(bool ignoreAutoIncrementField = true, bool fireOnAfterSaveData = true, bool validateData = false, TransactionObject transaction = null)
{
return(await Task.Run(() => this.Insert(ignoreAutoIncrementField, fireOnAfterSaveData, validateData, transaction)));
}
public int Insert(bool ignoreAutoIncrementField = true, bool fireOnAfterSaveData = true, bool validateData = false, TransactionObject transaction = null)
{
#if !PCL
var _table = TableDefinition.GetTableDefinition(typeof(T));
var _function = _table.DefaultDataFunction;
if (validateData)
{
if (!this.OnValidateData())
{
return(0);
}
}
var _ret = _function.Insert(this, ignoreAutoIncrementField, transaction);
ThrowException(_ret);
if (_ret.ReturnStatus == CrudStatus.Ok && _ret.ChangeType == SqlStatementsTypes.Insert)
{
this.SetSelfColumnsIds(_ret.ReturnData);
}
if (fireOnAfterSaveData)
{
this.OnAfterSaveData(new NotifyRecordChangesEventArgs(_ret.RecordsAffected, _ret.ChangeType, transaction));
}
return(_ret.RecordsAffected);
#else
return(-1);
#endif
}
public async Task <bool> SaveChangesAsync(bool ignoreAutoIncrementAttribute = true, FireEvent fireEvent = FireEvent.OnBeforeAndAfter, bool doNotUpdateWhenExists = false, bool validateData = false, TransactionObject transaction = null)
{
return(await Task.Run(() => this.SaveChanges(ignoreAutoIncrementAttribute, fireEvent, doNotUpdateWhenExists, validateData, transaction)));
}
/// <summary>
/// Save current changes on object
/// </summary>
/// <param name="ignoreAutoIncrementAttribute">if true, doesn't include autoincrement or backend calculated fields on insert statement. Defaults to true</param>
/// <param name="fireEvent">if true, fire the AfterSaveData event. Defaults to true</param>
/// <param name="doNotUpdateWhenExists">if true, doesn't fire the update statement when a register already exists in the database. Defaults to false</param>
/// <param name="validateData"></param>
/// <returns>true if object is saved on database, otherwise false</returns>
public bool SaveChanges(bool ignoreAutoIncrementAttribute = true, FireEvent fireEvent = FireEvent.OnBeforeAndAfter, bool doNotUpdateWhenExists = false, bool validateData = false, TransactionObject transaction = null)
{
#if !PCL
var _table = TableDefinition.GetTableDefinition(typeof(T));
var _function = _table.DefaultDataFunction;
if (validateData)
{
if (!this.OnValidateData())
{
return(false);
}
}
if (fireEvent == FireEvent.OnBeforeAndAfter || fireEvent == FireEvent.OnBeforeSave)
{
this.OnBeforeSaveData(new NotifyRecordChangesEventArgs(0, SqlStatementsTypes.UnknownStatement, transaction));
}
var _ret = _function.SaveChanges(this, ignoreAutoIncrementAttribute, doNotUpdateWhenExists, transaction);
ThrowException(_ret);
if (_ret.ReturnStatus == CrudStatus.Ok && _ret.ChangeType == SqlStatementsTypes.Insert)
{
this.SetSelfColumnsIds(_ret.ReturnData);
}
if (fireEvent == FireEvent.OnBeforeAndAfter || fireEvent == FireEvent.OnAfterSave)
{
this.OnAfterSaveData(new NotifyRecordChangesEventArgs(_ret.RecordsAffected, _ret.ChangeType, transaction));
}
return(_ret.ReturnStatus == CrudStatus.Ok);
#else
return(false);
#endif
}
public async Task <CrudReturn> DeleteAllAsync <TDatabaseObject>(DboCommand command, TransactionObject transaction = null)
{
return(await Task.Run(() => this.DeleteAll <TDatabaseObject>(command, transaction)));
}
public NotifyRecordChangesEventArgs(int recordsAffected, SqlStatementsTypes changeType, TransactionObject transaction)
{
ChangeType = changeType;
Transaction = transaction;
RecordsAffected = recordsAffected;
}
public CrudReturn Insert <TDatabaseObject>(TDatabaseObject objectToInsert, bool ignoreAutoIncrementField = true, TransactionObject transaction = null) where TDatabaseObject : IDatabaseObject
{
var _table = TableDefinition.GetTableDefinition(typeof(TDatabaseObject));
var _ret = new CrudReturn
{
ReturnStatus = CrudStatus.Ok,
RecordsAffected = -1,
ChangeType = SqlStatementsTypes.Insert,
ReturnMessage = "Dados atualizados com sucesso!"
};
var _transaction = transaction ?? new TransactionObject(true);
try
{
if (_transaction.Connection == null)
{
_transaction.SetConnection(_table.DefaultDataFunction.Connection);
}
var _sql = "";
var _data = objectToInsert.ToDictionary();
var _backEndField = _table.Fields.Select(f => f.Value).FirstOrDefault(f => f.AutomaticValue != AutomaticValue.None);
if (_backEndField != null)
{
_sql = _table.GetSqlInsert(ignoreAutoIncrementField);
int _lastId = this.DoInsert(_table, _transaction.Connection, _sql, _data);
objectToInsert.SetObjectFieldValue(_backEndField.Name, _lastId);
_ret.RecordsAffected = 1;
}
else
{
objectToInsert.SetIdFields();
_sql = _table.GetSqlInsert(ignoreAutoIncrementField);
_ret.RecordsAffected = _transaction.Connection.Execute(_sql, _data);
}
_ret.ReturnData = objectToInsert;
if (_transaction.AutoCommit)
{
_transaction.Commit();
_transaction.Dispose();
}
}
catch (Exception ex)
{
_ret.ReturnMessage = string.Format("{0}\r\n{1}", ex.Message, ex.StackTrace);
_ret.ReturnStatus = CrudStatus.Fail;
}
return(_ret);
}
public async Task <CrudReturn> DeleteAsync <TDatabaseObject>(TDatabaseObject objectToDelete, TransactionObject transaction = null) where TDatabaseObject : IDatabaseObject
{
return(await Task.Run(() => this.Delete <TDatabaseObject>(objectToDelete, transaction)));
}
public async Task <CrudReturn> InsertAsync <TDatabaseObject>(TDatabaseObject objectToInsert, bool ignoreAutoIncrementField = true, TransactionObject transaction = null) where TDatabaseObject : IDatabaseObject
{
return(await Task.Run(() => this.Insert(objectToInsert, ignoreAutoIncrementField, transaction)));
}
public async Task <CrudReturn> SaveChangesAsync <TDatabaseObject>(TDatabaseObject objectToSave, bool ignoreAutoIncrementField = true, bool doNotUpdateWhenExists = false, TransactionObject transaction = null) where TDatabaseObject : IDatabaseObject
{
return(await Task.Run(() => this.SaveChanges <TDatabaseObject>(objectToSave, ignoreAutoIncrementField, doNotUpdateWhenExists, transaction)));
}
public static async Task <int> DeleteAllAsync(Expression <Func <T, bool> > predicate = null, TransactionObject transaction = null)
{
return(await Task.Run(() => DeleteAll(predicate, transaction)));
}
public bool Delete(bool fireBeforeDeleteDataEvent = true, bool fireAfterDeleteDataEvent = true, TransactionObject transaction = null)
{
#if !PCL
var _table = TableDefinition.GetTableDefinition(typeof(T));
var _function = _table.DefaultDataFunction;
if (fireBeforeDeleteDataEvent)
{
this.OnBeforeDeleteData(new NotifyRecordChangesEventArgs(0, SqlStatementsTypes.Delete, transaction));
}
var _ret = _function.Delete(this, transaction);
ThrowException(_ret);
if (fireAfterDeleteDataEvent)
{
this.OnAfterDeleteData(new NotifyRecordChangesEventArgs(_ret.RecordsAffected, _ret.ChangeType, transaction));
}
return(_ret.RecordsAffected > 0);
#else
return(true);
#endif
}
public async Task <bool> DeleteAsync(bool fireBeforeDeleteDataEvent = true, bool fireAfterDeleteDataEvent = true, TransactionObject transaction = null)
{
return(await Task.Run(() => this.Delete(fireBeforeDeleteDataEvent, fireAfterDeleteDataEvent, transaction)));
}
