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; }
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()); } }
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); }
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); }
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; }
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; }
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)); }
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)); }
public IMessageRoute AddSpecification(ISpecification <string> specification) { _specifications.Add(specification); return(this); }
private static void Process(MemberInfo member, ISpecification holder) { var attribute = member.GetCustomAttribute <FindMenuAttribute>(); FacetUtils.AddFacet(Create(attribute, holder)); }
/// <summary> /// Constructs a new instance of <c>AndNotSpecification<T></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) { }
public async Task <int> CountAsync(ISpecification <T> spec) { return(await ApplySpecification(spec).CountAsync()); }
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)); }
public async Task <T> GetEntityWithSpec(ISpecification <T> spec) { return(await ApplySpecification(spec).FirstOrDefaultAsync()); }
public async Task <IReadOnlyList <T> > ListAsync(ISpecification <T> spec) { return(await ApplySpecification(spec).ToListAsync()); }
public ISpecification <T> Or(ISpecification <T> specification) => new OrSpecification <T>(this, specification);
public ISpecification <T> And(ISpecification <T> specification) => new AndSpecification <T>(this, specification);
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; }
public AndSpecification(ISpecification <TEntity> left, ISpecification <TEntity> right) : base(((BaseSpecification <TEntity>)left).Exprs.AndAlso(((BaseSpecification <TEntity>)right).Exprs)) { }
/// <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) { }
public NotSpecification(ISpecification <TEntity> other) => _this = other;
public Serializer(ISpecification <object> specification, ISerializer serializer) { _specification = specification; _serializer = serializer; }
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); } }
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); } }
protected CompositeSpecification(ISpecification <T> leftSide, ISpecification <T> rightSide) { this.LeftSide = leftSide; this.RightSide = rightSide; }
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))); }
private IQueryable <T> ApplySpecification(ISpecification <T> spec) { return(SpecificationEvaluator <T> .GetQuery(context.Set <T>().AsQueryable(), spec)); }
public T GetSingleBySpec(ISpecification <T> spec) { return(List(spec).FirstOrDefault()); }