public bool OnPreDelete(PreDeleteEvent @event)
{
if (IsEnabled)
{
var entity = default(Term);
if (@event.TryCatchEntity(ref entity))
{
if (DeleteSession == null)
{
DeleteSession = @event.Persister.Factory.GetCurrentSession();
}
var employeeId = entity.GetSnapshotValue <Guid>("EmployeeId");
var key = string.Format("{0}{1}", employeeId, entity.Start.Date);
if (!SqlCaches.ContainsKey(key))
{
var sql = string.Format("delete BackupTerm where BackupTerm.EmployeeId ='{0}' and datediff(d,starttime,'{1:yyyy/MM/dd HH:mm}')=0", employeeId, entity.Start.Date);
SqlCaches[key] = sql;
DeleteSession.CreateSQLQuery(sql).ExecuteUpdate();
}
}
}
return(false);
}
public static IEnumerable <PropertyEntry> ToPropertyEntry(
this PreDeleteEvent @event)
{
return(@event.DeletedState
.Select((t, i) => @event.Persister.PropertyNames[i])
.Select((name, i) => new NHibernatePropertyEntry(name, false, null, @event.DeletedState, i)));
}
/// <summary>
/// Save <see cref="Audit"/>
/// </summary>
/// <param name="event"><see cref="PreDeleteEvent"/></param>
internal static void Save(PreDeleteEvent @event)
{
if ([email protected]().GetInterfaces().Contains(typeof(IAuditable)))
{
return;
}
var session = @event.Session.GetSession(EntityMode.Poco);
var auditClass = AuditClass.Find(session, @event.Entity.GetType().FullName);
if (auditClass == null)
{
return;
}
var auditable = (IAuditable)@event.Entity;
if (string.IsNullOrWhiteSpace(auditable.AuditDescription))
{
auditable.AuditDescription = "{0} deleted".With(auditClass.Description);
}
Save(session, @event.Id.ToString(), auditable.AuditGroupReference, auditClass, AuditType.Delete(),
auditable.AuditDescription, auditable.AuditUser);
}
public async Task <bool> OnPreDeleteAsync(PreDeleteEvent e, CancellationToken cancellationToken)
{
if (e.Entity is IEntity entity)
{
await entity.BeforeDelete(new ChangeTrackerArgs(e.DeletedState, null, e.Persister.PropertyNames, false)).ConfigureAwait(false);
}
return(false);
}
public bool OnPreDelete(PreDeleteEvent e)
{
if (_logger != null)
{
_logger.Delete(e.Entity as IEntity);
}
return(false);
}
/// <summary>
/// Called when [pre delete].
/// </summary>
/// <param name="e">The e.</param>
/// <returns></returns>
public bool OnPreDelete(PreDeleteEvent e)
{
if (e.Entity != null && IsAuditable(e.Entity))
{
InsertDeleteAuditLog((Entity <int>)e.Entity, e.Session, AuditType.Delete);
}
return(false);
}
public bool OnPreDelete(PreDeleteEvent ev)
{
if (ev.Entity is ITransaction transaction)
{
throw new TransactionDeleteException(transaction);
}
return(false);
}
/// <summary>
/// Handles PreDelete event to delete an entity's associated security data.
/// </summary>
/// <param name="deleteEvent">Event object containing the delete operation information.</param>
/// <returns>False, indicating the delete operation should not be vetoed.</returns>
public bool OnPreDelete(PreDeleteEvent deleteEvent)
{
Guid securityKey = Security.ExtractKey(deleteEvent.Entity);
if (!Guid.Empty.Equals(securityKey))
{
var entityReference = deleteEvent.Session.CreateCriteria <EntityReference>()
.Add(Restrictions.Eq("EntitySecurityKey", securityKey))
.SetCacheable(true)
.UniqueResult <EntityReference>();
if (entityReference != null)
{
ISession childSession = deleteEvent.Session.SessionWithOptions()
.Connection()
.ConnectionReleaseMode()
.FlushMode()
.Interceptor()
.OpenSession();
// because default flush mode is auto, a read after a scheduled delete will invoke
// the auto-flush behaviour, causing a constraint violation exception in the
// underlying database, because there still are EntityGroup entities that need
// the deleted EntityReference/SecurityKey.
childSession.FlushMode = FlushMode.Commit;
childSession.Delete(entityReference);
//Also remove EntityReferencesToEntitiesGroups and Permissions that reference this entity
//Get list of EntitiesGroups that have the entity as a member
IEnumerable <EntitiesGroup> entitiesGroups = childSession.CreateCriteria <EntitiesGroup>()
.CreateCriteria("Entities")
.Add(Restrictions.Eq("EntitySecurityKey", securityKey))
.SetCacheable(true)
.List <EntitiesGroup>();
foreach (EntitiesGroup group in entitiesGroups)
{
group.Entities.Remove(entityReference);
}
////Get list of Permissions that references the entity
IEnumerable <Permission> permissions = childSession.CreateCriteria <Permission>()
.Add(Restrictions.Eq("EntitySecurityKey", securityKey))
.SetCacheable(true)
.List <Permission>();
foreach (Permission permission in permissions)
{
childSession.Delete(permission);
}
childSession.Flush();
}
}
return(false);
}
public bool OnPreDelete(
PreDeleteEvent @event)
{
var properties = @event.ToPropertyEntry().ToList();
Raise(@event, typeof(BeforeDeletedEntityDomainEvent <>), @event.Entity, properties);
return(false);
}
public static IEnumerable <PropertyEntry> ToPropertyEntry(
this PreDeleteEvent @event)
{
var entityType = NHibernateUtil.GetClass(@event.Entity);
return(@event.DeletedState
.Select((t, i) => @event.Persister.PropertyNames[i])
.Select((name, i) => new NHibernatePropertyEntry(entityType.GetProperty(@event.Persister.PropertyNames[i]), false, null, @event.DeletedState, i)));
}
public bool OnPreDelete(PreDeleteEvent @event)
{
if (@event.Session.Transaction == null || [email protected])
{
throw new InvalidProgramException("Nenhuma transação foi iniciada.");
}
return(true);
}
public static bool TryCatchEntity <T>(this PreDeleteEvent @event, ref T entity)
{
if (@event.Entity is T)
{
entity = (T)@event.Entity;
return(true);
}
return(false);
}
public async Task <bool> OnPreDeleteAsync(
PreDeleteEvent @event,
CancellationToken cancellationToken)
{
var properties = @event.ToPropertyEntry().ToList();
await RaiseAsync(@event, typeof(BeforeDeletedEntityDomainEvent <>), @event.Entity, properties);
return(false);
}
public bool OnPreDelete(PreDeleteEvent @event)
{
var seatArrangement = default(SeatArrangement);
if (@event.TryCatchEntity(ref seatArrangement))
{
//seatArrangement.Cancel(null);
//_occupationRepository.DeleteSeatArrangements(seatArrangement..Id);
}
return(false);
}
/// <summary>
/// Return true if the operation should be vetoed
/// </summary>
/// <param name="event"/>
public bool OnPreDelete(PreDeleteEvent @event)
{
try
{
AggregateDataInterceptor.OnDeleteCheckAggregate(@event.Entity, @event.Session);
return(false);
}
catch (Exception ex)
{
throw new InvalidOperationException("Error trying to flush aggregates during pre-delete phase: {0}".InvariantFormat(GetUsefulEntityName(@event.Entity, null, null)), ex);
}
}
public bool OnPreDelete(PreDeleteEvent @event)
{
Debug.WriteLine(string.Format("OnPreDelete - {0}", @event.Entity));
if (@event.Entity is IDataObject)
{
// the function returns true if the operation should be vetoed
// consider returning false instead of throwing
ServiceDataAuthorizationConnector.Check((IDataObject)@event.Entity,
DataOperation.Delete);
}
return(false);
}
private bool PreDelete()
{
IPreDeleteEventListener[] preListeners = Session.Listeners.PreDeleteEventListeners;
bool veto = false;
if (preListeners.Length > 0)
{
var preEvent = new PreDeleteEvent(Instance, Id, state, Persister, (IEventSource)Session);
foreach (IPreDeleteEventListener listener in preListeners)
{
veto |= listener.OnPreDelete(preEvent);
}
}
return(veto);
}
/// <summary>
/// Handles PreDelete event to delete an entity's associated security data.
/// </summary>
/// <param name="deleteEvent">Event object containing the delete operation information.</param>
/// <returns>False, indicating the delete operation should not be vetoed.</returns>
public bool OnPreDelete(PreDeleteEvent deleteEvent)
{
var securityKey = Security.ExtractKey(deleteEvent.Entity);
if (!Guid.Empty.Equals(securityKey))
{
EntityReference entityReference = deleteEvent.Session.CreateCriteria <EntityReference>()
.Add(Restrictions.Eq("EntitySecurityKey", securityKey))
.SetCacheable(true)
.UniqueResult <EntityReference>();
if (entityReference != null)
{
var childSession = deleteEvent.Session.GetSession(NHibernate.EntityMode.Poco);
// childSession.Delete(entityReference);
//Also remove EntityReferencesToEntitiesGroups and Permissions that reference this entity
//Get list of EntitiesGroups that have the entity as a member
IEnumerable <EntitiesGroup> entitiesGroups = childSession.CreateCriteria <EntitiesGroup>()
.CreateCriteria("Entities")
.Add(Restrictions.Eq("EntitySecurityKey", securityKey))
.SetCacheable(true)
.List <EntitiesGroup>();
foreach (EntitiesGroup group in entitiesGroups)
{
group.Entities.Remove(entityReference);
}
////Get list of Permissions that references the entity
IEnumerable <Permission> permissions = childSession.CreateCriteria <Permission>()
.Add(Restrictions.Eq("EntitySecurityKey", securityKey))
.SetCacheable(true)
.List <Permission>();
foreach (Permission permission in permissions)
{
childSession.Delete(permission);
}
childSession.Flush();
}
}
return(false);
}
private async Task <bool> PreDeleteAsync(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
IPreDeleteEventListener[] preListeners = Session.Listeners.PreDeleteEventListeners;
bool veto = false;
if (preListeners.Length > 0)
{
var preEvent = new PreDeleteEvent(Instance, Id, state, Persister, (IEventSource)Session);
foreach (IPreDeleteEventListener listener in preListeners)
{
veto |= await(listener.OnPreDeleteAsync(preEvent, cancellationToken)).ConfigureAwait(false);
}
}
return(veto);
}
public bool OnPreDelete(PreDeleteEvent preDeleteEvent)
{
var softDeletable = preDeleteEvent.Entity as ISoftDeletable;
if (softDeletable != null)
{
// TODO: process all subproperties and delete them if softdeletable?
// should be normal subproperties deleted?
var session = preDeleteEvent.Session.GetSession(EntityMode.Poco);
softDeletable.IsDeleted = true;
session.Update(softDeletable);
session.Flush();
return(true);
}
return(false);
}
public bool OnPreDelete(PreDeleteEvent @event)
{
if (!(@event.Entity is IDeletable deletable))
{
return(false);
}
var entry = @event.Session.GetSessionImplementation().PersistenceContext.GetEntry(@event.Entity);
entry.Status = Status.Loaded;
deletable.SetDeleted();
var id = @event.Persister.GetIdentifier(@event.Entity);
var fields = @event.Persister.GetPropertyValues(@event.Entity);
var version = @event.Persister.GetVersion(@event.Entity);
@event.Persister.Update(id, fields, new int[1], false, fields, version, @event.Entity, null,
@event.Session.GetSessionImplementation());
return(true);
}
public bool OnPreDelete(PreDeleteEvent @event)
{
var entity = ValidateOblect(@event.Entity);
if (entity != null)
{
var sessionImpl = @event.Session.GetSessionImplementation();
EntityEntry entry = sessionImpl.PersistenceContext.GetEntry(entity);
entry.Status = Status.Loaded;
entity.IsDeleted = true;
//object id = @event.Persister.GetIdentifier(entity, @event.Session.EntityMode);
//object[] fields = @event.Persister.GetPropertyValues(entity, @event.Session.EntityMode);
//object version = @event.Persister.GetVersion(entity, @event.Session.EntityMode);
object id = @event.Persister.GetIdentifier(entity);
object[] fields = @event.Persister.GetPropertyValues(entity);
object version = @event.Persister.GetVersion(entity);
@event.Persister.Update(id, fields, new int[1], false, fields, version, entity, null, sessionImpl);
PackageAuditLogItem(EventType.SoftDeleted, @event.Persister, entity as IRootEntity <idT>, fields, entry.DeletedState);
}
return(true);
}
public bool OnPreDelete(PreDeleteEvent e)
{
throw new NotImplementedException();
}
/// <inheritdoc />
public Task <bool> OnPreDeleteAsync(PreDeleteEvent @event, CancellationToken cancellationToken)
{
return(Task.Run(() => OnPreDelete(@event), cancellationToken));
}
public Task <bool> OnPreDeleteAsync(PreDeleteEvent @event, CancellationToken cancellationToken) => new Task <bool>(() => OnPreDelete(@event), cancellationToken);
public bool OnPreDelete(PreDeleteEvent @event) => @event.Entity is Entity <ConnectionConfigurer> entity ? !entity.OnPreDelete() : false;
public Task <bool> OnPreDeleteAsync(PreDeleteEvent @event, CancellationToken cancellationToken)
{
OnPreDelete(@event);
return(Task.FromResult(false));
}
public bool OnPreDelete(PreDeleteEvent @event)
{
CheckTransaction(@event.Session);
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="event"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public Task <bool> OnPreDeleteAsync(PreDeleteEvent @event, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Return true if the operation should be vetoed
/// </summary>
/// <param name="event"/>
public bool OnPreDelete(PreDeleteEvent @event)
{
Audit.Save(@event);
return(false);
}
