public void HookEntityMetadata_EntityStateChangedIsFalse_AfterReassigningSameValue()
{
var result = new HookEntityMetadata(EntityState.Modified);
Assert.AreEqual(false, result.HasStateChanged);
result.State = EntityState.Modified;
Assert.AreEqual(false, result.HasStateChanged);
}
protected override void Hook(ICreationTracking entity, HookEntityMetadata metadata)
{
metadata.Entry.Property(EFCore.CreationDateTime).CurrentValue = _dateTime.UtcNow;
metadata.Entry.Property(EFCore.CreatorBrowserName).CurrentValue = _session.UserBrowserName;
metadata.Entry.Property(EFCore.CreatorIp).CurrentValue = _session.UserIP;
metadata.Entry.Property(EFCore.CreatorUserId).CurrentValue = _session.UserId;
}
public override void Hook(ISoftDeletable entity, HookEntityMetadata metadata)
{
var baseEntity = entity as BaseEntity;
if (baseEntity == null)
{
return;
}
var aclEntity = baseEntity as IAclSupported;
if (aclEntity == null || !aclEntity.SubjectToAcl)
{
return;
}
var ctx = _dbContext.Value;
var modProps = ctx.GetModifiedProperties(baseEntity);
if (modProps.ContainsKey("Deleted"))
{
var shouldSetIdle = entity.Deleted;
var entityType = baseEntity.GetUnproxiedType();
var records = _aclService.Value.GetAclRecordsFor(entityType.Name, baseEntity.Id);
foreach (var record in records)
{
record.IsIdle = shouldSetIdle;
_aclService.Value.UpdateAclRecord(record);
}
}
}
public void HookEntityMetadata_HasEntityState()
{
var result = new HookEntityMetadata(EntityState.Deleted);
result.State = EntityState.Modified;
Assert.AreEqual(EntityState.Modified, result.State);
}
public void HookEntityMetadata_MetadataWithContext()
{
var context = new LocalContext();
var result = new HookEntityMetadata(EntityState.Modified, context);
Assert.AreEqual(context, result.CurrentContext);
}
protected override void Hook(ICreationTracking entity, HookEntityMetadata metadata, IUnitOfWork uow)
{
metadata.Entry.Property(EFCoreShadow.CreatedDateTime).CurrentValue = _clock.Now;
metadata.Entry.Property(EFCoreShadow.CreatedByBrowserName).CurrentValue = _session.UserBrowserName;
metadata.Entry.Property(EFCoreShadow.CreatedByIP).CurrentValue = _session.UserIP;
metadata.Entry.Property(EFCoreShadow.CreatedByUserId).CurrentValue = _session.UserId.To <TUserId>();
}
/// <summary>
/// Implements the interface. This causes the hook to only run for objects that are assignable to TEntity.
/// </summary>
public void HookObject(object entity, HookEntityMetadata metadata)
{
if (typeof(TEntity).IsAssignableFrom(entity.GetType()))
{
Hook((TEntity)entity, metadata);
}
}
protected override void Hook(IModificationTracking entity, HookEntityMetadata metadata, IUnitOfWork uow)
{
metadata.Entry.Property(EFCore.ModificationDateTime).CurrentValue = _dateTime.UtcNow;
metadata.Entry.Property(EFCore.ModifierBrowserName).CurrentValue = _session.UserBrowserName;
metadata.Entry.Property(EFCore.ModifierIp).CurrentValue = _session.UserIP;
metadata.Entry.Property(EFCore.ModifierUserId).CurrentValue = _session.UserId.FromString <TUserId>();
}
protected override void Hook(IHaveRowLevelSecurity entity, HookEntityMetadata metadata)
{
if (_session.UserId.HasValue)
{
entity.UserId = _session.UserId.Value;
}
}
public override void Hook(ProductVariantAttributeValue entity, HookEntityMetadata metadata)
{
if (entity != null)
{
_productAttributeService.DeleteProductBundleItemAttributeFilter(entity.ProductVariantAttributeId, entity.Id);
}
}
public void HookEntityMetadata_OnlyShowsEntityStateChangeAfterModification()
{
var result = new HookEntityMetadata(EntityState.Deleted);
Assert.AreEqual(false, result.HasStateChanged);
result.State = EntityState.Modified;
Assert.AreEqual(true, result.HasStateChanged);
}
protected override void Hook(IModificationTracking entity, HookEntityMetadata metadata, IDbContext dbContext)
{
metadata.Entry.Property(EFCoreShadow.ModifiedDateTime).CurrentValue = _clock.Now;
metadata.Entry.Property(EFCoreShadow.ModifiedByBrowserName).CurrentValue = _session.UserBrowserName;
metadata.Entry.Property(EFCoreShadow.ModifiedByIP).CurrentValue = _session.UserIP;
metadata.Entry.Property(EFCoreShadow.ModifiedByUserId).CurrentValue = _session.UserId.To <TUserId>();
}
public void HookEntityMetadata_OnlyShowsEntityStateChangeAfterModification()
{
var result = new HookEntityMetadata(EntityState.Deleted);
Assert.AreEqual(false, result.HasStateChanged);
result.State = EntityState.Modified;
Assert.AreEqual(true, result.HasStateChanged);
}
public void HookEntityMetadata_EntityStateChangedIsFalse_AfterReassigningSameValue()
{
var result = new HookEntityMetadata(EntityState.Modified);
Assert.AreEqual(false, result.HasStateChanged);
result.State = EntityState.Modified;
Assert.AreEqual(false, result.HasStateChanged);
}
public override void Hook(IModificationAudited entity, HookEntityMetadata metadata)
{
if (entity == null)
{
return;
}
entity.ModifiedOnUtc = Clock.Now;
entity.ModifiedUserID = _workContext.Value.CurrentUser.Id;
}
public override void Hook(IIdentifiable entity, HookEntityMetadata metadata)
{
//// Check is auditable context, contains auditlog table
IAuditableContext context = metadata.CurrentContext as IAuditableContext;
if (context == null)
{
return;
}
//// Get current username
var userName = "******";
if (this.HttpContext != null)
{
userName = this.HttpContext.User.Identity.Name;
}
//// Get entry, entity type and associate etadata
var entry = ((IObjectContextAdapter)metadata.CurrentContext).ObjectContext.ObjectStateManager.GetObjectStateEntry(entity);
var entityType = entity.GetType();
TypeDescriptor.AddProvider(new AssociatedMetadataTypeTypeDescriptionProvider(entityType), entityType);
//// Get is entity modified property contains requireAudit Field, and add auditlog
var properties = TypeDescriptor.GetProperties(entityType);
foreach (string propertyName in entry.GetModifiedProperties())
{
//// Check is property need io
var propertyDescriptor = properties.Find(propertyName, true);
var propRequireAudit = propertyDescriptor.Attributes.OfType <RequireAuditAttribute>().FirstOrDefault();
if (propRequireAudit == null)
{
continue;
}
//// Get original value
DbDataRecord original = entry.OriginalValues;
string oldValue = original.GetValue(original.GetOrdinal(propertyName)).ToString();
//// Get new value
CurrentValueRecord current = entry.CurrentValues;
string newValue = current.GetValue(current.GetOrdinal(propertyName)).ToString();
//// Write Audit Log
AuditLog auditLog = new AuditLog();
auditLog.IdentifyKey = entity.IdentifyKey;
auditLog.IdentifyName = entityType.Name;
auditLog.OriginValue = oldValue;
auditLog.NewValue = newValue;
auditLog.CreatedAt = DateTime.Now;
auditLog.CreatedBy = userName;
context.AuditLogs.Add(auditLog);
}
}
protected override void Hook(ITenantEntity entity, HookEntityMetadata metadata)
{
if (!_tenant.HasValue)
{
return;
}
metadata.Entry.Property(EFCore.TenantId).CurrentValue = _tenant.Value.Id;
}
public void HookObject(object entity, HookEntityMetadata metadata)
{
var entityId = entity as IEntityObjectId <string>;
if (entityId != null && entityId.Id.IsEmpty())
{
entityId.Id = SequentialGuid.NewGuid().ToString().ToLower();
}
}
public override void Hook(ISoftDeletable entity, HookEntityMetadata metadata)
{
var baseEntity = entity as BaseEntity;
if (baseEntity == null)
{
return;
}
var dbContext = _ctx.Resolve <IDbContext>();
var modifiedProps = dbContext.GetModifiedProperties(baseEntity);
if (!modifiedProps.ContainsKey("Deleted"))
{
return;
}
var entityType = baseEntity.GetUnproxiedType();
using (var scope = new DbContextScope(ctx: dbContext, autoCommit: false))
{
// mark orphaned ACL records as idle
var aclSupported = baseEntity as IAclSupported;
if (aclSupported != null && aclSupported.SubjectToAcl)
{
var shouldSetIdle = entity.Deleted;
var rsAclRecord = _ctx.Resolve <IRepository <AclRecord> >();
var aclService = _ctx.Resolve <IAclService>();
var records = aclService.GetAclRecordsFor(entityType.Name, baseEntity.Id);
foreach (var record in records)
{
record.IsIdle = shouldSetIdle;
aclService.UpdateAclRecord(record);
}
}
// Delete orphaned inactive UrlRecords.
// We keep the active ones on purpose in order to be able to fully restore a soft deletable entity once we implemented the "recycle bin" feature
var slugSupported = baseEntity as ISlugSupported;
if (slugSupported != null && entity.Deleted)
{
var rsUrlRecord = _ctx.Resolve <IRepository <UrlRecord> >();
var urlRecordService = _ctx.Resolve <IUrlRecordService>();
var activeRecords = urlRecordService.GetUrlRecordsFor(entityType.Name, baseEntity.Id);
foreach (var record in activeRecords)
{
if (!record.IsActive)
{
urlRecordService.DeleteUrlRecord(record);
}
}
}
}
}
public override void Hook(Auditable entity, HookEntityMetadata metadata)
{
EntityState state = metadata.CurrentContext.Entry(entity).State;
if (state != EntityState.Detached && state != EntityState.Unchanged)
{
AuditFields.SetUpdatedByField(entity, metadata, User);
AuditFields.SetUpdatedAtField(entity);
}
}
public void Should_PreDeleteHook_Reassign_To_Modified_State()
{
var hook = new SoftDeletePreDeleteHook();
var metadata = new HookEntityMetadata(EntityState.Deleted);
var entity = new TimestampedSoftDeletedEntity();
hook.Hook(entity, metadata);
Assert.AreEqual(true, metadata.HasStateChanged);
Assert.AreEqual(EntityState.Modified, metadata.State);
}
/// <summary>
/// Executes the post action hooks.
/// </summary>
/// <param name="modifiedEntries">The modified entries to execute hooks for.</param>
private void ExecutePostActionHooks(IEnumerable <HookedEntityEntry> modifiedEntries)
{
foreach (var entityEntry in modifiedEntries)
{
foreach (var hook in _postHooks.Where(x => x.HookStates == entityEntry.PreSaveState))
{
var metadata = new HookEntityMetadata(entityEntry.PreSaveState);
hook.HookObject(entityEntry.Entity, metadata);
}
}
}
protected virtual void ExecuteHooks <THook>(IEnumerable <EntityEntry> entryList) where THook : IHook
{
foreach (var entry in entryList)
{
var hooks = _hooks.OfType <THook>().Where(x => x.HookState == entry.State).OrderBy(hook => hook.Order);
foreach (var hook in hooks)
{
var metadata = new HookEntityMetadata(entry);
hook.Hook(entry.Entity, metadata, this);
}
}
}
public override void Hook(IHookBase entity, HookEntityMetadata metadata)
{
var userId = "Unknown";
if (this._token != null)
{
userId = _token.UserId;
}
entity.CreateUser = userId;
entity.CreateTime = DateTime.Now;
}
public override void Hook(ISystemInfo entity, HookEntityMetadata metadata)
{
var userName = "******";
if (this.HttpContext != null &&
this.HttpContext.User.Identity.IsAuthenticated)
{
userName = this.HttpContext.User.Identity.Name;
}
entity.UpdatedBy = userName;
entity.UpdatedAt = DateTime.Now;
}
protected override void Hook(IBranchedEntity entity, HookEntityMetadata metadata)
{
if (!(entity is IBranchedEntity branchedEntity))
{
return;
}
if (branchedEntity.BranchId != default)
{
throw new FrameworkException("Can not set TenantId to 0 for IBranchedEntity!");
}
branchedEntity.BranchId = _uow.BranchId;
}
public override void Hook(ILocalizedEntity entity, HookEntityMetadata metadata)
{
var baseEntity = entity as BaseEntity;
if (baseEntity == null)
{
return;
}
var entityType = baseEntity.GetUnproxiedType();
var localizedEntities = this._localizedEntityService.GetLocalizedProperties(baseEntity.Id, entityType.Name);
localizedEntities.Each(x => this._localizedEntityService.DeleteLocalizedProperty(x));
}
protected override void Hook(ITenantEntity entity, HookEntityMetadata metadata)
{
if (!(entity is ITenantEntity tenantEntity))
{
return;
}
if (tenantEntity.TenantId != default)
{
throw new FrameworkException("Can not set TenantId to 0 for IMultiTenant entities!");
}
tenantEntity.TenantId = _uow.TenantId;
}
public override void Hook(IAclSupported entity, HookEntityMetadata metadata)
{
var baseEntity = entity as BaseEntity;
if (baseEntity == null)
{
return;
}
var entityType = baseEntity.GetUnproxiedType();
var records = _aclService.Value.GetAclRecordsFor(entityType.Name, baseEntity.Id);
records.Each(x => _aclService.Value.DeleteAclRecord(x));
}
public void ExecutePostActionHooks()
{
foreach (var entityEntry in _modifiedEntries)
{
var entry = entityEntry;
var postActionHooks = IoC.GetAllInstances <IPostActionHook>()
.Where(x => (x.HookState & entry.PreSaveState) == entry.PreSaveState);
foreach (var hook in postActionHooks)
{
var metadata = new HookEntityMetadata(entityEntry.PreSaveState);
hook.Hook(entityEntry.Entity, metadata);
}
}
}
public void ExecutePostActionHooks(IEnumerable <HookedEntityEntry> modifiedEntries)
{
foreach (var entityEntry in modifiedEntries)
{
var entry = entityEntry;
var hooks = _provider.GetServices <IPostActionHook>()
.Where(x => (x.HookState & entry.PreSaveState) == entry.PreSaveState);
foreach (var hook in hooks)
{
var metadata = new HookEntityMetadata(entityEntry.PreSaveState);
hook.Hook(entityEntry.Entity, metadata);
}
}
}
protected override void Hook(IEntity entity, HookEntityMetadata metadata)
{
if (entity is IHasDeletionDateTime hasDeletionDateTimeEntity)
{
hasDeletionDateTimeEntity.DeletionDateTime = _dateTime.UtcNow;
}
if (!(entity is IDeletionTracking deletionTrackingEntity))
{
return;
}
deletionTrackingEntity.DeleterUserId = _session.UserId;
deletionTrackingEntity.DeleterIp = _session.UserIP;
deletionTrackingEntity.DeleterBrowserName = _session.UserBrowserName;
}
public void HookEntityMetadata_MetadataWithContext()
{
var context = new LocalContext();
var result = new HookEntityMetadata(EntityState.Modified, context);
Assert.AreEqual(context, result.CurrentContext);
}
public void HookEntityMetadata_HasEntityState()
{
var result = new HookEntityMetadata(EntityState.Deleted);
result.State = EntityState.Modified;
Assert.AreEqual(EntityState.Modified, result.State);
}
