/// <summary>
        /// Implements AfterGetRelGroupsChildren to filters out inactive entities
        /// </summary>
        /// <param name="args">The source entities</param>
        partial void AfterGetRelGroupsChildren(global::IdeaBlade.EntityModel.v4.GetterArgs<global::IdeaBlade.EntityModel.v4.RelatedEntityList<RelGroup>> args)
        {
            if (args != null && args.Value != null)
            {

                // BaseEntity.IsActive is a generic delegate predicate
                List<RelGroup> filteredList = args.Value.Where<RelGroup>(BaseEntity.IsActive<RelGroup>).ToList<RelGroup>();
                ListEntityReference<RelGroup> refList = args.Value.ListReference;

                IdeaBlade.EntityModel.v4.RelatedEntityList<RelGroup> newRelatedList = new RelatedEntityList<RelGroup>(filteredList, refList);
                args.Value = newRelatedList;
            }
        }

 

If you are trying to implement this yourself right now, do you have any outstanding issues or problems that you would like to share with us? 

 

a.  Confirm that the documentation (with the exception of the pm_Fetching event) is up to date:

 

b.  Helps DevForce Classic developers who are having coding problems with the pm_Fetching event.

 

Here is the problematic code from one customer's implementation:

 

 

On page 415 of Developers Guide, there are some sample codes for an approach for soft delete, but seems like they are a bit dated (for classic DevForce perhaps).

Not sure if my event handler OnEntityManagerFetched works, but not sure if my OnEntityManagerFetching below matches what the old example is doing?

 

        private static EntityManager m_EntityManager = DomainModelEntityManager.DefaultManager;

        // constructor
        public ConcreteEntity()
        {
            InitializeEm();
        }

        private void InitializeEm()
        {
            m_EntityManager.Fetching += new EventHandler<EntityFetchingEventArgs>(OnEntityManagerFetching);
            m_EntityManager.Fetched += new EventHandler<EntityFetchedEventArgs>(OnEntityManagerFetched);
        }

        private static void OnEntityManagerFetching(object sender, EntityFetchingEventArgs e)
        {
            IEntityQuery q = e.Query;

            if (q.QueryableType == typeof(ConcreteEntity))
            {
                DomainModel.DomainModelEntityManager dm = new DomainModelEntityManager();
                EntityQuery<ConcreteEntity> eq = dm.ConcreteEntities.Where(ce => ce.Status == (int)BaseEntity.EntityStatus.Active);
                QueryCache qc = new QueryCache();
                qc.Add(eq);
                q.AddToQueryCache(qc);
            }
        }

        private static void OnEntityManagerFetched(object sender, EntityFetchedEventArgs e)
        {
            List<Entity> removeList = new List<Entity>();
            foreach (Entity ent in e.Result)
            {
                BaseEntity baseEnt = ent as BaseEntity; // BaseEntity is a base class for ConcreteEntity
                if (baseEnt != null)
                {
                    if (baseEnt.GetEntityStatus() != BaseEntity.EntityStatus.Active)
                    {
                        removeList.Add(ent);
                    }
                }
            }

            m_EntityManager.RemoveEntities<Entity>(removeList, false);
        }

 

Thanks in advance

-Sebastian