public void ChangeTracker_IsChanged_When_Monitored_Object_Property_Is_Changed()
{
var simple = new SimpleObject{Name="Original"};
var changeTracker = new ChangeTracker { simple };
simple.Name = "New";
changeTracker.ShouldHave().Properties(c=>c.IsChanged).EqualTo(new {IsChanged=true});
}
public void Object_Is_Tracked_When_Added_To_ChangeTracker()
{
var simple = new SimpleObject();
var changeTracker = new ChangeTracker { simple };
var tracked = changeTracker.GetTracked();
tracked.Should().Equal(simple);
}
public void Entry_methods_delegate_to_underlying_state_manager()
{
var entity = new Random();
var stateManagerMock = new Mock<StateManager>();
var stateEntry = new Mock<StateEntry>().Object;
stateManagerMock.Setup(m => m.GetOrCreateEntry(entity)).Returns(stateEntry);
var changeTracker = new ChangeTracker(stateManagerMock.Object, Mock.Of<ChangeDetector>());
Assert.Same(stateEntry, changeTracker.Entry(entity).StateEntry);
Assert.Same(stateEntry, changeTracker.Entry((object)entity).StateEntry);
}
/// <summary>
/// Construct new ObjectContext with an opened connection.
/// </summary>
/// <param name="connectionString">Connection string for creating EntityConnection</param>
public MembersContainerImpl(string connectionString)
: base(new EntityConnection(connectionString))
{
try
{
base.Connection.Open();
}
catch (SQLiteException sqle)
{
throw new ArgumentException(sqle.Message);
}
_changeTracker = new ChangeTracker(this);
}
public static IChangeTrackerResponseLogic CreateLogic(ChangeTracker tracker)
{
switch (tracker.Mode) {
case ChangeTrackerMode.OneShot:
case ChangeTrackerMode.LongPoll:
return new OneShotOrLongPollLogic();
#if false
case ChangeTrackerMode.Continuous:
return new ContinuousLogic();
#endif
case ChangeTrackerMode.WebSocket:
return new WebSocketLogic();
default:
throw new NotSupportedException();
}
}
public void Members_check_arguments()
{
Assert.Equal(
"stateManager",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws<ArgumentNullException>(() => new ChangeTracker(null, null)).ParamName);
var changeTracker = new ChangeTracker(Mock.Of<StateManager>(), Mock.Of<ChangeDetector>());
Assert.Equal(
"entity",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws<ArgumentNullException>(() => changeTracker.Entry(null)).ParamName);
Assert.Equal(
"entity",
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws<ArgumentNullException>(() => changeTracker.Entry<Random>(null)).ParamName);
}
private void Create(params string[] lines)
{
_textBuffer = CreateTextBuffer(lines);
_textView = MockObjectFactory.CreateTextView(_textBuffer);
_textView.SetupGet(x => x.HasAggregateFocus).Returns(true);
// Setup normal mode so that we can provide an ICommandRunner to
// recieve commands from
_factory = new MockRepository(MockBehavior.Loose) {DefaultValue = DefaultValue.Mock};
_runner = _factory.Create<ICommandRunner>(MockBehavior.Loose);
_normalMode = _factory.Create<INormalMode>(MockBehavior.Strict);
_normalMode.SetupGet(x => x.CommandRunner).Returns(_runner.Object);
// Create the IVimBuffer instance
_buffer = _factory.Create<IVimBuffer>(MockBehavior.Loose);
_buffer.DefaultValue = DefaultValue.Mock;
_buffer.SetupGet(x => x.NormalMode).Returns(_normalMode.Object);
_vimData = VimUtil.CreateVimData();
var vim = MockObjectFactory.CreateVim(vimData: _vimData);
_tracker = new ChangeTracker(vim.Object);
_tracker.OnVimBufferCreated(_buffer.Object);
}
public override int SaveChanges()
{
//Checks whether the InsertedAt column exists
foreach (var entry in ChangeTracker.Entries().Where(entry => entry.Entity.GetType().GetProperty("InsertedAt") != null))
{
//When adding
if (entry.State == EntityState.Added)
{
//Enter the value of with the current date and time
entry.Property("InsertedAt").CurrentValue = DateTime.Now;
}
//When modifying
if (entry.State == EntityState.Modified)
{
//Do not change the value contained in the InsertedAt column
entry.Property("InsertedAt").IsModified = false;
}
}
//Checks whether the UpdatedAt column exists
foreach (var entry in ChangeTracker.Entries().Where(entry => entry.Entity.GetType().GetProperty("UpdatedAt") != null))
{
//When adding
if (entry.State == EntityState.Modified)
{
//Enter the value of with the current date and time
entry.Property("UpdatedAt").CurrentValue = DateTime.Now;
}
//When modifying
if (entry.State == EntityState.Added)
{
//Do not change the value contained in the UpdatedAt column
entry.Property("UpdatedAt").IsModified = false;
}
}
return(base.SaveChanges());
}
public override int SaveChanges()
{
var entries = ChangeTracker
.Entries()
.Where(e => (e.State == EntityState.Added || e.State == EntityState.Modified));
foreach (var entityEntry in entries)
{
var b = entityEntry.Entity as EntityBase;
if (b == null)
{
continue;
}
b.UpdatedAt = DateTime.UtcNow;
if (entityEntry.State == EntityState.Added)
{
b.CreatedAt = DateTime.UtcNow;
}
}
return(base.SaveChanges());
}
private void AddTimestamps()
{
var entities = ChangeTracker.Entries().Where(x => x.Entity is Base && (x.State == EntityState.Added || x.State == EntityState.Modified));
var currentUsername = !string.IsNullOrEmpty(_httpContextAccessor?.HttpContext?.User?.Identity?.Name)
? _httpContextAccessor.HttpContext.User.Identity.Name
: "Anonymous";
foreach (var entity in entities)
{
if (entity.State == EntityState.Added)
{
((Base)entity.Entity).createdAt = DateTime.Now.AddHours(-12);
((Base)entity.Entity).createdBy = currentUsername;
}
else
{
entity.Property("createdAt").IsModified = false;
entity.Property("createdBy").IsModified = false;
((Base)entity.Entity).updatedAt = DateTime.Now.AddHours(-12);
((Base)entity.Entity).updatedBy = currentUsername;
}
}
}
/// <summary>
/// Required function to set the fields CreatedAt and ModifiedAt on all functions, that doesn't use the .asNoTracked() (readOnly) chaining on Queries.
/// </summary>
private void OnBeforeSaving()
{
var entries = ChangeTracker.Entries();
foreach (var entry in entries)
{
var now = DateTime.UtcNow;
if (entry.Entity is IEntity entity)
{
switch (entry.State)
{
case EntityState.Modified:
entity.ModifiedAt = now;
break;
case EntityState.Added:
entity.CreatedAt = now;
entity.ModifiedAt = now;
break;
}
}
}
}
public override int SaveChanges()
{
IEnumerable <DbEntityEntry> Entities = ChangeTracker.Entries().Where(x => x.Entity is LsEntity && (x.State == EntityState.Added || x.State == EntityState.Modified));
foreach (var Entity in Entities)
{
if (Entity.State == EntityState.Added)
{
((LsEntity)Entity.Entity).DateCreated = DateTimeOffset.Now;
((LsEntity)Entity.Entity).UserCreated = _currentUsername;
Entity.Property("DateModified").IsModified = false;
Entity.Property("UserModified").IsModified = false;
}
else
{
Entity.Property("DateCreated").IsModified = false;
Entity.Property("UserCreated").IsModified = false;
((LsEntity)Entity.Entity).DateModified = DateTimeOffset.Now;
((LsEntity)Entity.Entity).UserModified = _currentUsername;
}
}
return(base.SaveChanges());
}
public void FilterTournamentsTest()
{
TestLineSr LineSr = new TestLineSr();
Kernel.Rebind <ILineSr>().ToConstant <ILineSr>(LineSr);
ChangeTracker.Setup(x => x.SelectedSportFilter).Returns(new ComboBoxItemStringId("1", "0"));
TopTournamentsViewModel model = new TopTournamentsViewModel();
var match = TestMatchLn.CreateMatch(1, false, true);
var value = model.MatchFilter(match);
Assert.IsTrue(value);
model = new TopTournamentsViewModel();
match = TestMatchLn.CreateMatch(1, true, true);
value = model.MatchFilter(match);
Assert.IsFalse(value);
}
public override int SaveChanges()
{
foreach (IModificationHistory history in ChangeTracker.Entries()
.Where(e => e.Entity is IModificationHistory && (e.State == EntityState.Added ||
e.State == EntityState.Modified))
.Select(e => e.Entity as IModificationHistory)
)
{
history.DateModified = DateTime.Now;
if (history.DateCreated == DateTime.MinValue)
{
history.DateCreated = DateTime.Now;
}
}
int result = base.SaveChanges();
foreach (IModificationHistory history in ChangeTracker.Entries()
.Where(e => e.Entity is IModificationHistory)
.Select(e => e.Entity as IModificationHistory))
{
history.IsDirty = false;
}
return(result);
}
IEnumerable <EntityChange <TEntity> > IEntityChangesProvider.GetEntityChanges <TEntity>()
{
var entries = ChangeTracker.Entries <TEntity>();
var changes = new List <EntityChange <TEntity> >();
foreach (var entry in entries)
{
EntityChangeState state;
switch (entry.State)
{
case EntityState.Added:
state = EntityChangeState.Added;
break;
case EntityState.Deleted:
state = EntityChangeState.Deleted;
break;
case EntityState.Modified:
state = EntityChangeState.Modified;
break;
default:
continue;
}
changes.Add(new EntityChange <TEntity>
{
Entity = entry.Entity,
State = state,
ModifiedProperties = state == EntityChangeState.Modified ? GetEntityModifiedPropertiesGenerator(entry).ToArray() : null
});
}
return(changes.AsReadOnly());
}
/// <summary>
/// set the dates in entities
/// </summary>
private void OnBeforeSaving()
{
//select only entities which inherit from BaseEntity
foreach (var entity in ChangeTracker.Entries <SoftDeleteEntity>())
{
switch (entity.State)
{
case EntityState.Added:
entity.Entity.Created = DateTime.UtcNow;
break;
case EntityState.Modified:
entity.Entity.Modified = DateTime.UtcNow;
break;
case EntityState.Deleted:
entity.Entity.Deleted = DateTime.UtcNow;
break;
default:
break;
}
}
}
public override int SaveChanges()
{
ChangeTracker.DetectChanges();
ObjectContext ctx = ((IObjectContextAdapter)this).ObjectContext;
foreach (var entity in ctx.ObjectStateManager.GetObjectStateEntries(EntityState.Modified))
{
BaseModel baseObject = entity.Entity as BaseModel;
if (baseObject == null)
{
continue;
}
baseObject.UpdatedDate = Now;
baseObject.UpdatedUser = UserName;
}
foreach (var entity in ctx.ObjectStateManager.GetObjectStateEntries(EntityState.Added))
{
BaseModel baseObject = entity.Entity as BaseModel;
if (baseObject == null)
{
continue;
}
baseObject.CreatedDate = Now;
baseObject.UpdatedDate = Now;
baseObject.CreatedUser = UserName;
baseObject.UpdatedUser = UserName;
}
return(base.SaveChanges());
}
private void OnBeforeSaving()
{
var entries = ChangeTracker.Entries();
var now = DateTime.Now;
foreach (var entry in entries
.Where(entry =>
entry.Entity.GetType().GetProperty("DateCreated") != null &&
entry.Entity.GetType().GetProperty("DateUpdated") != null
))
{
switch (entry.State)
{
case EntityState.Modified:
entry.Property("DateUpdated").CurrentValue = now;
break;
case EntityState.Added:
entry.Property("DateCreated").CurrentValue = now;
break;
}
}
}
private void AddTimestamps()
{
var entities = ChangeTracker.Entries()
.Where( x => x.Entity is BaseEntity && ( x.State == EntityState.Added || x.State == EntityState.Modified || x.State == EntityState.Deleted ) );
foreach (var entity in entities)
{
var now = DateTime.UtcNow; // current datetime
if (entity.State == EntityState.Added)
{
( ( BaseEntity ) entity.Entity ).CreatedAt = now;
//Por defecto todas nuestras entidades se crean con status true
( ( BaseEntity ) entity.Entity ).Status = true;
}
if (entity.State == EntityState.Deleted)
{
( ( BaseEntity ) entity.Entity ).DeletedAt = now;
}
( ( BaseEntity ) entity.Entity ).UpdatedAt = now;
}
}
private HookTrackingResult GetChangeTracking()
{
if (_func == null)
{
return(null);
}
var result = new HookTrackingResult();
result.Context = this;
var entities = ChangeTracker.Entries();
foreach (var entity in entities)
{
switch (entity.State)
{
case EntityState.Added:
result.EntriesAdded.Add(entity);
break;
case EntityState.Deleted:
result.EntriesDeleted.Add(entity);
break;
case EntityState.Modified:
result.EntriesModified.Add(entity);
break;
case EntityState.Detached:
case EntityState.Unchanged:
default:
break;
}
}
return(result);
}
private void OnBeforeSaving()
{
var entries = ChangeTracker.Entries();
foreach (var entry in entries)
{
if (entry.Entity is Booking booking)
{
var now = DateTime.UtcNow;
switch (entry.State)
{
case EntityState.Modified:
entry.CurrentValues["LastUpdatedAt"] = now;
break;
case EntityState.Added:
entry.CurrentValues["CreatedAt"] = now;
entry.CurrentValues["LastUpdatedAt"] = now;
break;
}
}
}
}
private void OnBeforeSaving()
{
var entries = ChangeTracker.Entries();
foreach (var entry in entries)
{
if (entry.Entity is BaseModel trackable)
{
var now = DateTime.Now;
switch (entry.State)
{
case EntityState.Modified:
trackable.UpdatedAt = now;
break;
case EntityState.Added:
trackable.Id = Guid.NewGuid();
trackable.CreatedAt = now;
trackable.UpdatedAt = now;
break;
}
}
}
}
private void FillBaseFields()
{
foreach (var entry in ChangeTracker.Entries())
{
switch (entry.State)
{
case EntityState.Added:
entry.CurrentValues[BaseProperties.IsDeleted] = false;
entry.CurrentValues[BaseProperties.Guid] = (Guid)entry.CurrentValues[BaseProperties.Guid] == Guid.Empty ? Guid.NewGuid() : entry.CurrentValues[BaseProperties.Guid];
entry.CurrentValues[BaseProperties.IsDeleted] = false;
entry.CurrentValues[BaseProperties.CreatedBy] = RequestContext?.UserId ?? "";
entry.CurrentValues[BaseProperties.CreatedAt] = DateTime.Now.ToUniversalTime().ToUnixTimeMilliseconds();
entry.CurrentValues[BaseProperties.UpdatedAt] = default(long);
entry.CurrentValues[BaseProperties.UpdatedBy] = default;
break;
case EntityState.Deleted:
entry.State = EntityState.Modified;
entry.CurrentValues[BaseProperties.IsDeleted] = true;
entry.CurrentValues[BaseProperties.UpdatedAt] = DateTime.Now.ToUniversalTime().ToUnixTimeMilliseconds();
entry.CurrentValues[BaseProperties.UpdatedBy] = RequestContext?.UserId ?? "";
entry.Property(BaseProperties.Guid).IsModified = false;
entry.Property(BaseProperties.CreatedAt).IsModified = false;
entry.Property(BaseProperties.CreatedBy).IsModified = false;
break;
case EntityState.Modified:
entry.CurrentValues[BaseProperties.UpdatedAt] = DateTime.Now.ToUniversalTime().ToUnixTimeMilliseconds();
entry.CurrentValues[BaseProperties.UpdatedBy] = RequestContext?.UserId ?? "";
entry.Property(BaseProperties.Guid).IsModified = false;
entry.Property(BaseProperties.CreatedAt).IsModified = false;
entry.Property(BaseProperties.CreatedBy).IsModified = false;
break;
}
}
}
private void MakeAudit()
{
var modifiedEntries = ChangeTracker.Entries().Where(
x => x.Entity is AuditEntity && (x.State == EntityState.Added || x.State == EntityState.Modified)
);
foreach (var entry in modifiedEntries)
{
var entity = entry.Entity as AuditEntity;
if (entity != null)
{
var date = DateTime.UtcNow;
// TODO : Pendiente implementar el usuario para la auditoria.
string userId = null;
if (entry.State == EntityState.Added)
{
entity.CreateAt = date;
entity.CreateBy = userId;
}
else if (entity is ISoftDelete && ((ISoftDelete)entity).Delete)
{
entity.DeleteAt = date;
entity.DeleteBy = userId;
}
Entry(entity).Property(x => x.CreateAt).IsModified = false;
Entry(entity).Property(x => x.CreateBy).IsModified = false;
entity.UpdateAt = date;
entity.UpdateBy = userId;
}
}
}
public async Task <int> SaveChangesAsync()
{
foreach (var entry in ChangeTracker.Entries <BaseEntity>().ToList())
{
switch (entry.State)
{
case EntityState.Added:
entry.Entity.CreationDate = DateTime.UtcNow;
entry.Entity.CreatedBy = _currentUser.UserId;
break;
case EntityState.Modified:
entry.Entity.LastUpdatedDate = DateTime.UtcNow;
entry.Entity.LastUpdatedBy = _currentUser.UserId;
break;
}
}
if (_currentUser.UserId != null)
{
await AuditLogging();
}
return(await base.SaveChangesAsync());
}
public override int SaveChanges()
{
foreach (var entry in ChangeTracker.Entries())
{
if (entry.Entity is Entity e)
{
switch (entry.State)
{
case EntityState.Added:
e.CreatedAt = DateTime.Now;
e.IsDeleted = false;
e.ModifiedAt = null;
e.DeletedAt = null;
break;
case EntityState.Modified:
e.ModifiedAt = DateTime.Now;
break;
}
}
}
return base.SaveChanges();
}
public int SaveChanges()
{
//call our code here
var hist = new History();
ChangeTracker.DetectChanges();
var holder = ChangeTracker.Entries <Holidays>();
foreach (System.Data.Entity.Infrastructure.DbEntityEntry <Holidays> entry in holder)
{
switch (entry.State)
{
case System.Data.EntityState.Added:
hist.type = "added";
break;
case System.Data.EntityState.Deleted:
hist.type = "deleted";
break;
case System.Data.EntityState.Modified:
hist.type = "modified";
break;
}
hist.dbtable = "Holidays";
hist.change = "Holiday: " + entry.Property(u => u.holidayName).CurrentValue +
"; Date: " + entry.Property(u => u.date).CurrentValue;
}
hist.username = System.Web.HttpContext.Current.User.Identity.Name;
hist.timestamp = System.DateTime.Now;
HistDB.HistoryList.Add(hist);
HistDB.SaveChanges();
return(base.SaveChanges());
}
private void SaveUpdateHook()
{
var entries = ChangeTracker
.Entries()
.Where(e => e.Entity is BaseEntity && (
e.State == EntityState.Added ||
e.State == EntityState.Modified));
foreach (var entityEntry in entries)
{
if (!(entityEntry.Entity is BaseEntity baseEntity))
{
continue;
}
if (entityEntry.State == EntityState.Added)
{
baseEntity.CreatedDate = DateTime.Now;
}
else
{
baseEntity.UpdatedDate = DateTime.Now;
}
}
}
public async Task <bool> Commit()
{
foreach (var entry in ChangeTracker.Entries().Where(entry => entry.Entity.GetType().GetProperty("RegisterDate") != null))
{
if (entry.State == EntityState.Added)
{
entry.Property("RegisterDate").CurrentValue = DateTime.Now;
}
if (entry.State == EntityState.Modified)
{
entry.Property("RegisterDate").IsModified = false;
}
}
var suceess = await base.SaveChangesAsync() > 0;
if (suceess)
{
await _handler.PublishEvents(this);
}
return(suceess);
}
public override Task <int> SaveChangesAsync(CancellationToken cancellationToken = new CancellationToken())
{
foreach (var entry in ChangeTracker.Entries <AuditableEntity>())
{
switch (entry.State)
{
case EntityState.Added:
entry.Entity.CreatedAt = DateTime.Now;
entry.Entity.Active = true;
break;
case EntityState.Modified:
entry.Entity.UpdatedAt = DateTime.Now;
break;
case EntityState.Deleted:
entry.Entity.DeletedAt = DateTime.Now;
entry.Entity.Active = false;
entry.State = EntityState.Modified;
break;
}
}
return(base.SaveChangesAsync(cancellationToken));
}
public override int SaveChanges()
{
foreach (var entry in ChangeTracker.Entries <AuditableEntity>())
{
switch (entry.State)
{
case EntityState.Added:
entry.Entity.CreatedAt = DateTime.Now;
entry.Entity.Active = true;
break;
case EntityState.Modified:
entry.Entity.UpdatedAt = DateTime.Now;
break;
case EntityState.Deleted:
entry.Entity.DeletedAt = DateTime.Now;
entry.Entity.Active = false;
entry.State = EntityState.Modified;
break;
}
}
return(base.SaveChanges());
}
public override int SaveChanges()
{
//foreach (EntityEntry<Course> course in ChangeTracker.Entries<Course>())
//{
// course.State = EntityState.Unchanged;
//}
//
//foreach (EntityEntry<Suffix> suffix in ChangeTracker.Entries<Suffix>())
//{
// suffix.State = EntityState.Unchanged;
//}
IEnumerable <EntityEntry> enumerationEntries = ChangeTracker.Entries()
.Where(x => EnumerationTypes.Contains(x.Entity.GetType()));
foreach (EntityEntry enumerationEntry in enumerationEntries)
{
enumerationEntry.State = EntityState.Unchanged;
}
List <Entity> entities = ChangeTracker.Entries()
.Where(x => x.Entity is Entity)
.Select(x => (Entity)x.Entity)
.ToList();
int result = base.SaveChanges();
foreach (Entity entity in entities)
{
// dispatch events
// clear all events
}
return(result);
}
public override int SaveChanges()
{
foreach (IEntity entity in ChangeTracker.Entries()
.Where(e => e.State == EntityState.Added)
.Select(e => e.Entity as IEntity))
{
entity.CreatedOn = DateTimeOffset.Now;
IUpdatesTrackable updatesTrackableEntity = entity as IUpdatesTrackable;
if (updatesTrackableEntity != null)
{
updatesTrackableEntity.LastUpdatedOn = DateTimeOffset.Now;
}
}
foreach (IUpdatesTrackable entity in ChangeTracker.Entries()
.Where(e => e.Entity is IUpdatesTrackable && e.State == EntityState.Modified)
.Select(e => e.Entity as IUpdatesTrackable))
{
entity.LastUpdatedOn = DateTimeOffset.Now;
}
return(base.SaveChanges());
}
private void OnBeforeSaving()
{
var entries = ChangeTracker.Entries();
var utcNow = DateTime.UtcNow;
foreach (var entry in entries)
{
if (entry.Entity is BaseEntity trackable)
{
switch (entry.State)
{
case EntityState.Modified:
trackable.UpdateOn = utcNow;
entry.Property("CreateOn").IsModified = false;
break;
case EntityState.Added:
trackable.CreateOn = utcNow;
trackable.UpdateOn = utcNow;
break;
}
}
}
}
private void OnBeforeSaving()
{
var entities = ChangeTracker.Entries().Where(x => x.Entity is BaseEntity &&
(x.State == EntityState.Added || x.State == EntityState.Modified || x.State == EntityState.Deleted));
foreach (var entity in entities)
{
if (entity.State == EntityState.Added)
{
((BaseEntity)entity.Entity).DateCreated = DateTime.Now;
((BaseEntity)entity.Entity).UserCreated = _loggedInUser.Username;
}
else if (entity.State == EntityState.Modified)
{
((BaseEntity)entity.Entity).DateModified = DateTime.Now;
((BaseEntity)entity.Entity).UserModified = _loggedInUser.Username;
}
else if (entity.State == EntityState.Deleted)
{
//disable delete from database
return;
}
}
}
public override async Task <int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = default)
{
try
{
var auditLog = AuditingManager?.Current?.Log;
List <EntityChangeInfo> entityChangeList = null;
if (auditLog != null)
{
entityChangeList = EntityHistoryHelper.CreateChangeList(ChangeTracker.Entries().ToList());
}
var changeReport = ApplyAbpConcepts();
var result = await base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken);
await EntityChangeEventHelper.TriggerEventsAsync(changeReport);
if (auditLog != null)
{
EntityHistoryHelper.UpdateChangeList(entityChangeList);
auditLog.EntityChanges.AddRange(entityChangeList);
Logger.LogDebug($"Added {entityChangeList.Count} entity changes to the current audit log");
}
return(result);
}
catch (DbUpdateConcurrencyException ex)
{
throw new AbpDbConcurrencyException(ex.Message, ex);
}
finally
{
ChangeTracker.AutoDetectChangesEnabled = true;
}
}
public async Task <bool> CommitAsync()
{
if (!_notificationHandler.HasNotifications())
{
foreach (var entry in ChangeTracker.Entries().Where(entry => entry.Entity.GetType().GetProperty("DataCriacao") != null))
{
if (entry.State == EntityState.Added)
{
entry.Property("DataCriacao").CurrentValue = DateTime.Now;
}
if (entry.State == EntityState.Modified)
{
entry.Property("DataCriacao").IsModified = false;
}
}
var sucesso = await base.SaveChangesAsync() > 0;
//if (sucesso) await _mediatorHandler.PublicarEventos(this);
return(sucesso);
}
return(false);
}
public void Initialize(ChangeTracker changeTracker)
{
_redirections.Initialize(changeTracker);
}
public virtual void Initialize(ChangeTracker changeTracker)
{
_state.Initialize(changeTracker);
}
public void Initialize(ChangeTracker changeTracker)
{
_steps.Initialize(changeTracker);
}
private void CreateForText(params string[] lines)
{
_textBuffer = Utils.EditorUtil.CreateBuffer(lines);
_textView = Mock.MockObjectFactory.CreateTextView(_textBuffer);
_textView.SetupGet(x => x.HasAggregateFocus).Returns(true);
_buffer = new MockVimBuffer();
_buffer.TextViewImpl = _textView.Object;
_buffer.TextBufferImpl = _textBuffer;
var factory = new MockFactory(MockBehavior.Loose);
factory.DefaultValue = DefaultValue.Mock;
_buffer.NormalModeImpl = factory.Create<INormalMode>().Object;
_buffer.VisualBlockModeImpl = factory.Create<IVisualMode>().Object;
_buffer.VisualCharacterModeImpl = factory.Create<IVisualMode>().Object;
_buffer.VisualLineModeImpl = factory.Create<IVisualMode>().Object;
_trackerRaw = new ChangeTracker();
_tracker = _trackerRaw;
_trackerRaw.OnVimBufferCreated(_buffer);
}
private void CreateForText(params string[] lines)
{
_textBuffer = Utils.EditorUtil.CreateBuffer(lines);
_textView = Utils.MockObjectFactory.CreateTextView(_textBuffer);
_textView.SetupGet(x => x.HasAggregateFocus).Returns(true);
_buffer = new MockVimBuffer();
_buffer.TextViewImpl = _textView.Object;
_buffer.TextBufferImpl = _textBuffer;
_normalMode = new MockNormalMode();
_buffer.ModeImpl = _normalMode;
_trackerRaw = new ChangeTracker();
_tracker = _trackerRaw;
_trackerRaw.OnVimBufferCreated(_buffer);
}
public void Initialize(ChangeTracker changeTracker, IHashDependancy hashDependancy)
{
_cardTypes.Initialize(changeTracker, hashDependancy);
_colors.Initialize(changeTracker, hashDependancy);
}
private void CreateForText(params string[] lines)
{
_textBuffer = EditorUtil.CreateBuffer(lines);
_textView = MockObjectFactory.CreateTextView(_textBuffer);
_textView.SetupGet(x => x.HasAggregateFocus).Returns(true);
_normalModeRunner = new MockCommandRunner();
_normalMode = new MockNormalMode() { CommandRunnerImpl = _normalModeRunner };
_buffer = new MockVimBuffer() { TextViewImpl = _textView.Object, TextBufferImpl = _textBuffer, NormalModeImpl = _normalMode };
_textChangeTracker = new MockTextChangeTracker() { VimBufferImpl = _buffer };
_factory = new MockRepository(MockBehavior.Loose);
_factory.DefaultValue = DefaultValue.Mock;
_textChangeTrackerFactory = _factory.Create<ITextChangeTrackerFactory>();
_textChangeTrackerFactory.Setup(x => x.GetTextChangeTracker(_buffer)).Returns(_textChangeTracker);
_buffer.VisualBlockModeImpl = _factory.Create<IVisualMode>().Object;
_buffer.VisualCharacterModeImpl = _factory.Create<IVisualMode>().Object;
_buffer.VisualLineModeImpl = _factory.Create<IVisualMode>().Object;
_trackerRaw = new ChangeTracker(_textChangeTrackerFactory.Object);
_tracker = _trackerRaw;
_trackerRaw.OnVimBufferCreated(_buffer);
}
public void Initialize(ChangeTracker changeTracker)
{
_costModifiers.Initialize(changeTracker);
}
public void Initialize(ChangeTracker changeTracker)
{
_score.Initialize(changeTracker);
_value.Initialize(changeTracker);
}
public void Initialize(ChangeTracker changeTracker)
{
_assigned.Initialize(changeTracker);
}
