Example #1
0
        protected override void RelCreationChange(EntityChangeRelCreation item)
        {
            IEnumerable <EntityChangeDescriptor> temp = ChangeLog.Where(p => p.Entity == item.Entity);

            if (temp.Any(p => p is EntityChangeRelCreation == false))
            {
                throw new InvalidOperationException("Unable to schedule a relationship creation for an entity already tracked.");
            }
            if (temp.Any() && temp.Any(p => !p.Equals(item)))
            {
                throw new InvalidOperationException("Unable to schedule a relationship creation. Already tracked for another source-destination pair.");
            }

            if (ChangeLog.Any(p => p is EntityChangeNodeDeletion && p.Entity == item.Source) ||
                item.Source.EntityId == null && !ChangeLog.Any(p => p is EntityChangeNodeCreation && p.Entity == item.Source))
            {
                throw new ArgumentException("Invalid source node");
            }
            if (ChangeLog.Any(p => p is EntityChangeNodeDeletion && p.Entity == item.Destination) ||
                item.Destination.EntityId == null && !ChangeLog.Any(p => p is EntityChangeNodeCreation && p.Entity == item.Destination))
            {
                throw new ArgumentException("Invalid destination node");
            }

            if (!temp.Any())
            {
                ChangeLog.Add(item);
            }
        }
Example #2
0
        private void CreateChangeLog()
        {
            var objectContext = ((IObjectContextAdapter)this).ObjectContext;
            var changeSet     = objectContext.ObjectStateManager.GetObjectStateEntries(EntityState.Modified | EntityState.Added | EntityState.Deleted);

            foreach (ObjectStateEntry objectStateEntry in changeSet)
            {
                BaseDao baseDao = objectStateEntry.Entity as BaseDao;
                if (baseDao == null || baseDao.ChangeLog == null)
                {
                    continue;
                }

                foreach (UnitOfWorkItem unitOfWorkItem in baseDao.ChangeLog)
                {
                    string typeName     = baseDao.GetType().FullName;
                    var    domainObject = DomainObjects.First(d => d.EntityType == typeName);

                    ChangeLog.Add(new ChangeLogDao
                    {
                        Id           = Guid.NewGuid(),
                        DomainObject = domainObject,
                        ObjectId     = baseDao.Id,
                        OldValue     = unitOfWorkItem.OldVaue == null ? null : unitOfWorkItem.OldVaue.ToString(),
                        NewValue     = unitOfWorkItem.NewValue == null ? null : unitOfWorkItem.NewValue.ToString(),
                        Property     = unitOfWorkItem.PropertyName,
                        ChangedAt    = unitOfWorkItem.TimeStamp,
                        ChangedBy    = CurrentUserId,
                        CreatedAt    = unitOfWorkItem.TimeStamp,
                        CreatedBy    = CurrentUserId
                    });
                }
            }
        }
Example #3
0
        protected override void NodeUpdateChange(EntityChangeNodeUpdate item)
        {
            IEnumerable <EntityChangeDescriptor> temp = ChangeLog.Where(p => p.Entity == item.Entity).ToList();

            if (!temp.Any() && item.Entity.EntityId == null)
            {
                throw new InvalidOperationException("Unable to locate entity. It must be tracked or have an EntityId.");
            }

            if (temp.Any(p => p is EntityChangeNodeDeletion))
            {
                throw new InvalidOperationException("Unable to update an entity scheduled for deletion");
            }

            if (temp.Any(p => p is EntityChangeNodeCreation))
            {
                return;
            }

            if (temp.Any(p => p.Inverse != null && p.Inverse.Equals(item)))
            {
                ChangeLog.Remove(item);
            }
            else
            {
                if (temp.Any(p => (p as EntityChangeNodeUpdate)?.Property == item.Property))
                {
                    ChangeLog.RemoveAll(p => temp.Contains(p) && (p as EntityChangeNodeUpdate)?.Property == item.Property);
                }
                ChangeLog.Add(item);
            }
        }
Example #4
0
        protected override void NodeCreationChange(EntityChangeNodeCreation item)
        {
            IEnumerable <EntityChangeDescriptor> temp = ChangeLog.Where(p => p.Entity == item.Entity);

            if (temp.Any(p => p is EntityChangeNodeCreation == false))
            {
                throw new InvalidOperationException("Unable to schedule a node creation for an entity already tracked.");
            }

            if (!temp.Any())
            {
                ChangeLog.Add(item);
            }
        }
Example #5
0
        protected override void ConnectionMergeChange(EntityChangeConnectionMerge item)
        {
            IEnumerable <EntityChangeDescriptor> temp = ChangeLog.Where(p => p.Entity == item.Entity && p is EntityChangeConnectionMerge).ToList();

            ChangeLog.RemoveAll(p =>
                                temp.Contains(p) &&
                                ((p as EntityChangeConnectionMerge).Source != item.Source || (p as EntityChangeConnectionMerge).Destination != item.Destination));

            EntityChangeConnectionMerge existing = temp.FirstOrDefault(p => (p as EntityChangeConnectionMerge).Source == item.Source && (p as EntityChangeConnectionMerge).Destination == item.Destination) as EntityChangeConnectionMerge;

            if (existing == null)
            {
                ChangeLog.Add(item);
            }
            else
            {
                existing.Order = item.Order;
            }
        }
Example #6
0
        protected override void RelDeletionChange(EntityChangeRelDeletion item)
        {
            IEnumerable <EntityChangeDescriptor> temp = ChangeLog.Where(p => p.Entity == item.Entity).ToList();

            if (!temp.Any() && item.Entity.EntityId == null)
            {
                return;
            }

            if (temp.Any(p => p is EntityChangeRelCreation || p is EntityChangeConnectionMerge))
            {
                ChangeLog.RemoveAll(p => temp.Contains(p));
            }
            else
            {
                ChangeLog.RemoveAll(p => temp.Contains(p));
                ChangeLog.Add(item);
            }
        }
 public T this[int index]
 {
     get
     {
         if (index < 0 || index >= _base.Length)
         {
             throw new IndexOutOfRangeException();
         }
         foreach (var item in _changeLog.GetChanges())
         {
             if (item.TryGetValue(index, out T value))
             {
                 return(value);
             }
         }
         return(_base[index]);
     }
     set
     {
         _changeLog.Add(index, value);
     }
 }
Example #8
0
        protected override void NodeDeletionChange(EntityChangeNodeDeletion item)
        {
            IEnumerable <EntityChangeDescriptor> temp = ChangeLog.Where(p => p.Entity == item.Entity).ToList();

            if (!temp.Any() && item.Entity.EntityId == null)
            {
                throw new InvalidOperationException("Unable to locate entity. It must be tracked or have an EntityId.");
            }

            if (temp.Any(p => p is EntityChangeNodeCreation))
            {
                ChangeLog.RemoveAll(p => temp.Contains(p));
            }
            else
            {
                ChangeLog.RemoveAll(p => temp.Contains(p));
                ChangeLog.Add(item);
            }

            foreach (EntityChangeRelCreation rel in ChangeLog.Where(p => p is EntityChangeRelCreation && (((EntityChangeRelCreation)p).Source == item.Entity || ((EntityChangeRelCreation)p).Destination == item.Entity)).ToList())
            {
                RelDeletionChange(new EntityChangeRelDeletion(rel.Entity as IOgmConnection));
            }
        }
Example #9
0
        public int CustomSaveChange()
        {
            var changes = from e in this.ChangeTracker.Entries()
                          where e.State != EntityState.Unchanged
                          select e;

            if (changes.Any())
            {
                var id = HttpContext.Current.User.Identity.GetUserId <int>();
                foreach (var change in changes)
                {
                    var entityName = change.Entity.GetType().Name;
                    if (change.State == EntityState.Added)
                    {
                        base.SaveChanges();
                        EntitySetBase setBase = ((IObjectContextAdapter)this).ObjectContext.ObjectStateManager
                                                .GetObjectStateEntry(change.Entity).EntitySet;
                        string[] keyNames = setBase.ElementType.KeyMembers.Select(k => k.Name).ToArray();
                        string   keyName;
                        if (keyNames != null)
                        {
                            keyName = keyNames.FirstOrDefault();
                        }
                        else
                        {
                            keyName = "(NotFound)";
                        }
                        var item          = change.Entity;
                        var currentValues = this.Entry(item).CurrentValues;
                        foreach (string propertyName in currentValues.PropertyNames)
                        {
                            var current = currentValues[propertyName];
                            if (current != null)
                            {
                                ChangeLog log = new ChangeLog()
                                {
                                    EntityName      = entityName,
                                    PrimaryKeyValue = keyName != "(NotFound)" && this.Entry(item).CurrentValues[keyName] != null?this.Entry(item).CurrentValues[keyName].ToString() : null,
                                                          PropertyName = propertyName,
                                                          NewValue     = current != null?current.ToString() : null,
                                                                             DateChanged  = DateTime.Now,
                                                                             ChangeType   = (int)DbChangeType.Add,
                                                                             CreatedBy    = id,
                                                                             CreationDate = DateTime.Now
                                };
                                ChangeLog.Add(log);
                            }
                        }
                    }
                    else if (change.State == EntityState.Modified)
                    {
                        var primaryKey     = GetPrimaryKeyValue(change);
                        var item           = change.Entity;
                        var originalValues = this.Entry(item).OriginalValues;
                        var currentValues  = this.Entry(item).CurrentValues;
                        foreach (string propertyName in originalValues.PropertyNames)
                        {
                            var original = originalValues[propertyName];
                            var current  = currentValues[propertyName];
                            if (!Equals(original, current))
                            {
                                ChangeLog log = new ChangeLog()
                                {
                                    EntityName                             = entityName,
                                    PrimaryKeyValue                        = primaryKey.ToString(),
                                    PropertyName                           = propertyName,
                                    OldValue                               = original != null?original.ToString() : null,
                                                                  NewValue = current != null?current.ToString() : null,
                                                                                 DateChanged  = DateTime.Now,
                                                                                 ChangeType   = (int)DbChangeType.Edit,
                                                                                 CreatedBy    = id,
                                                                                 CreationDate = DateTime.Now
                                };
                                ChangeLog.Add(log);
                            }
                        }
                    }
                    else if (change.State == EntityState.Deleted)
                    {
                        var primaryKey     = GetPrimaryKeyValue(change);
                        var item           = change.Entity;
                        var originalValues = this.Entry(item).OriginalValues;
                        foreach (string propertyName in originalValues.PropertyNames)
                        {
                            var original = originalValues[propertyName];
                            if (original != null)
                            {
                                ChangeLog log = new ChangeLog()
                                {
                                    EntityName      = entityName,
                                    PrimaryKeyValue = primaryKey != null?primaryKey.ToString() : null,
                                                          PropertyName = propertyName,
                                                          OldValue     = original != null?original.ToString() : null,
                                                                             DateChanged  = DateTime.Now,
                                                                             ChangeType   = (int)DbChangeType.Delete,
                                                                             CreatedBy    = id,
                                                                             CreationDate = DateTime.Now
                                };
                                ChangeLog.Add(log);
                            }
                        }
                    }
                }
            }
            return(base.SaveChanges());
        }