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); }