Ejemplo n.º 1
0
        public bool OnPreUpdate(PreUpdateEvent e)
        {
            var auditable = e.Entity as IAuditableEntity;
            if (auditable == null)
                return false;

            var logger = ServiceLocator.TryGetInstance<IAuditableEntityLogger>();
            if (logger != null)
            {
                var changedPropertiesIdx = e.Persister.FindDirty(e.State, e.OldState, e.Entity, e.Session.GetSessionImplementation());
                foreach (var idx in changedPropertiesIdx)
                {
                    var tableName = e.Persister.EntityName;
                    var propertyName = e.Persister.PropertyNames[idx];
                    var oldValue = e.OldState[idx];
                    var newValue = e.State[idx];

                    logger.Log(tableName, propertyName, oldValue, newValue);
                }
            }

            var name = (ApplicationContext.User != null && !string.IsNullOrEmpty(ApplicationContext.User.Identity.Name)) ? ApplicationContext.User.Identity.Name : "Unknown";
            var date = DateTime.UtcNow; 

            Set(e.Persister, e.State, "UpdatedBy", name);
            Set(e.Persister, e.State, "UpdatedAt", date);
            auditable.UpdatedBy = name;
            auditable.UpdatedAt = date;

            return false;
        }
Ejemplo n.º 2
0
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            if (@event.Entity is Log)
                throw new InvalidOperationException("You cannot modify logs, they are immutable!");

            var sb = new StringBuilder("Updating " + @event.Persister.EntityName + " " + @event.Id)
                .AppendLine();
            for (int i = 0; i < @event.OldState.Length; i++)
            {
                if(@event.Persister.PropertyTypes[i]
                    .IsEqual(@event.OldState[i], @event.State[i], @event.Session.EntityMode))
                    continue;

                sb.Append("\t")
                    .Append(@event.Persister.PropertyNames[i])
                    .Append(": ")
                    .Append(@event.OldState[i])
                    .Append(" -> ")
                    .Append(@event.State[i])
                    .AppendLine();
            }

            using(var child = @event.Session.GetSession(EntityMode.Poco))
            {
                child.Save(new Log
                {
                    EntityId = (int) @event.Id,
                    Entity = @event.Persister.EntityName,
                    Changes = sb.ToString()
                });
                child.Flush();
            }

            return false;
        }
Ejemplo n.º 3
0
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            SetAuditFields(@event.Entity as IAuditableEntity, "Update");
            CommitAuditInfo(@event.Persister, @event.State, "EditDate");

            return false;
        }
Ejemplo n.º 4
0
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            var auditable = @event.Entity as IAuditableEntity;
            if (auditable == null)
            {
                return false;
            }

            string userUniqueId = string.Empty;

            var user = ApplicationContext.User;
            if (user != null)
            {
                var identity = ApplicationContext.User.Identity as ICoreIdentity;
                if (identity != null)
                {
                    userUniqueId = identity.Id;
                }
            }

            DateTime updatedAt = DateTime.Now;

            this.Set(@event.Persister, @event.State, "UpdatedBy", userUniqueId);
            this.Set(@event.Persister, @event.State, "UpdatedAt", updatedAt);
            auditable.UpdatedBy = userUniqueId;
            auditable.UpdatedAt = updatedAt;

            return false;
        }
Ejemplo n.º 5
0
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            if (@event.Entity == null || @event.Session.EntityMode != EntityMode.Poco) return false;

            /*simple validation*/
            if (@event.Entity as Person != null)
            {
                var person = (Person) @event.Entity;
                if (person.Partner != null && person.Partner.Id != Guid.Empty)
                    Log.Info("Person does not have a partner");
            }
            if (@event.Entity as Cat != null)
            {
                var cat = (Cat)@event.Entity;
                {
                    Log.Info(string.Format("Cat {0} has Master Id {1}", cat.Name, cat.Master.Id));
                }
            }
            if (@event.Entity as Toy != null)
            {
                var toy = (Toy)@event.Entity;
                {
                    Child xChild;
                    using(var newSession = @event.Session.SessionFactory.OpenSession())
                    {
                         xChild = newSession.Get<Child>(toy.Owner.Id);
                    }
                    Log.Info(string.Format("Toy {0} has Owner {1}", toy.Name,xChild.Name));
                }

            }
            return false;
        }
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            using (var childSession = @event.Session.GetSession(EntityMode.Poco))
            {
                for (var i = 0; i < @event.Persister.PropertyNames.Length; i++)
                {
                    if(@event.Persister.VersionProperty == i)
                        continue;

                    var propName = @event.Persister.PropertyNames[i];
                    IType propertyType = @event.Persister.PropertyTypes[i];
                    var same = propertyType.IsEqual(@event.OldState[i], @event.State[i], EntityMode.Poco);
                    if (same)
                        continue;

                    var changeEvent = new ChangeEvent
                    {
                        EntityName = @event.Persister.EntityName,
                        EntityId = (int)@event.Id,
                        NewValue = (@event.State[i] ?? "null").ToString(),
                        OldValue = (@event.OldState[i] ?? "null").ToString(),
                        PropertyName = propName
                    };
                    childSession.Save(changeEvent);
                }

                childSession.Flush();
            }

            return false;
        }
Ejemplo n.º 7
0
 public bool OnPreUpdate(PreUpdateEvent e)
 {
     var auditable = e.Entity as IAuditable;
     if (auditable == null)
         return false;
     var time = DateTime.UtcNow;
     SetState(e.Persister, e.State, "Updated", time);
     auditable.Updated = time;
     return false;
 }
        public bool OnPreUpdate(PreUpdateEvent updateEvent)
        {
            var rootFinder = updateEvent.Entity as ICanFindMyAggregateRoot;
            if (rootFinder == null)
                return false;

            updateEvent.Session.Lock(rootFinder.MyRoot, LockMode.Force);

            return false;
        }
Ejemplo n.º 9
0
 public bool OnPreUpdate(PreUpdateEvent @event)
 {
     var c = @event.Entity as IAuditInfo;
     if (c == null)
         return false;
     c.UpdatedBy = sUsernameProvider.Username;
     Set(@event.Persister, @event.State, "UpdatedBy", c.UpdatedBy);
     c.UpdatedOn = DateTime.Now;
     Set(@event.Persister, @event.State, "UpdatedOn", c.UpdatedOn);
     return false;
 }
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            var entity = @event.Entity as EntityBase;
            if (entity == null)
                return false;

            entity.IsDeleted = false;
            entity.UpdatedAt = DateTime.Now;
            Set(@event.Persister, @event.State, "UpdatedAt", entity.UpdatedAt);
            return false;
        }
        /// <summary>
        /// 엔티티를 Update 하기 전에, 엔티티의 UpdateTimestamp 속성 값을 현재 시각으로 설정합니다.
        /// </summary>
        /// <param name="event"></param>
        /// <returns></returns>
        public bool OnPreUpdate(PreUpdateEvent @event) {
            if(IsDebugEnabled)
                log.Debug("엔티티에 대해 PreUpdateEvent를 수행합니다...");

            var entity = @event.Entity as IUpdateTimestampedEntity;

            if(entity != null)
                entity.UpdateTimestamp = GetCurrentTime();

            return false;
        }
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            var auditableEntity = @event.Entity as IEntityWithAuditing;
            if (auditableEntity == null)
                return false;
            
            auditableEntity.AuditingInfo.UpdatedBy = "Someone else";
            auditableEntity.AuditingInfo.UpdatedOn = DateTime.Now;
            Set(@event.Persister, @event.State, "AuditingInfo", auditableEntity.AuditingInfo);

            return false;
        }
Ejemplo n.º 13
0
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            var auditable = @event.Entity as IAuditableEntity;
            if (auditable == null)
            {
                return false;
            }

            string userUniqueId = string.Empty;

            var user = ApplicationContext.User;
            if (user != null)
            {
                var identity = ApplicationContext.User.Identity as ICoreIdentity;
                if (identity != null)
                {
                    userUniqueId = identity.Id;
                }
            }

            DateTime updatedAt = DateTime.Now;

            var auditTrailFactory = ServiceLocator.TryGetInstance<IAuditTrailFactory>();
            if (auditTrailFactory != null && auditTrailFactory.IsEntityRegistered(@event.Persister.EntityName))
            {
                string tableName = @event.Persister.EntityName;
                int[] changedPropertiesIdx = @event.Persister.FindDirty(@event.State, @event.OldState, @event.Entity,
                                             @event.Session.GetSessionImplementation());

                Guid changeSetUniqueId = GuidExtensions.NewCombGuid();

                foreach (int idx in changedPropertiesIdx)
                {
                    string propertyName = @event.Persister.PropertyNames[idx];
                    object oldValue = @event.OldState[idx];
                    object newValue = @event.State[idx];

                    IEntityAuditTrail auditTrail = auditTrailFactory.CreateAuditTrail(changeSetUniqueId, tableName, @event.Id.ToString(),
                                                   propertyName, oldValue, newValue,
                                                   userUniqueId,
                                                   updatedAt);

                    @event.Session.Save(auditTrail);
                }
            }

            this._Set(@event.Persister, @event.State, "UpdatedBy", userUniqueId);
            this._Set(@event.Persister, @event.State, "UpdatedAt", updatedAt);
            auditable.UpdatedBy = userUniqueId;
            auditable.UpdatedAt = updatedAt;

            return false;
        }
Ejemplo n.º 14
0
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            IModel owner = @event.Entity as IModel;

            if (owner == null || @event.Session.EntityMode != EntityMode.Poco)
            {
                return false;
            }

            Validate(owner);

            return false;
        }
        /// <summary>
        /// Return true if the operation should be vetoed
        /// </summary>
        /// <param name="event"/>
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            var audit = @event.Entity as Entity;
            if (audit == null)
                return false;

            var time = DateTime.Now;
            Set(@event.Persister, @event.State, "ModifiedOn", time);

            audit.ModifiedOn = time;

            return false;
        }
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            IAuditableModel auditableModel = @event.Entity as IAuditableModel;
            if (auditableModel == null) return false;

            auditableModel.UpdatedBy = System.Threading.Thread.CurrentPrincipal.Identity.Name;
            auditableModel.UpdatedTime = DateTime.Now;

            Set(@event.Persister, @event.State, "UpdatedTime", auditableModel.UpdatedTime);
            Set(@event.Persister, @event.State, "UpdatedBy", auditableModel.UpdatedBy);

            return false;
        }
Ejemplo n.º 17
0
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            var timestamped = (@event.Entity as ITimestamped);
            if (!isValidEntity(timestamped)) return false;

            if (timestamped.Timestamp == null)
                timestamped.Timestamp = new Timestamp();
            timestamped.Timestamp.Modify();

            updateState(@event.Persister, @event.State, "Timestamp", timestamped.Timestamp);

            return false;
        }
Ejemplo n.º 18
0
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            var editedEntity = @event.Entity as IAuditableEntity;
            if (editedEntity == null)
                return false;

            var datAndtime = DateTime.UtcNow;

            PersistAuditInfo(@event.Persister, @event.State, "EditDate", datAndtime);

            editedEntity.EditDate = datAndtime;

            return false;
        }
Ejemplo n.º 19
0
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            var entity = @event.Entity as Entity;

            if (entity == null)
            {
                return false;
            }

            Set(@event.Persister, @event.State, @"UpdatedBy", _actor);

            entity.UpdatedBy = _actor;

            return false;
        }
        /// <inheritdoc/>
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            var audit = @event.Entity as IAuditEntity;
            if (audit == null)
                return false;

            var time = DateTime.Now;

            Set(@event.Persister, @event.State, "Updated", time);
            Set(@event.Persister, @event.State, "UpdatedBy", CurrentUser);

            audit.Updated = time;
            audit.UpdatedBy = CurrentUser;

            return false;
        }
Ejemplo n.º 21
0
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            GetAuditProperties(@event.Entity);
             if (_auditProperties.IsEmpty()) return false;
             try {
            var sessionID = new Guid(ConfigurationManager.AppSettings["SessionID"]);
            var sessionSerice = Locator.Resolve<ISessionService>();
            var user = sessionSerice.GetUserAccount(sessionID);
            SetAuditProperties(@event, @event.Persister, @event.State, user, DateTime.Now);

            return false;
             }
             catch (Exception) {
            return false;
             }
        }
Ejemplo n.º 22
0
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            var baseEntity = @event.Entity as BaseEntity;
            if (baseEntity != null)
            {
                baseEntity.LastEditor = "Leoli_Update_Event";
                baseEntity.LastTime = DateTime.Now;

                this.Set(@event.Persister, @event.State, "LastEditor", baseEntity.LastEditor);
                this.Set(@event.Persister, @event.State, "LastTime", baseEntity.LastTime);
                //or
                //@event.State.SetValue("Leoli_Update_Event", Array.IndexOf(@event.Persister.PropertyNames, "LastEditor"));
                //@event.State.SetValue(baseEntity.LastTime, Array.IndexOf(@event.Persister.PropertyNames, "LastTime"));
            }
            return false;
        }
        /// <summary>
        /// Return true if the operation should be vetoed
        /// </summary>
        /// <param name="event"/>
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            var entity = @event.Entity as ICreatedAndUpdatedProperty;

            if (entity == null)
                return false;

            var time = DateTime.Now;

            Set(@event.Persister, @event.State, "Updated", time);

            entity.Updated = time;

            if (entity.Created == DateTime.MinValue) entity.Created = time;

            return false;
        }
Ejemplo n.º 24
0
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            var entity = @event.Entity as Entity;
            if (entity == null)
                return false;

            DateTime time = DateTime.Now;
            string name = GetUserId();

            Set(@event.Persister, @event.State, "UpdatedAt", time);
            Set(@event.Persister, @event.State, "UpdatedBy", name);

            entity.UpdatedAt = time;
            entity.UpdatedBy = name;

            return false;
        }
Ejemplo n.º 25
0
        public bool OnPreUpdate(PreUpdateEvent preUpdateEvent)
        {
            var audit = preUpdateEvent.Entity as IAuditable;
            if (audit == null)
                return false;

            var time = DateTime.UtcNow;
            var userid = CurrentUserId();

            Set(preUpdateEvent.Persister, preUpdateEvent.State, "ModifiedOnUtc", time);
            Set(preUpdateEvent.Persister, preUpdateEvent.State, "ModifiedBy", userid);

            preUpdateEvent.Entity.GetType().GetMethod("ChangeModifiedBy", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(preUpdateEvent.Entity, new object[] { userid });
            preUpdateEvent.Entity.GetType().GetMethod("ChangeModifiedOnUtc", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(preUpdateEvent.Entity, new object[] { time });

            return false;
        }
Ejemplo n.º 26
0
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            var audit = @event.Entity as IHaveAuditInformation;
            if (audit == null)
                return false;

            var time = DateTime.Now;
            var name = WindowsIdentity.GetCurrent().Name;

            Set(@event.Persister, @event.State, "ModifyDate", time);
            Set(@event.Persister, @event.State, "ModifyUser", name);

            audit.ModifyDate = time;
            audit.ModifyUser = name;

            return false;
        }
        public bool OnPreUpdate(PreUpdateEvent eventItem)
        {
            Trip trip = eventItem.Entity as Trip;
            if (null == trip)
            {
                return false;
            }

            if (ViolatesTripConstraint(eventItem.Session, trip.Observer.StaffCode, trip.TripNumber, trip.Id))
            {
                throw new Exception("Trip with this staff code/trip number already exists.");
            }

            // Mess with Departure/Return dates?

            return false;
        }
        public bool OnPreUpdate(PreUpdateEvent @event)
        {
            var audit = @event.Entity as IHaveAuditInformation;
            if (audit == null)
                return false;

            var time = DateTime.Now;
            var user = GetUser();

            Set(@event.Persister, @event.State, "UpdatedAt", time);
            Set(@event.Persister, @event.State, "UpdatedBy", user);

            audit.UpdatedAt = time;
            audit.UpdatedBy = user;

            return false;
        }
Ejemplo n.º 29
0
        public bool OnPreUpdate(PreUpdateEvent e)
        {
            if(e.Entity is DomainEntity)
            {
                if(e.OldState==null)
                    throw new AuditException();

                var dirtyFieldIndexes = e.Persister.FindDirty(e.State, e.OldState, e.Entity, e.Session);

                if(dirtyFieldIndexes.Length>0)
                {
                    var entity = e.Entity as DomainEntity;
                    entity.LastUpdatedAt = DateTime.UtcNow;

                    var changeLogs = new List<AuditChangeLog>();
                    if (e.Entity.GetType().GetInterface(typeof(IAuditable).Name) != null)
                    {
                        foreach (var dirtyFieldIndex in dirtyFieldIndexes)
                        {
                            if (e.OldState[dirtyFieldIndex] == e.State[dirtyFieldIndex]) continue;
                            
                            //insert audit changelog here
                            var changeLog = new AuditChangeLog
                                                {
                                                    EntityType = e.Entity.GetType().Name,
                                                    EntityIdentifier = entity.Id.ToString(),
                                                    ActionType = AuditType.Update,
                                                    PropertyName = e.Persister.PropertyNames[dirtyFieldIndex]
                                                };

                            changeLog.OldPropertyValue = GetPropertyValue(e.OldState[dirtyFieldIndex], changeLog.PropertyName, entity);
                            changeLog.NewPropertyValue = GetPropertyValue(e.State[dirtyFieldIndex], changeLog.PropertyName, entity);

                            changeLogs.Add(changeLog); 
                        }

                        IStatelessSession session = e.Session.SessionFactory.OpenStatelessSession();
                        changeLogs.ForEach(log=>session.Insert(log));
                        session.Close();
                    } 
                }

            }

            return false;
        }
Ejemplo n.º 30
0
        public bool OnPreUpdate(PreUpdateEvent event_item)
        {
            var audit = event_item.Entity as IAuditable;
            if (audit == null)
            {
                return false;
            }

            DateTime? modifiedDate = DateTime.Now; 
            string userIdentity = GetIdentityName();

            store(event_item.Persister, event_item.State, "ModifiedDate", modifiedDate);
            store(event_item.Persister, event_item.State, "ModifiedByUser", userIdentity);
            audit.ModifiedDate = modifiedDate;
            audit.ModifiedByUser = userIdentity;

            return false;
        }