Contribution to Cocktail.Contrib

   Hi,

I have some suggestion about some contribution to add to the Cocktail.Contrib project

In the repository I find the use of the actual FindAsync method "dangerous" because of the use of IPredicateDescription. Having the entity property's name writen as a string can brings errors. If the Entity property's name change in the code but not in the IPredicateDescription the code will compile.
I prefer the use of the expression so if something wrong I know it during the compile time and not during the execution of the application. 

when you use a sandbox for all the entity editing, you find yourself to always import then import back the entities and his graph. Devforce has a still not corrected bug in the ImportEntities method (see the post http://www.ideablade.com/forum/forum_posts.asp?TID=3008&PID=11813&title=importentities-and-nn-relations#11813).
The ImportEntity method below allow to import an entity and his navigation properties (given the 2nd parameters of the method) and does the workaround for the many to many relationship.
I wanted to write another method when the 2nd parameters would be an IList<Entityspan> to be able to have deep graph but I don't have enough knowledge of how to work with the metadata so I gave up (for now).

I hope you will find those methods usefull ...

Repository :
        /// <summary>
        ///   Retrieves one or more entities matching the provided predicate.
        /// </summary>
        /// <param name="predicate"> The predicate to filter the returned list of entities </param>
        /// <param name="sortSelector"> The sort criteria for the returned list of entities. </param>
        /// <param name="includeProperties"> Related entities to eager fetch together with the returned list of entities. </param>
        /// <param name="onSuccess"> Callback to be called when the entity retrieval was successful. </param>
        /// <param name="onFail"> Callback to be called when the entity retrieval failed. </param>
        /// <returns> Asynchronous operation result. </returns>
        public OperationResult<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate,
                                                         ISortSelector sortSelector = null,
                                                         string includeProperties = null,
                                                         Action<IEnumerable<T>> onSuccess = null,
                                                         Action<Exception> onFail = null)
        {
            var query = GetFindQuery(predicate, sortSelector, includeProperties);
            return query.ExecuteAsync().OnComplete(onSuccess, onFail).AsOperationResult();
        }

        /// <summary>
        ///   Returns the query to retrieve a list of entities
        /// </summary>
        /// <param name="predicate"> The predicate used to qualify the list of entities. </param>
        /// <param name="sortSelector"> The sort selector used to sort the list of entities. </param>
        /// <param name="includeProperties"> An optional list of included properties. </param>
        /// <remarks>
        ///   Override to modify the query used to retrieve a list of entities
        /// </remarks>
        protected virtual IEntityQuery<T> GetFindQuery(Expression<Func<T, bool>> predicate,
                                                       ISortSelector sortSelector, string includeProperties)
        {
            IEntityQuery<T> query = EntityManager.GetQuery<T>();
            if (predicate != null)
                query = query.Where(predicate);
            if (sortSelector != null)
                query = query.OrderBySelector(sortSelector);
            if (!string.IsNullOrWhiteSpace(includeProperties))
                query = ParseIncludeProperties(includeProperties)
                    .Aggregate(query, (q, includeProperty) => q.Include(includeProperty));

            return query;
        }

UnitOfwork :
        private static void EnsureEntitiesAreUnmodified(IEnumerable entities)
        {
            if (entities.Cast<IEntity>()
                .Any(e => e.EntityAspect.EntityState != EntityState.Unchanged))
            {
                throw new InvalidOperationException(
                    "Cannot import entities with pending changes");
            }
        }

        public object ImportEntity(object entitySource, string[] entityRelationLinks)
        {
            var entity = EntityAspect.Wrap(entitySource);

            if (entity == null || entity.IsNullOrPendingEntity)
                throw new ArgumentException();

            if (entity.EntityManager == EntityManager)
                return entitySource;

            IEnumerable entitiesToImport = null;

            if (entityRelationLinks != null)
            {
                // Workaround for the many to many import bug
                var entitydest = EntityManager.FindEntity(entity.EntityKey);
                var destinationEntity = EntityAspect.Wrap(entitydest);
                if (destinationEntity != null)
                {
                    destinationEntity.EntityMetadata.ListNavigationProperties.ForEach(listNavigationnProperty =>
                    {
                        if (!listNavigationnProperty.IsCollectionReadOnly && listNavigationnProperty.IsManyToMany && entityRelationLinks.Any(link => link.Equals(listNavigationnProperty.Name)))
                        {
                            var children = listNavigationnProperty.GetValue(entitydest) as IEnumerable<IEntity>;
                            children.ToList().ForEach(ent => listNavigationnProperty.GetEntityReference(entitydest).RemoveEntity(ent, true));
                        }
                    });
                }

                if (entityRelationLinks.Any())
                {
                    var spans = new List<EntitySpan>();
                    entityRelationLinks.ForEach(
                        relationLink =>
                        spans.Add(new EntitySpan(entitySource.GetType(),
                                                 EntityManager.MetadataStore.GetEntityRelation(entitySource.GetType(),
                                                                                               relationLink))));

                    entitiesToImport = entity.EntityManager.FindEntityGraph(new object[] {entitySource}, spans,
                                                                            EntityState.AllButDetached);
                }

            }
            else
                entitiesToImport = new[] { entitySource };

            EnsureEntitiesAreUnmodified(entitiesToImport);
            EntityManager.ImportEntities(entitiesToImport, MergeStrategy.OverwriteChanges);
            var importedEntity = EntityManager.FindEntity(entity.EntityKey);
            return importedEntity;
        }
    }