public IList<IProduct> Filter(IList<IProduct> productList, ISpecification specification)
        {
            if (productList == null || specification == null)
                return null;

            return productList.Where(product => specification.IsMatched(product)).ToList();
        }
 public NamedFacetInferred(string value, ISpecification holder)
     : base(value, holder) {
     ShortName = TypeNameUtils.GetShortName(value);
     CapitalizedName = NameUtils.CapitalizeName(ShortName);
     SimpleName = NameUtils.SimpleName(ShortName);
     NaturalName = NameUtils.NaturalName(ShortName);
 }
 public AuthorizationHideForSessionFacet(string roles,
                                         string users,
                                         ISpecification holder)
     : base(holder) {
     this.roles = FacetUtils.SplitOnComma(roles);
     this.users = FacetUtils.SplitOnComma(users);
 }
 public AutoCompleteFacet(MethodInfo autoCompleteMethod, int pageSize, int minLength, ISpecification holder)
     : this(holder) {
     method = autoCompleteMethod;
     PageSize = pageSize == 0 ? DefaultPageSize : pageSize;
     MinLength = minLength;
     methodDelegate = DelegateUtils.CreateDelegate(method);
 }
        private void Process(IReflector reflector, MethodInfo member, ISpecification holder) {
            var allParams = member.GetParameters();
            var paramsWithAttribute = allParams.Where(p => p.GetCustomAttribute<ContributedActionAttribute>() != null).ToArray();
            if (!paramsWithAttribute.Any()) return; //Nothing to do
            var facet = new ContributedActionFacet(holder);
            foreach (ParameterInfo p in paramsWithAttribute) {
                var attribute = p.GetCustomAttribute<ContributedActionAttribute>();
                var type = reflector.LoadSpecification<IObjectSpecImmutable>(p.ParameterType);
                if (type != null) {
                    if (type.IsParseable) {
                        Log.WarnFormat("ContributedAction attribute added to a value parameter type: {0}", member.Name);
                    }
                    else if (type.IsCollection) {
                        var parent = reflector.LoadSpecification(member.DeclaringType);

                        if (parent is IObjectSpecBuilder) {
                            AddLocalCollectionContributedAction(reflector,  p, facet);
                        }
                        else {
                            AddCollectionContributedAction(reflector, member, type, p, facet, attribute);
                        }
                    }
                    else {
                        facet.AddObjectContributee(type, attribute.SubMenu, attribute.Id);
                    }
                }
            }
            FacetUtils.AddFacet(facet);
        }
 public AuthorizationHideForSessionFacet(IIdentifier identifier,
                                         IAuthorizationManager authorizationManager,
                                         ISpecification holder)
     : base(holder) {
     this.identifier = identifier;
     this.authorizationManager = authorizationManager;
 }
Example #7
0
 public static IInteractionBuffer IsValid(ISpecification specification, IInteractionContext ic, IInteractionBuffer buf) {
     IEnumerable<IValidatingInteractionAdvisor> facets = specification.GetFacets().Where(f => f is IValidatingInteractionAdvisor).Cast<IValidatingInteractionAdvisor>();
     foreach (IValidatingInteractionAdvisor advisor in facets) {
         buf.Append(advisor.Invalidates(ic));
     }
     return buf;
 }
 /// <summary>
 /// 
 /// </summary>
 /// <param name="specification"></param>
 /// <param name="item"></param>
 /// <param name="reason"></param>
 public static void IsSatisfiedByFalse(ISpecification<string> specification, string item, string reason)
 {
     Assert.IsNotNull(specification);
     Assert.IsFalse(specification.IsSatisfiedBy(item));
     Assert.AreEqual(specification.ReasonsForDissatisfaction.Count(), 1);
     Assert.AreEqual(specification.ReasonsForDissatisfaction.Single(), reason);
 }
        private static void Process(ISpecification holder) {
            var facets = new List<IFacet>();

            var specImmutable = holder as IMemberSpecImmutable;
            if (specImmutable != null) {
                facets.Add(new NamedFacetInferred(specImmutable.Identifier.MemberName, holder));
                facets.Add(new DescribedAsFacetNone(holder));
            }

            if (holder is IAssociationSpecImmutable) {
                facets.Add(new ImmutableFacetNever(holder));
                facets.Add(new PropertyDefaultFacetNone(holder));
                facets.Add(new PropertyValidateFacetNone(holder));
            }

            var immutable = holder as IOneToOneAssociationSpecImmutable;
            if (immutable != null) {
                facets.Add(new MaxLengthFacetZero(holder));
                DefaultTypicalLength(facets, immutable.ReturnSpec, immutable);
                facets.Add(new MultiLineFacetNone(holder));
            }

            if (holder is IActionSpecImmutable) {
                facets.Add(new ExecutedFacetDefault(holder));
                facets.Add(new ActionDefaultsFacetNone(holder));
                facets.Add(new ActionChoicesFacetNone(holder));
                facets.Add(new PageSizeFacetDefault(holder));
            }

            FacetUtils.AddFacets(facets);
        }
        private SubscriptionClient CreateAndGetSubscriptionInternal(string subscriptionName, ISpecification filterSpecification)
        {
            var filter = new SqlFilter(filterSpecification.Result());
            EnsureSubscriptionNameIsValid(subscriptionName);

            log.Info($"Checking subscription for path {subscriptionName} exists");

            if (!this.namespaceManager.SubscriptionExists(this.topic, subscriptionName))
            {
                log.Info("Creating subscription as it does not currently exist");

                var subscriptionDescription = new SubscriptionDescription(this.topic, subscriptionName)
                {
                    LockDuration = TimeSpan.FromMinutes(5)
                };

                this.namespaceManager.CreateSubscription(subscriptionDescription, filter);

                log.Info("Subscription created");
            }

            log.Info("Creating subscription client");

            var client = SubscriptionClient.CreateFromConnectionString(
                connectionString, this.topic, subscriptionName);

            log.Info("Subscription client created");

            return client;
        }
        /// <summary>
        /// This method will return the list of cells that meet the specification.
        /// <param name="cell"> source cell, whose neighbours need to find </param>
        /// <param name="specification">Actual specification, which need to pass by neighbours.  </param>
        /// <returns>return the cell collection which pass the specification. </returns>
        public ICollection<Cell> FindNeighbourCells(Cell cell, ISpecification<Cell> specification)
        {
            if(cell == null)
                throw new ArgumentNullException("Cell can't be empty");

            List<Cell> cells = new List<Cell>();

            int startRow;
            int startCol;
            int endRow;
            int endCol;

            int colIndex = cell.ColNumber;
            int rowIndex = cell.RowNumber;

            GetValidStartRowAndCol(rowIndex, colIndex, out startRow, out startCol);
            GetValidEndRowAndCol(rowIndex, colIndex, out endRow, out endCol);

            for (int xcoord = startRow; xcoord <= endRow; xcoord++)
            {
                for (int ycoord = startCol; ycoord <= endCol; ycoord++)
                {
                    if (!(xcoord == rowIndex && ycoord == colIndex))
                    {
                        if (specification == null)
                            cells.Add(grid[xcoord, ycoord]);
                        else
                            if (specification.IsSpecificationMeet(grid[xcoord, ycoord]))
                                cells.Add(grid[xcoord, ycoord]);
                    }
                }
            }
            return cells;
        }
 public void Setup()
 {
     spec1 = Substitute.For<ISpecification<string>>();
     spec2 = Substitute.For<ISpecification<string>>();
     spec1.ReasonsForDissatisfaction.Returns(new List<string> { Spec1Dissatisfaction });
     spec2.ReasonsForDissatisfaction.Returns(new List<string> { Spec2Dissatisfaction });
 }
        public void Initialize()
        {
            var fizzSpec = new FizzSpecification();
            var buzzSpec = new BuzzSpecification();

            _fizzBuzzSpec = fizzSpec.And(buzzSpec);
        }
 public IEnumerable<User> AllMatching(ISpecification<User> specification)
 {
     lock (_users)
     {
         return _users.Where(specification.SatisfiedBy());
     }
 }
Example #15
0
 private static IInteractionBuffer IsUsable(ISpecification specification, IInteractionContext ic, IInteractionBuffer buf) {
     IEnumerable<IDisablingInteractionAdvisor> facets = specification.GetFacets().Where(f => f is IDisablingInteractionAdvisor).Cast<IDisablingInteractionAdvisor>();
     foreach (IDisablingInteractionAdvisor advisor in facets) {
         buf.Append(advisor.Disables(ic));
     }
     return buf;
 }
        /// <summary>
        /// Finds the number of neighbours of a given cell that meet the passed in specification.
        /// </summary>
        /// <param name="cell">Cell whose neighbours have to be found.</param>
        /// <param name="specification">The specification that should be met by the neighbouring cells.</param>
        /// <returns>Returns the collection of cells that meet the passed in specification.</returns>
        public ICollection<Cell> FindNeighbours(Cell cell, ISpecification<Cell> specification)
        {
            List<Cell> cells = new List<Cell>();
            if (cell == null)
            {
                throw new ArgumentNullException(paramName:"Cell");
            }

            int column = cell.ColumnNumber;
            int row = cell.RowNumber;
            int startrow;
            int startcol;
            int endcol;
            int endrow;
            GetValidStartRowAndColumn(row, column, out startrow, out startcol);
            GetValidEndRowAndColumn(row, column, out endrow, out endcol);

            for (int xcoord = startrow; xcoord <= endrow; xcoord++)
            {
                for (int ycoord = startcol; ycoord <= endcol; ycoord++)
                {
                    if (!(xcoord == row && ycoord == column))
                    {
                        if (specification == null)
                            cells.Add(grid[xcoord, ycoord]);
                        else
                            if(specification.IsSatisfiedBy(grid[xcoord, ycoord]))
                                cells.Add(grid[xcoord, ycoord]);
                    }
                }
            }
            return cells;
        }
        private void ProcessArray(IReflector reflector, Type type, ISpecification holder) {
            FacetUtils.AddFacet(new ArrayFacet(holder));
            FacetUtils.AddFacet(new TypeOfFacetInferredFromArray(holder));

            var elementType = type.GetElementType();
            reflector.LoadSpecification(elementType);
        }
Example #18
0
 public void DecorateAllHoldersFacets(ISpecification holder) {
     if (facetDecorators.Any()) {
         foreach (Type facetType in holder.FacetTypes) {
             DecorateFacet(facetType, holder);
         }
     }
 }
 public void Subscribe(
     string subscriptionName,
     ISpecification filter,
     Action<IEnumerable<SubscriptionMessage>> messagesReceived)
 {
     this.InitialiseSubscription(subscriptionName, filter, messagesReceived);
 }
Example #20
0
        internal CaseSpecification(List<WhenThenPair> whenThens, ISpecification elseSpecification)
        {
			Platform.CheckForNullReference(whenThens, "whenThens");
			Platform.CheckForNullReference(elseSpecification, "elseSpecification");

            _whenThens = whenThens;
            _else = elseSpecification;
        }
 public RegExFacet(string validation, string format, bool caseSensitive, string message, ISpecification holder)
     : base(typeof (IRegExFacet), holder) {
     validationPattern = validation;
     Pattern = new Regex(validation, PatternFlags);
     formatPattern = format;
     isCaseSensitive = caseSensitive;
     failureMessage = message;
 }
Example #22
0
 public IEnumerable<Product> By(IList<Product> products, ISpecification specification)
 {
     foreach (var product in products)
     {
         if (specification.IsSatisfiedBy(product))
             yield return product;
     }
 }
 private string CreateSpecificationTitle(ISpecification specification)
 {
     string suffix = "Specification";
     string title = specification.Story.Name;
     if (title.EndsWith(suffix))
         title = title.Remove(title.Length - suffix.Length, suffix.Length);
     return title;
 }
        public void IsSatisfiedByReturnsTrueIfBothAreSatisfiedBy()
        {
            _left = SpecificationGenerator.GetSpecification(true);
            _right = SpecificationGenerator.GetSpecification(true);
            var andSpecification = new AndSpecification<object>(_left, _right);

            Assert.True(andSpecification.IsSatisfiedBy(string.Empty));
        }
        public void IsSatisfiedByReturnsFalseIBothArentSatisfied()
        {
            _left = SpecificationGenerator.GetSpecification(false);
            _right = SpecificationGenerator.GetSpecification(false);
            var andSpecification = new AndSpecification<object>(_left, _right);

            Assert.False(andSpecification.IsSatisfiedBy(string.Empty));
        }
 private static void Create(AuthorizeActionAttribute attribute, ISpecification holder) {
     if (attribute != null) {
         if (attribute.Roles != null || attribute.Users != null) {
             FacetUtils.AddFacet(new AuthorizationHideForSessionFacet(attribute.Roles, attribute.Users, holder));
             FacetUtils.AddFacet(new AuthorizationDisableForSessionFacet(attribute.Roles, attribute.Users, holder));
         }
     }
 }
        private static IDataTypeFacet Create(DataTypeAttribute attribute, ISpecification holder) {
            if (attribute == null) {
                return null;
            }

            return attribute.DataType == DataType.Custom ? new DataTypeFacetAnnotation(attribute.CustomDataType, holder) :
                new DataTypeFacetAnnotation(attribute.DataType, holder);
        }
 public JsonReducerController(ISpecification<TvShow> tvShowSpecification)
 {
     if (tvShowSpecification == null)
     {
         throw new ArgumentNullException("tvShowSpecification");
     }
     _tvShowSpecification = tvShowSpecification;
 }
Example #29
0
 public static bool IsVisible(ISpecification specification, IInteractionContext ic, ILifecycleManager lifecycleManager, IMetamodelManager manager) {
     var buf = new InteractionBuffer();
     IEnumerable<IHidingInteractionAdvisor> facets = specification.GetFacets().Where(f => f is IHidingInteractionAdvisor).Cast<IHidingInteractionAdvisor>();
     foreach (IHidingInteractionAdvisor advisor in facets) {
         buf.Append(advisor.Hides(ic, lifecycleManager, manager));
     }
     return IsVisible(buf);
 }
        public void IsSatisfiedByReturnsTrueIfRightIsntSatisfied()
        {
            _left = SpecificationGenerator.GetSpecification(true);
            _right = SpecificationGenerator.GetSpecification(false);
            var orSpecification = new OrSpecification<object>(_left, _right);

            Assert.True(orSpecification.IsSatisfiedBy(string.Empty));
        }
Example #31
0
        public async Task <int> GetTotalCountAsync(ISpecification <Category> specification)
        {
            IQueryable <Category> query = await ApplySpecification(specification);

            return(await query.CountAsync());
        }
        public virtual IEnumerable <TResult> Evaluate <T, TResult>(IEnumerable <T> source, ISpecification <T, TResult> specification)
        {
            _ = specification.Selector ?? throw new SelectorNotFoundException();

            var baseQuery = Evaluate(source, (ISpecification <T>)specification);

            var resultQuery = baseQuery.Select(specification.Selector.Compile());

            return(specification.PostProcessingAction == null
                ? resultQuery
                : specification.PostProcessingAction(resultQuery));
        }
Example #33
0
        public IMessageRoute AddSpecification(ISpecification <string> specification)
        {
            _specifications.Add(specification);

            return(this);
        }
Example #34
0
        private static void Process(MemberInfo member, ISpecification holder)
        {
            var attribute = member.GetCustomAttribute <FindMenuAttribute>();

            FacetUtils.AddFacet(Create(attribute, holder));
        }
Example #35
0
 /// <summary>
 /// Constructs a new instance of <c>AndNotSpecification&lt;T&gt;</c> class.
 /// </summary>
 /// <param name="left">The first specification.</param>
 /// <param name="right">The second specification.</param>
 public AndNotSpecification(ISpecification <T> left, ISpecification <T> right) : base(left, right)
 {
 }
Example #36
0
 public async Task <int> CountAsync(ISpecification <T> spec)
 {
     return(await ApplySpecification(spec).CountAsync());
 }
Example #37
0
        private static ITableViewFacet CreateTableViewFacet(TableViewAttribute attribute, ISpecification holder)
        {
            var columns         = attribute.Columns == null ? new string[] { } : attribute.Columns;
            var distinctColumns = columns.Distinct().ToArray();

            if (columns.Length != distinctColumns.Length)
            {
                // we had duplicates - log
                var duplicates = columns.GroupBy(x => x).Where(g => g.Count() > 1).Select(g => g.Key).Aggregate("", (s, t) => s != "" ? s + ", " + t : t);
                var name       = holder.Identifier == null ? "Unknown" : holder.Identifier.ToString();
                Log.WarnFormat("Table View on {0} had duplicate columns {1}", name, duplicates);
                columns = distinctColumns;
            }

            return(new TableViewFacet(attribute.Title, columns, holder));
        }
Example #38
0
 public async Task <T> GetEntityWithSpec(ISpecification <T> spec)
 {
     return(await ApplySpecification(spec).FirstOrDefaultAsync());
 }
Example #39
0
 public async Task <IReadOnlyList <T> > ListAsync(ISpecification <T> spec)
 {
     return(await ApplySpecification(spec).ToListAsync());
 }
Example #40
0
 public ISpecification <T> Or(ISpecification <T> specification) => new OrSpecification <T>(this, specification);
Example #41
0
 public ISpecification <T> And(ISpecification <T> specification) => new AndSpecification <T>(this, specification);
Example #42
0
 private static ITableViewFacet Create(TableViewAttribute attribute, ISpecification holder)
 {
     return(attribute == null ? null : CreateTableViewFacet(attribute, holder));
 }
 public MemberAccess(ISpecification <object> specification, IMemberAccess access)
 {
     _specification = specification;
     _access        = access;
 }
Example #44
0
 public AndSpecification(ISpecification <TEntity> left, ISpecification <TEntity> right)
     : base(((BaseSpecification <TEntity>)left).Exprs.AndAlso(((BaseSpecification <TEntity>)right).Exprs))
 {
 }
Example #45
0
 /// <summary>
 /// Creates a private class for testing the basic functionality for command handlers which handles commands for system data in the food waste domain.
 /// </summary>
 /// <param name="systemDataRepository">Implementation of the repository which can access system data for the food waste domain.</param>
 /// <param name="foodWasteObjectMapper">Implementation of an object mapper which can map objects in the food waste domain.</param>
 /// <param name="specification">Implementation of a specification which encapsulates validation rules.</param>
 /// <param name="commonValidations">Implementation of the common validations.</param>
 /// <param name="exceptionBuilder">Implementation of the builder which can build exceptions.</param>
 public MyFoodWasteSystemDataCommandHandler(ISystemDataRepository systemDataRepository, IFoodWasteObjectMapper foodWasteObjectMapper, ISpecification specification, ICommonValidations commonValidations, IExceptionBuilder exceptionBuilder)
     : base(systemDataRepository, foodWasteObjectMapper, specification, commonValidations, exceptionBuilder)
 {
 }
Example #46
0
 public NotSpecification(ISpecification <TEntity> other) => _this = other;
 public Serializer(ISpecification <object> specification, ISerializer serializer)
 {
     _specification = specification;
     _serializer    = serializer;
 }
Example #48
0
 protected override TAggregateRoot DoFind(ISpecification <TAggregateRoot> specification)
 {
     return(this.MongoDBRespositoryContext.MongoDatabase.GetCollection <TAggregateRoot>().FindOne(specification.GetExpression()));
 }
 public DescribedAsFacetNone(ISpecification holder)
     : base("", holder)
 {
 }
        /// <summary>
        /// Search for NonStandardHoliday items
        /// </summary>
        /// <param name="currentUser"></param>
        /// <param name="user"></param>
        /// <param name="appID"></param>
        /// <param name="overrideID"></param>
        /// <param name="searchCriteria"></param>
        /// <param name="page"></param>
        /// <param name="pageSize"></param>
        /// <param name="includeInActive"></param>
        /// <param name="specification"></param>
        /// <param name="dataRepository"></param>
        /// <param name="uow"></param>
        /// <returns></returns>
        public NonStandardHolidaySearchVMDC SearchNonStandardHoliday(string currentUser, string user, string appID, string overrideID, NonStandardHolidaySearchCriteriaDC searchCriteria, int page, int pageSize, bool includeInActive,
                                                                     ISpecification <NonStandardHoliday> specification, IRepository <NonStandardHoliday> dataRepository, IUnitOfWork uow)
        {
            try
            {
                #region Parameter validation

                // Validate parameters
                if (string.IsNullOrEmpty(currentUser))
                {
                    throw new ArgumentOutOfRangeException("currentUser");
                }
                if (string.IsNullOrEmpty(user))
                {
                    throw new ArgumentOutOfRangeException("user");
                }
                if (string.IsNullOrEmpty(appID))
                {
                    throw new ArgumentOutOfRangeException("appID");
                }
                if (null == dataRepository)
                {
                    throw new ArgumentOutOfRangeException("dataRepository");
                }
                if (null == specification)
                {
                    throw new ArgumentOutOfRangeException("specification");
                }
                if (null == uow)
                {
                    throw new ArgumentOutOfRangeException("uow");
                }

                #endregion

                using (uow)
                {
                    // Evaluate search criteria if supplied
                    if (null != searchCriteria)
                    {
                        EvaluateNonStandardHolidaySearchCriteria(searchCriteria, ref specification);
                    }

                    if (!includeInActive)
                    {
                        ISpecification <NonStandardHoliday> isActiveSpecification = new Specification <NonStandardHoliday>(x => x.IsActive == true);
                        specification = specification.And(isActiveSpecification);
                    }

                    // Set default sort expression
                    System.Linq.Expressions.Expression <Func <NonStandardHoliday, DateTime> > sortExpression = x => x.Date;

                    //Sort holidays in descending order
                    bool isAscendingSort = false;

                    // Find all items that satisfy the specification created above.
                    IEnumerable <NonStandardHoliday> dataEntities = dataRepository.Find <DateTime>(specification, sortExpression, isAscendingSort, page, pageSize);

                    // Get total count of items for search critera
                    int itemCount = dataRepository.Count(specification);

                    NonStandardHolidaySearchVMDC results = new NonStandardHolidaySearchVMDC();

                    // Convert to data contracts
                    List <NonStandardHolidaySearchMatchDC> destinations = Mapper.Map <IEnumerable <NonStandardHoliday>, List <NonStandardHolidaySearchMatchDC> >(dataEntities);

                    results.MatchList      = destinations;
                    results.SearchCriteria = searchCriteria;
                    results.RecordCount    = itemCount;

                    return(results);
                }
            }
            catch (Exception e)
            {
                //Prevent exception from propogating across the service interface
                ExceptionManager.ShieldException(e);

                return(null);
            }
        }
Example #51
0
        public UserDTO UserLogin(ISpecification <User> ispec)
        {
            var user = iUserManage.FindBy(ispec);

            return(user == null ? null : MapperSupport.MapTo <UserDTO>(user));
        }
 // Partial method for evaluation of NonStandardHoliday search criteria
 partial void EvaluateNonStandardHolidaySearchCriteria(NonStandardHolidaySearchCriteriaDC searchCriteria, ref ISpecification <NonStandardHoliday> specification);
 public NotSpecification(ISpecification <T> wrapped)
 {
     _wrapped = wrapped;
 }
        /// <summary>
        ///
        /// </summary>
        /// <param name="currentUser"></param>
        /// <param name="user"></param>
        /// <param name="appID"></param>
        /// <param name="overrideID"></param>
        /// <param name="includeInActive"></param>
        /// <param name="specification"></param>
        /// <param name="dataRepository"></param>
        /// <param name="uow"></param>
        /// <returns></returns>
        public List <NonStandardHolidayDC> GetAllNonStandardHoliday(string currentUser, string user, string appID, string overrideID, bool includeInActive, ISpecification <NonStandardHoliday> specification, IRepository <NonStandardHoliday> dataRepository, IUnitOfWork uow)
        {
            try
            {
                #region Parameter validation

                // Validate parameters
                if (string.IsNullOrEmpty(currentUser))
                {
                    throw new ArgumentOutOfRangeException("currentUser");
                }
                if (string.IsNullOrEmpty(user))
                {
                    throw new ArgumentOutOfRangeException("user");
                }
                if (string.IsNullOrEmpty(appID))
                {
                    throw new ArgumentOutOfRangeException("appID");
                }
                if (null == dataRepository)
                {
                    throw new ArgumentOutOfRangeException("dataRepository");
                }
                if (null == specification)
                {
                    throw new ArgumentOutOfRangeException("specification");
                }
                if (null == uow)
                {
                    throw new ArgumentOutOfRangeException("uow");
                }

                #endregion

                using (uow)
                {
                    // Build specification
                    if (!includeInActive)
                    {
                        ISpecification <NonStandardHoliday> isActiveSpecification = new Specification <NonStandardHoliday>(x => x.IsActive == true);
                        specification = specification.And(isActiveSpecification);
                    }

                    // Set default sort expression
                    System.Linq.Expressions.Expression <Func <NonStandardHoliday, Object> > sortExpression = x => x.Description;

                    // Find all items that satisfy the specification created above.
                    IEnumerable <NonStandardHoliday> dataEntities = dataRepository.Find(specification, sortExpression);

                    // Convert to data contracts
                    List <NonStandardHolidayDC> destinations = Mapper.Map <IEnumerable <NonStandardHoliday>, List <NonStandardHolidayDC> >(dataEntities);

                    return(destinations);
                }
            }
            catch (Exception e)
            {
                //Prevent exception from propogating across the service interface
                ExceptionManager.ShieldException(e);

                return(null);
            }
        }
Example #55
0
 protected CompositeSpecification(ISpecification <T> leftSide, ISpecification <T> rightSide)
 {
     this.LeftSide  = leftSide;
     this.RightSide = rightSide;
 }
Example #56
0
 private static IFacet Create(FindMenuAttribute attribute, ISpecification holder)
 {
     return(attribute == null ? null : new FindMenuFacet(holder));
 }
 public async Task <int> CountPages(int size, ISpecification <T> spec)
 {
     return((int)Math.Ceiling((await Search(spec)).Count() / (double)size));
 }
 public async Task <IEnumerable <T> > Search(ISpecification <T> spec)
 {
     return((await GetAll()).Where(e => spec.IsSatisfiedBy(e)));
 }
Example #59
0
 private IQueryable <T> ApplySpecification(ISpecification <T> spec)
 {
     return(SpecificationEvaluator <T> .GetQuery(context.Set <T>().AsQueryable(), spec));
 }
Example #60
0
 public T GetSingleBySpec(ISpecification <T> spec)
 {
     return(List(spec).FirstOrDefault());
 }