コード例 #1
0
        public void SoftCascadeDelete(ISoftDeletable model)
        {
            var deleteTime = DateTime.UtcNow;

            this.SoftCascadeDelete(model, deleteTime);
            context.SaveChanges();
        }
コード例 #2
0
 public void Delete(ISoftDeletable item, DateTime now, bool saveChanges)
 {
     item.DeletedOn = now;
     item.IsDeleted = true;
     if (saveChanges)
     {
         context.SaveChanges();
     }
 }
コード例 #3
0
        public void Restore(ISoftDeletable entity)
        {
            var entry = ChangeTracker.Entries().First(en => en.Entity == entity);

            if ((bool)entry.Property(nameof(ISoftDeletable.IsDeleted)).CurrentValue == true)
            {
                entry.Property(nameof(ISoftDeletable.IsDeleted)).CurrentValue = false;
            }
        }
コード例 #4
0
        public void HardRemove(ISoftDeletable entity)
        {
            var entry = ChangeTracker.Entries().First(en => en.Entity == entity);

            // a hack to detect hard deleted entities
            entry.CurrentValues[SoftDeleteConstants.DeletedDateProperty] = DateTime.MinValue;

            Remove(entity);
        }
コード例 #5
0
        public void Restore(ISoftDeletable entity)
        {
            var entry = ChangeTracker.Entries().First(en => en.Entity == entity);

            if ((DateTime?)entry.Property(SoftDeleteConstants.DeletedDateProperty).CurrentValue != null)
            {
                entry.Property(SoftDeleteConstants.DeletedDateProperty).CurrentValue = null;
            }
        }
コード例 #6
0
        private void HandleSoftDeletableEntities()
        {
            IEnumerable <DbEntityEntry> entries = ChangeTracker.Entries().Where(x => x.Entity is ISoftDeletable && x.State == EntityState.Deleted);

            foreach (var entry in entries)
            {
                entry.State = EntityState.Modified;
                ISoftDeletable entity = (ISoftDeletable)entry.Entity;
                entity.IsDeleted = true;
            }
        }
コード例 #7
0
ファイル: BaseDA.cs プロジェクト: piCkl3riick/framework-abdh
 /// <summary>
 /// Get Domain by ID
 /// </summary>
 /// <param name="id"></param>
 /// <returns></returns>
 public T GetByID(TIdentifier id)
 {
     using (ConnectionScope.Enter())
     {
         T entity;
         entity = (T)NHibernateSession.Get(persitentType, id);
         ISoftDeletable softDeletable = entity as ISoftDeletable;
         if (softDeletable != null && softDeletable.DeletedDate != null)
         {
             entity = default(T);
         }
         return(entity);
     }
 }
コード例 #8
0
 public virtual void Delete(T obj)
 {
     using (var txn = TransactionScope.Enter())
     {
         ISoftDeletable deletableObj = obj as ISoftDeletable;
         if (obj == null || (deletableObj != null && deletableObj.DeletedDate.HasValue))
         {
             throw new ObjectNotFoundException();
         }
         BeforeDelete(obj);
         _baseDA.Delete(obj);
         txn.Commit();
     }
 }
コード例 #9
0
        public static void UnDelete(this ISoftDeletable entity)
        {
            entity.IsDeleted = false;

            var deletionAuditedEntity = entity as IDeletionTracking;

            if (deletionAuditedEntity == null)
            {
                return;
            }

            deletionAuditedEntity.DeletionDateTime   = null;
            deletionAuditedEntity.DeleterUserId      = null;
            deletionAuditedEntity.DeleterBrowserName = null;
            deletionAuditedEntity.DeleterIp          = null;
        }
コード例 #10
0
ファイル: BaseDA.cs プロジェクト: piCkl3riick/framework-abdh
        /// <summary>
        /// Insert a domain
        /// </summary>
        /// <param name="obj">Domain</param>
        /// <returns></returns>
        public T Insert(T obj)
        {
            using (ConnectionScope.Enter())
            {
                ISoftDeletable softDeletable = obj as ISoftDeletable;
                if (softDeletable != null)
                {
                    softDeletable.CreatedDate  = DateTime.Now;
                    softDeletable.ModifiedDate = DateTime.Now;
                }
                TIdentifier id = (TIdentifier)NHibernateSession.Save(obj);
                obj = GetByID(id);

                return(obj);
            }
        }
コード例 #11
0
        /// <summary>
        /// 检测并执行<see cref="ISoftDeletable"/>接口的逻辑
        /// </summary>
        public static TEntity CheckIDateleTime <TEntity, TKey>(this TEntity entity)
            where TEntity : IEntity
            where TKey : IEquatable <TKey>
        {
            if (!(entity is ISoftDeletable))
            {
                return(entity);
            }
            ISoftDeletable entity1 = (ISoftDeletable)entity;

            if (entity1.DeleteTime == default(DateTime))
            {
                entity1.DeleteTime = DateTime.Now;
            }

            return((TEntity)entity1);
        }
コード例 #12
0
ファイル: BaseDA.cs プロジェクト: piCkl3riick/framework-abdh
 /// <summary>
 /// Update Domain
 /// </summary>
 /// <param name="obj"></param>
 /// <returns></returns>
 public T Update(T obj)
 {
     using (ConnectionScope.Enter())
     {
         if (obj.IsNew)
         {
             throw new DataException("Cannot insert empty key into ID field");
         }
         ISoftDeletable softDeletable = obj as ISoftDeletable;
         if (softDeletable != null)
         {
             softDeletable.ModifiedDate = DateTime.Now;
         }
         NHibernateSession.Update(obj);
         return(obj);
     }
 }
コード例 #13
0
ファイル: Repository.cs プロジェクト: jl632541832/OSharp
 private void DeleteInternal(params TEntity[] entities)
 {
     CheckDataAuth(DataAuthOperation.Delete, entities);
     if (typeof(ISoftDeletable).IsAssignableFrom(typeof(TEntity)))
     {
         // 逻辑删除
         foreach (TEntity entity in entities)
         {
             ISoftDeletable softDeletableEntity = (ISoftDeletable)entity;
             softDeletableEntity.DeletedTime = DateTime.Now;
         }
     }
     else
     {
         // 物理删除
         _dbSet.RemoveRange(entities);
     }
 }
コード例 #14
0
        private void SoftCascadeDelete(ISoftDeletable model, DateTime deleteTime)
        {
            var properties       = model.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
            var wantedProperties = properties
                                   .Where(x =>
                                          x.PropertyType.IsGenericType &&
                                          x.PropertyType.GetGenericTypeDefinition() == typeof(ICollection <>) &&
                                          typeof(ISoftDeletable).IsAssignableFrom(x.PropertyType.GetGenericArguments()[0]))
                                   .ToArray();

            foreach (var prop in wantedProperties)
            {
                ///can not cast even though models are implementing the interface - the problem
                ///might be with differenet intances of the library some assemmbly stuff
                var listOfChildItems = (HashSet <ISoftDeletable>)prop.GetValue(model);

                if (typeof(VideoNote).IsAssignableFrom(prop.PropertyType.GetGenericArguments()[0]))
                {
                    foreach (var item in listOfChildItems)
                    {
                        item.DeletedOn = deleteTime;
                        item.IsDeleted = true;
                    }

                    continue;
                }

                foreach (var childItem in listOfChildItems)
                {
                    SoftCascadeDelete(childItem, deleteTime);
                }
            }

            model.DeletedOn = deleteTime;
            model.IsDeleted = true;
        }
コード例 #15
0
 private void SetDeleted(ISoftDeletable entity)
 {
     entity.SetSoftDeleted(_now.Moment, _currentUserAccessor.User.Login);
 }
コード例 #16
0
 /// <summary>
 /// Returns true if the given object has been soft-deleted; otherwise, returns false
 /// </summary>
 /// <param name="obj"></param>
 /// <returns></returns>
 public static bool HasBeenSoftDeleted(this ISoftDeletable obj)
 {
     return(obj.DeletedUtc != null);
 }
コード例 #17
0
 /// <summary>
 /// Marks the given object as soft-deleted
 /// </summary>
 /// <param name="obj"></param>
 public static void SoftDelete(this ISoftDeletable obj)
 {
     obj.DeletedUtc = DateTime.UtcNow;
 }
コード例 #18
0
        public override int SaveChanges()
        {
            //自动审核
            var nowAuditDate = DateTime.Now;
            var changeSet    = ChangeTracker.Entries <IAuditable>();

            if (changeSet != null)
            {
                foreach (DbEntityEntry <IAuditable> dbEntityEntry in changeSet)
                {
                    switch (dbEntityEntry.State)
                    {
                    case EntityState.Added:
                        dbEntityEntry.Entity.CreatedOn  = nowAuditDate;
                        dbEntityEntry.Entity.ModifiedOn = nowAuditDate;
                        break;

                    case EntityState.Modified:
                        dbEntityEntry.Entity.ModifiedOn = nowAuditDate;
                        break;
                    }
                }
            }
            //乐观并发控制
            foreach (var dbEntityEntry in ChangeTracker.Entries().Where(x => x.State == EntityState.Added || x.State == EntityState.Modified))
            {
                IVersionable entity = dbEntityEntry.Entity as IVersionable;
                if (entity != null)
                {
                    entity.RowVersion = entity.RowVersion + 1;
                }
            }
            //Id自动生成
            foreach (var dbEntityEntry in ChangeTracker.Entries().Where(x => x.State == EntityState.Added))
            {
                IIdentifiable entity = dbEntityEntry.Entity as IIdentifiable;
                if (entity != null)
                {
                    if (entity.Id == Guid.Empty.ToString("N"))
                    {
                        IIdentityGenerator identityGenerator = LocalServiceLocator.GetService <IIdentityGenerator>();
                        if (identityGenerator != null)
                        {
                            entity.Id = (string)identityGenerator.NewId();
                        }
                    }
                }
            }
            //逻辑删除
            foreach (var dbEntityEntry in ChangeTracker.Entries().Where(x => x.State == EntityState.Deleted))
            {
                ISoftDeletable entity = dbEntityEntry.Entity as ISoftDeletable;
                if (entity != null)
                {
                    if (!entity.IsDeleted)
                    {
                        entity.IsDeleted = true;
                    }
                    base.Entry(entity).State = EntityState.Modified;
                }
            }
            return(base.SaveChanges());
        }
コード例 #19
0
 /// <summary>
 /// Marks the given object as no longer soft-deleted
 /// </summary>
 /// <param name="obj"></param>
 public static void SoftRestore(this ISoftDeletable obj)
 {
     obj.DeletedUtc = null;
 }
コード例 #20
0
 public static bool IsNullOrDeleted(this ISoftDeletable entity)
 {
     return(entity == null || entity.IsDeleted);
 }
コード例 #21
0
 /// <summary>
 /// Set soft-delete properties on deletion.
 /// </summary>
 /// <param name="entity">The entity</param>
 /// <param name="now">When the entity was deleted</param>
 /// <param name="currentUserName">The user who deleted the entity</param>
 public static void SetSoftDeleted(this ISoftDeletable entity, DateTime now, string currentUserName)
 {
     entity.IsDeleted = true;
     entity.DeletedOn = now;
     entity.DeletedBy = currentUserName;
 }
コード例 #22
0
        public static bool IsIncludeSoftDeleted(bool?includeSoftDeleted, TEntity entity, out ISoftDeletable softDeletableEntity)
        {
            var result = (!(includeSoftDeleted ?? false) && (entity is ISoftDeletable));

            if (result)
            {
                softDeletableEntity = entity as ISoftDeletable;

                result = result && softDeletableEntity.IsDeleted;
            }
            else
            {
                softDeletableEntity = null;
            }

            return(result);
        }
コード例 #23
0
 public static bool IsDeleted(this ISoftDeletable model)
 {
     return(model.DeletedAt != null);
 }
コード例 #24
0
 public static void MarkAsDeleted(this ISoftDeletable softDeletable)
 {
     softDeletable.IsDeleted = true;
     softDeletable.DeletedDate = DateTimeOffset.Now;
 }