public IRestRequest Put(string resource, FilterBase filters = null) { var request = CreateRequest(resource, filters); request.Method = Method.PUT; return request; }
public IRestRequest Delete(string resource, FilterBase filters = null) { var request = CreateRequest(resource, filters); request.Method = Method.DELETE; return request; }
private IRestRequest CreateRequest(string resource, FilterBase filters) { var request = new RestRequest(); if (filters != null) { filters.Validate(); foreach (var param in filters.ToDictionary()) { request.AddParameter(param.Key, param.Value); } } request.DateFormat = _options.DateFormat ?? "yyyy-MM-dd HH:mm:ss"; request.Resource = resource; request.RequestFormat = DataFormat.Json; return request; }
public virtual WarningSpecificationResult GetDomainWarning(FilterBase filters = null) { return(this._validationWarning); }
protected override Expression <Func <CategoriaEstoque, object> >[] DataAgregation(Expression <Func <CategoriaEstoque, object> >[] includes, FilterBase filter) { return(base.DataAgregation(includes, filter)); }
protected override System.Collections.Generic.IEnumerable <TDS> MapperDomainToResult <TDS>(FilterBase filter, PaginateResult <SampleDetail> dataList) { return(base.MapperDomainToResult <SampleDetailDtoSpecializedResult>(filter, dataList) as IEnumerable <TDS>); }
public ITransactUpdateItemBuilder <TEntity> WithCondition(FilterBase condition) => new TransactUpdateItemBuilder <TEntity>(new ConditionNode(condition, Node));
protected override IQueryable <dynamic> DefineFieldsGetByFilters(IQueryable <Sample> source, FilterBase filters) { if (filters.QueryOptimizerBehavior == "queryOptimizerBehavior") { return(source.Select(_ => new { })); } return(source); }
public override Task <IPagedList <TOutput> > FilterAsync <TOutput>(FilterBase filter, CancellationToken cancellationToken = default) { throw new System.NotImplementedException(); }
public static ILogClient CreateDefaultClient(FilterBase filter, IChannelManagement manager, IChannelSubscription subscription) { return(CreateUnreliableClient(filter, manager, subscription)); }
protected virtual Command Filter(FilterBase filter) { //Validating if there are filters defined if (filter == null) return null; if (filter is ColumnCompareFilter) return Filter((ColumnCompareFilter)filter); if (filter is CustomFilter) return Filter((CustomFilter)filter); if (filter is InFilter) return Filter((InFilter)filter); if (filter is LikeFilter) return Filter((LikeFilter)filter); if (filter is RangeFilter) return Filter((RangeFilter)filter); if (filter is ValueCompareFilter) return Filter((ValueCompareFilter)filter); if (filter is LogicalOperatorFilter) return Filter((LogicalOperatorFilter)filter); throw new ArgumentOutOfRangeException("filter"); }
public async Task <IActionResult> Get(FilterBase filterBase) { return(Ok(await _service.GetAsync(filterBase))); }
/// <summary> /// Creates a UDP log listener with the given filter /// </summary> /// <param name="manager">Management entpoint</param> /// <param name="subscription">Subscription endpoint</param> /// <param name="filter">Log filter to apply</param> /// <returns></returns> public static ILogClient CreateReliableClient(FilterBase filter, IChannelManagement manager, IChannelSubscription subscription) { return(new SyslogTlsClient(filter, manager, subscription)); }
/// <summary> /// /// </summary> /// <param name="i"></param> /// <param name="f"></param> public FilterStruct(int i, FilterBase f) { index = i; filter = f; }
protected override Expression <Func <FluxoTrabalhoTipo, object> >[] DataAgregation(Expression <Func <FluxoTrabalhoTipo, object> >[] includes, FilterBase filter) { return(base.DataAgregation(includes, filter)); }
protected override Expression <Func <PendenciaDocumento, object> >[] DataAgregation(Expression <Func <PendenciaDocumento, object> >[] includes, FilterBase filter) { return(includes.Add(_ => _.Documento)); }
public virtual ValidationSpecificationResult GetDomainValidation(FilterBase filters = null) { return(base._validationResult); }
public static ILogClient CreateDefaultClient(FilterBase filter) { return(CreateUnreliableClient(filter)); }
public RecipientsListsRepository(FilterBase filter, SpeakExpressionParserBase speakExpressionParser) { this.filter = filter; this.speakExpressionParser = speakExpressionParser; }
public async Task ShouldSearchListItemsAndScrollThroughResults() { // Arrange // --------------------------------------------------------------------------- // Get a list of MetadataSchemaIds // --------------------------------------------------------------------------- var searchRequestSchema = new SchemaSearchRequest { Limit = 2, Filter = FilterBase.FromExpression <Schema>(i => i.Types, SchemaType.List.ToString()) }; var searchResultSchema = await _client.Schema.SearchAsync(searchRequestSchema).ConfigureAwait(false); Assert.True(searchResultSchema.Results.Any()); List <string> metadataSchemaIds = searchResultSchema.Results .Select(i => i.Id) .OrderBy(i => i) .ToList(); var searchRequestObject = new ListItemSearchRequest() { Limit = 100 }; var items = new List <ListItem>(); List <string> failedMetadataSchemaIds = new List <string>(); // Act // --------------------------------------------------------------------------- // Loop over all metadataSchemaIds and make a search for each metadataSchemaId // --------------------------------------------------------------------------- foreach (var metadataSchemaId in metadataSchemaIds) { searchRequestObject.SchemaIds = new List <string> { metadataSchemaId }; searchRequestObject.PageToken = null; try { int i = 0; ListItemSearchResult searchResultObject; do { searchResultObject = await _client.ListItem.SearchAsync(searchRequestObject).ConfigureAwait(false); if (searchResultObject.Results.Any()) { items.AddRange(searchResultObject.Results); } }while (++i < 3 && ((searchRequestObject.PageToken = searchResultObject.PageToken) != null)); } catch (Exception) { failedMetadataSchemaIds.Add(metadataSchemaId); } } // Assert Assert.True(!failedMetadataSchemaIds.Any()); Assert.True(items.Any()); }
internal IQueryable <T> Get(Expression <Func <T, bool> > where = null, Func <IQueryable <T>, IOrderedQueryable <T> > orderBy = null, List <Expression <Func <T, object> > > includeProperties = null, FilterBase <T> filter = null) { IQueryable <T> query = DbSet; if (includeProperties != null) { query = includeProperties.Aggregate(query, (current, includeProperty) => current.Include(includeProperty)); } if (where != null) { query = query.Where(where); } if (orderBy != null) { query = orderBy(query); } if (filter != null) { query = filter.Filter(query); } return(query); }
protected override Expression <Func <Colaborador, object> >[] DataAgregation(Expression <Func <Colaborador, object> >[] includes, FilterBase filter) { return(base.DataAgregation(includes, filter)); }
protected override Expression <Func <ManySampleType, object> >[] DataAgregation(Expression <Func <ManySampleType, object> >[] includes, FilterBase filter) { return(base.DataAgregation(includes, filter)); }
public ExportExcelCustom(FilterBase filter) : base(filter) { }
public static IEnumerable <Point> Filter(this IEnumerable <Point> points, FilterBase filter) { return(filter.Filter(points)); }
protected override Expression <Func <StatusDoUsuario, object> >[] DataAgregation(Expression <Func <StatusDoUsuario, object> >[] includes, FilterBase filter) { return(base.DataAgregation(includes, filter)); }
protected override Expression <Func <Sample, object> >[] DataAgregation(Expression <Func <Sample, object> >[] includes, FilterBase filter) { return(includes.Add(_ => _.CollectionSampleTag, _ => _.CollectionManySampleType)); }
protected override Expression <Func <OrdemServico, object> >[] DataAgregation(Expression <Func <OrdemServico, object> >[] includes, FilterBase filter) { return(base.DataAgregation(includes, filter)); }
public virtual ConfirmEspecificationResult GetDomainConfirm(FilterBase filters = null) { return(this._validationConfirm); }
public virtual async Task <PaginateResult <TResultP> > PagingDataListCustom <TResultP>(FilterBase filters, IQueryable <TResultP> queryOptimize) { var totalCount = await this.CountAsync(queryOptimize); var paginateResult = await this.ToListAsync(this.Paging(queryOptimize, filters, totalCount)); return(new PaginateResult <TResultP> { TotalCount = totalCount, PageSize = filters.PageSize, ResultPaginatedData = paginateResult, Source = queryOptimize }); }
protected override Expression <Func <Pendencia, object> >[] DataAgregation(Expression <Func <Pendencia, object> >[] includes, FilterBase filter) { if (filter.QueryOptimizerBehavior == "Play" || filter.QueryOptimizerBehavior == "Stop" || filter.QueryOptimizerBehavior == "ConcluirPendencia") { return(includes.Add(_ => _.CollectionPendenciaTempos)); } return(includes.Add(_ => _.Projeto)); }
/// <summary> /// Creates the Where Clause for a Select, Update and Delete Sql Sentence /// </summary> /// <param name="filter"> /// Filter to serialize /// </param> /// <returns> /// Where Clause for a Select, Update and Delete Sql Sentence /// </returns> protected virtual Command WhereClause(FilterBase filter) { //Validating if there are filters defined if (filter == null) return null; //Creating filter collection List<FilterBase> filters = new List<FilterBase>(); filters.Add(filter); //Getting the Where clausule return WhereClause(filters, LogicalOperator.And); }
protected override IQueryable <dynamic> DefineFieldsGetByFilters(IQueryable <CategoriaEstoque> source, FilterBase filters) { if (filters.QueryOptimizerBehavior == "queryOptimizerBehavior") { //if (!filters.IsOrderByDomain) //{ // return source.Select(_ => new // { // Id = _.CategoriaEstoqueId // }).OrderBy(_ => _.Id); //} return(source.Select(_ => new { //Id = _.CategoriaEstoqueId })); } //if (!filters.IsOrderByDomain) // return source.OrderBy(_ => _.CategoriaEstoqueId); return(source); }
public void Add(FilterBase childFilter) { Log4JParserC.Log4JFilterAnyAdd (Handle, childFilter.Handle); }
protected abstract IQueryable <dynamic> DefineFieldsGetByFilters(IQueryable <T> source, FilterBase filters);
public UsersInListRepository(FilterBase filter, SpeakExpressionParserBase speakExpressionParser) { this.filter = filter; this.speakExpressionParser = speakExpressionParser; }
protected Expression <Func <T, object> >[] DataAgregation(FilterBase filter) { return(DataAgregation(new Expression <Func <T, object> >[] { }, filter)); }
protected virtual Expression <Func <T, object> >[] DataAgregation(Expression <Func <T, object> >[] includes, FilterBase filter) { return(includes); }
public void Remove(FilterBase childFilter) { Log4JParserC.Log4JFilterAnyRemove (Handle, childFilter.Handle); }
public FilterNot(FilterBase childFilter) : base(Init (childFilter.Handle)) { }