protected override object EntityIsTransient(SaveOrUpdateEvent eventt)
{
var entity = eventt.Entity as AEntity;
if (entity != null)
entity.Created = entity.Modified = DateTime.Now;
return base.EntityIsTransient(eventt);
}
protected override object EntityIsPersistent(SaveOrUpdateEvent eventt)
{
var entity = eventt.Entity as AEntity;
if (null != entity)
entity.Modified = DateTime.Now;
return base.EntityIsPersistent(eventt);
}
protected override object EntityIsPersistent(SaveOrUpdateEvent @event)
{
var entity = @event.Entity as IUpdateAwareEntity;
if (entity != null)
entity.OnUpdate();
return base.EntityIsPersistent(@event); ;
}
protected override object EntityIsTransient(SaveOrUpdateEvent @event)
{
var entity = @event.Entity as ISaveAwareEntity;
if (entity != null)
entity.OnSave();
return base.EntityIsTransient(@event);
}
/// <summary>
/// Performs the save or update.
/// </summary>
/// <param name="evt">The evt.</param>
/// <returns>
/// The id used to save the entity; may be null depending on the
/// type of id generator used and the requiresImmediateIdAccess value
/// </returns>
protected override object PerformSaveOrUpdate(SaveOrUpdateEvent evt)
{
if (evt.Session.IsDirtyEntity(evt.Entity))
{
eventListenerHelper.OnModify(evt.Entity);
}
return base.PerformSaveOrUpdate(evt);
}
/// <summary>
/// Performs the update.
/// </summary>
/// <param name="evt">The event.</param>
/// <param name="entity">The entity.</param>
/// <param name="persister">The persister.</param>
protected override void PerformUpdate(SaveOrUpdateEvent evt, object entity, NHibernate.Persister.Entity.IEntityPersister persister)
{
if (evt.Session.IsDirtyEntity(entity))
{
eventListenerHelper.OnModify(entity);
}
base.PerformUpdate(evt, entity, persister);
}
protected override object PerformSaveOrUpdate(SaveOrUpdateEvent evt)
{
var entity = evt.Entity as Entity;
if(entity != null) {
ProcessEntityBeforeInsert(entity, evt.Session);
}
return base.PerformSaveOrUpdate(evt);
}
public void SaveIdentifiable(SaveOrUpdateEvent @event, IIdentifiable identifiable)
{
var other = @event.Session.Get(@event.Entity.GetType(), identifiable.Id);
if (other == null)
Default.OnSaveOrUpdate(@event);
else
{
@event.ResultId = identifiable.Id;
}
}
public void OnSaveOrUpdate(SaveOrUpdateEvent @event)
{
var entity = @event.Entity as Entity;
if (entity == null) return;
EventDispatcher.RaiseEvent(@event.Entity, entity.Id.Equals(Guid.Empty) ? typeof (InsertEvent) : typeof (UpdateEvent));
//Validate event is raised here instead of on PreInsert/PreUpdate events to make our validation before the
//NHibernate DefaultSaveOrUpdateEventListener is handled since it throws own exceptions if entity isn't valid
//according to its Map.
EventDispatcher.RaiseEvent(@event.Entity, typeof (ValidateEvent));
}
/// <summary>
/// Performs the save or update.
/// </summary>
/// <param name="evt">The save or update event.</param>
/// <returns>
/// The id used to save the entity; may be null depending on the
/// type of id generator used and the requiresImmediateIdAccess value
/// </returns>
protected override object PerformSaveOrUpdate(SaveOrUpdateEvent evt)
{
if (evt.Entity is IEntity)
{
Events.CoreEvents.Instance.OnEntitySaving((IEntity)evt.Entity, evt.Session);
}
if (evt.Session.IsDirtyEntity(evt.Entity))
{
eventListenerHelper.OnModify(evt.Entity);
}
return base.PerformSaveOrUpdate(evt);
}
/// <summary>
/// Performs the update.
/// </summary>
/// <param name="evt">The event.</param>
/// <param name="entity">The entity.</param>
/// <param name="persister">The entity's persister.</param>
protected override void PerformUpdate(SaveOrUpdateEvent evt, object entity, NHibernate.Persister.Entity.IEntityPersister persister)
{
if (entity is IEntity)
{
Events.CoreEvents.Instance.OnEntitySaving((IEntity)entity, evt.Session);
}
if (evt.Session.IsDirtyEntity(entity))
{
eventListenerHelper.OnModify(entity);
}
base.PerformUpdate(evt, entity, persister);
}
protected override object PerformSaveOrUpdate(SaveOrUpdateEvent @event)
{
var baseEntity = @event.Entity as BaseEntity;
if (baseEntity != null)
{
baseEntity.Creator = "Leoli";
baseEntity.LastEditor = "Leoli_SaveOrUpdate_Event";
baseEntity.CreateTime = DateTime.Now;
baseEntity.LastTime = DateTime.Now;
}
return base.PerformSaveOrUpdate(@event);
}
public void OnSaveOrUpdate(SaveOrUpdateEvent @event)
{
var identifiable = @event.Entity as IIdentifiable;
if (identifiable == null)
{
Default.OnSaveOrUpdate(@event);
return;
}
if (identifiable.Id == null)
{
identifiable.AssignIdentity();
}
if (Default == null) return;
if ((Default is DefaultSaveEventListener) || (Default is DefaultSaveOrUpdateEventListener))
SaveIdentifiable(@event, identifiable);
else
Default.OnSaveOrUpdate(@event);
}
public void OnSaveOrUpdate(SaveOrUpdateEvent @event)
{
}
public void OnSaveOrUpdate(SaveOrUpdateEvent @event)
{
log.Debug("OnSaveOrUpdate :" + @event);
}
public void OnSaveOrUpdate(SaveOrUpdateEvent @event)
{
Debug.WriteLine(string.Format("OnSaveOrUpdate - {0}", @event.Entity));
if (@event.Entity is IDataObject)
{
ServiceDataAuthorizationConnector.Check((IDataObject)@event.Entity,
DataOperation.Retreive);
}
}
public void OnSaveOrUpdate(SaveOrUpdateEvent @event)
{
Debug.WriteLine("EventListener.OnSaveOrUpdate: {0}", @event.ResultId);
}
// Commented out for perf, can enable if you want to debug a tricky NH exception
//private ConcurrentQueue<string> _saveQueue = new ConcurrentQueue<string>();
public void OnSaveOrUpdate(SaveOrUpdateEvent @event)
{
try
{
_defaultSaveListener.OnSaveOrUpdate(@event);
//_saveQueue.Enqueue(usefulEntityName + " at " + DateTimeOffset.UtcNow.TimeOfDay.ToString());
//// Trim the save queue to avoid it getting too big
//if (_saveQueue.Count > 10) _saveQueue = new ConcurrentQueue<string>(_saveQueue.Reverse().Take(10).Reverse());
}
catch (Exception ex)
{
var cascadeHelperMsg = string.Empty;
var actionQueueDeletions = string.Empty;
//if (ex.Message.Contains("cascade"))
//{
// cascadeHelperMsg = "\nPreviously tried:\n" + string.Concat(_saveQueue.Select(x => x + "\n"));
// actionQueueDeletions = "\nDeletions queued:\n" + string.Concat(@event.Session.ActionQueue.CloneDeletions().Select(x => GetUsefulEntityName(x.Instance, x.EntityName, x.Id) + "\n"));
//}
var usefulEntityName = GetUsefulEntityName(@event.Entity, @event.EntityName, @event.Entry != null ? @event.Entry.Id : null);
throw new InvalidOperationException("Error trying to save {0}. {1}{2}".InvariantFormat(usefulEntityName, cascadeHelperMsg, actionQueueDeletions), ex);
}
}
/// <summary>
/// Performs the save or update.
/// </summary>
/// <param name="evt">The evt.</param>
/// <returns>
/// The id used to save the entity; may be null depending on the
/// type of id generator used and the requiresImmediateIdAccess value
/// </returns>
protected override object PerformSaveOrUpdate(SaveOrUpdateEvent evt)
{
eventListenerHelper.OnModify(evt.Entity);
return base.PerformSaveOrUpdate(evt);
}
/// <summary>
/// Handle the given update event.
/// </summary>
/// <param name="event">The update event to be handled.</param>
public void OnSaveOrUpdate(SaveOrUpdateEvent @event)
{
var entity = @event.Entity as Entity;
if (entity == null)
return;
if (entity.Id == 0)
entity.CreatedOn = CurrentDateTimeProvider();
ExplicitUpdateCall(@event.Entity as Entity);
}
public void OnSaveOrUpdate(SaveOrUpdateEvent @event)
{
ResetReadOnlyEntity(@event.Session, @event.Entity);
}
public void OnSaveOrUpdate(SaveOrUpdateEvent @event)
{
ExplicitUpdateCall(@event.Entity as ITrackModificationDate);
}
public void OnSaveOrUpdate(SaveOrUpdateEvent @event)
{
@event.EntityName = GetEntityName(@event.Entity, @event.EntityName);
}
