public static ISpecification<Place> ByAddress(Address address)
        {
            Specification<Place> specification = new TrueSpecification<Place>();

            if (address != null)
            {
                var stspec = new DirectSpecification<Place>(
                    p => p.Address.Street.ToLower().Contains(
                        address.Street.ToLower()
                        )
                    );

                var dtspec = new DirectSpecification<Place>(
                    p => p.Address.District.ToLower().Contains(
                        address.District.ToLower()
                        )
                    );
                var zpspec = new DirectSpecification<Place>(
                    p => p.Address.ZipCode == address.ZipCode
                    );

                specification &= stspec || dtspec || zpspec;
            }

            return specification;
        }

        public void CreateAndSpecificationTest()
        {
            //Arrange
            DirectSpecification<SampleEntity> leftAdHocSpecification;
            DirectSpecification<SampleEntity> rightAdHocSpecification;

            var identifier = Guid.NewGuid();
            Expression<Func<SampleEntity, bool>> leftSpec = s => s.Id == identifier;
            Expression<Func<SampleEntity, bool>> rightSpec = s => s.SampleProperty.Length > 2;

            leftAdHocSpecification = new DirectSpecification<SampleEntity>(leftSpec);
            rightAdHocSpecification = new DirectSpecification<SampleEntity>(rightSpec);

            //Act
            AndSpecification<SampleEntity> composite = new AndSpecification<SampleEntity>(leftAdHocSpecification, rightAdHocSpecification);

            //Assert
            Assert.IsNotNull(composite.SatisfiedBy());
            Assert.ReferenceEquals(leftAdHocSpecification, composite.LeftSideSpecification);
            Assert.ReferenceEquals(rightAdHocSpecification, composite.RightSideSpecification);

            var list = new List<SampleEntity>();
            var sampleA = new SampleEntity() {  SampleProperty = "1" };
            sampleA.ChangeCurrentIdentity(identifier);

            var sampleB = new SampleEntity() { SampleProperty = "the sample property" };
            sampleB.ChangeCurrentIdentity(identifier);

            list.AddRange(new SampleEntity[] { sampleA, sampleB });
            

            var result = list.AsQueryable().Where(composite.SatisfiedBy()).ToList();

            Assert.IsTrue(result.Count == 1);
        }

        public void CreateNotSpecificationFromNegationOperator()
        {
            var spec = new DirectSpecification<SampleEntity>(s=>s.Name==EntityName);

            ISpecification<SampleEntity> notSpec = !spec;

            Assert.IsNotNull(notSpec);
        }

 public ActionResult MyAdList()
 {
     int userId= WebSecurity.GetUserId(User.Identity.Name);
     ISpecification<Advertisement> myAdSpec = new DirectSpecification<Advertisement>(ad => ad.OwnerID == userId );
     var lst = productRepository.GetAdvertisementsList(myAdSpec);
     ViewBag.IsEditable = true;
     return View("AdList",lst);
 }

        public void DirectSpecification_Constructor_NullSpecThrowArgumentNullException_Test()
        {
            //Arrange
            DirectSpecification<TEntity> adHocSpecification;
            Expression<Func<TEntity, bool>> spec = null;

            //Act
            adHocSpecification = new DirectSpecification<TEntity>(spec);
        }

        public void CreateDirectSpecificationNullSpecThrowArgumentNullExceptionTest()
        {
            //Arrange
            DirectSpecification<SampleEntity> adHocSpecification;
            Expression<Func<SampleEntity, bool>> spec = null;

            //Act
            adHocSpecification = new DirectSpecification<SampleEntity>(spec);
        }

        public static Specification<CategoriaProduto> ConsultaCategoriaProduto(string texto)
        {
            Specification<CategoriaProduto> spec = new DirectSpecification<CategoriaProduto>(c => true);

            if (!string.IsNullOrEmpty(texto))
            {
                spec = new DirectSpecification<CategoriaProduto>(c => c.Nome.Contains(texto));
            }

            return spec;
        }

        public static Specification<Usuario> ConsultaEmail(string email)
        {
            if (email != null)
            {
                email = email.Trim();
            }

            Specification<Usuario> spec = new DirectSpecification<Usuario>(c => true);

            return spec;
        }

        public static Specification<Usuario> ConsultaTexto(string texto)
        {
            Specification<Usuario> spec = new DirectSpecification<Usuario>(c => true);

            if (!string.IsNullOrWhiteSpace(texto))
            {
                spec &= new DirectSpecification<Usuario>(c => c.NomeUsuario.ToUpper().Contains(texto.ToUpper()));
            }

            return spec;
        }

        public void CriaAndSpecificationComLambdaRightNullEThrowArgumentNullExceptionTest()
        {
            //Arrange
            CompositeSpecification<ClienteStub> compoSpecification;
            Expression<Func<ClienteStub, bool>> lambda = s => s.Nome != string.Empty;

            DirectSpecification<ClienteStub> direct = new DirectSpecification<ClienteStub>(lambda);

            //Act
            compoSpecification = new AndSpecification<ClienteStub>(direct, null);
        }

        /// <summary>
        /// The orders in a date range
        /// </summary>
        /// <param name="startDate">The start date </param>
        /// <param name="endDate">The end date</param>
        /// <returns>Related specification for this criteria</returns>
        public static ISpecification<Order> OrderFromDateRange(DateTime? startDate, DateTime? endDate)
        {
            Specification<Order> spec = new TrueSpecification<Order>();

            if (startDate.HasValue)
                spec &= new DirectSpecification<Order>(o => o.OrderDate > (startDate ?? DateTime.MinValue));

            if (endDate.HasValue)
                spec &= new DirectSpecification<Order>(o => o.OrderDate < (endDate ?? DateTime.MaxValue));

            return spec;
        }

        public void CreateNewDirectSpecificationTest()
        {
            //Arrange
            DirectSpecification<SampleEntity> adHocSpecification;
            Expression<Func<SampleEntity, bool>> spec = s => s.Id == Guid.NewGuid();

            //Act
            adHocSpecification = new DirectSpecification<SampleEntity>(spec);

            //Assert
            Assert.ReferenceEquals(new PrivateObject(adHocSpecification).GetField("_MatchingCriteria"), spec);
        }

        public void DirectSpecification_Constructor_Test()
        {
            //Arrange
            DirectSpecification<TEntity> adHocSpecification;
            Expression<Func<TEntity,bool>> spec = s => s.Id==0;

            //Act
            adHocSpecification = new DirectSpecification<TEntity>(spec);

            //Assert
            Assert.ReferenceEquals(new PrivateObject(adHocSpecification).GetField("_MatchingCriteria"), spec);
        }

      /// <summary>
      ///    Specification for bank accounts with number like to <paramref name="ibanNumber" />
      /// </summary>
      /// <param name="ibanNumber">The bank account number</param>
      /// <returns>Associated specification</returns>
      public static ISpecification<BankAccount> BankAccountIbanNumber(string ibanNumber)
      {
         Specification<BankAccount> specification = new TrueSpecification<BankAccount>();

         if (!String.IsNullOrWhiteSpace(ibanNumber))
         {
            specification &= new DirectSpecification<BankAccount>(
               (b) => b.Iban.ToLower().Contains(ibanNumber.ToLower()));
         }

         return specification;
      }

        public void Sepcification_OfType_Test()
        {
            //初始化
            var baseSpec = new DirectSpecification<BaseEntity>(be => be.Id == 1);

            //操作
            var inheritSpec = baseSpec.OfType<InheritEntity>();

            //验证
            Assert.IsNotNull(inheritSpec);
            Assert.IsTrue(inheritSpec.SatisfiedBy().Compile()(new InheritEntity() { Id = 1 }));
        }

        public static ISpecification<Place> ByName(string name)
        {
            Specification<Place> specification = new TrueSpecification<Place>();

            if (!string.IsNullOrWhiteSpace(name))
            {
                specification &= new DirectSpecification<Place>(
                    p => p.Name.ToLower().Contains(name.ToLower())
                    );
            }

            return specification;
        }

        /// <summary>
        /// Specification for menu with application code like to <paramref name="text"/>
        /// </summary>
        /// <param name="text">The text to search</param>
        /// <returns>Associated specification for this criterion</returns>
        public static ISpecification<User> UserName(string userName)
        {
            Specification<User> specification = new TrueSpecification<User>();

            if (!string.IsNullOrWhiteSpace(userName))
            {
                var nameSpecification = new DirectSpecification<User>(c => c.UserName.ToLower() == userName.ToLower());

                specification &= nameSpecification;
            }

            return specification;
        }

        public void DirectSpecification_Constructor_Test()
        {
            //Arrange
            DirectSpecification<Entity> adHocSpecification;
            Expression<Func<Entity,bool>> spec = s => s.Id==0;

            //Act
            adHocSpecification = new DirectSpecification<Entity>(spec);

            //Assert
            var expectedValue = adHocSpecification.GetType().GetField("_MatchingCriteria", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(adHocSpecification);
            Assert.AreSame(expectedValue, spec);
        }

        public void CheckNotSpecificationOperators()
        {
            var spec = new DirectSpecification<SampleEntity>(s=>s.Name==EntityName);

            var notSpec = !spec;

            ISpecification<SampleEntity> resultAnd = notSpec && spec;
            ISpecification<SampleEntity> resultOr = notSpec || spec;

            Assert.IsNotNull(notSpec);
            Assert.IsNotNull(resultAnd);
            Assert.IsNotNull(resultOr);
        }

        /// <summary>
        /// Specification for menu with application code like to <paramref name="text"/>
        /// </summary>
        /// <param name="text">The text to search</param>
        /// <returns>Associated specification for this criterion</returns>
        public static ISpecification<Menu> ApplicationCodeFullText(string text)
        {
            Specification<Menu> specification = new TrueSpecification<Menu>();

            if(!String.IsNullOrWhiteSpace(text)) {
                var nameSpecification = new DirectSpecification<Menu>(c => c.ApplicationCode.ToLower().Contains(text));

                specification &= nameSpecification;

            }

            return specification;
        }