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);
 }
Esempio n. 5
0
 protected override Expression <Func <CategoriaEstoque, object> >[] DataAgregation(Expression <Func <CategoriaEstoque, object> >[] includes, FilterBase filter)
 {
     return(base.DataAgregation(includes, filter));
 }
Esempio n. 6
0
 protected override System.Collections.Generic.IEnumerable <TDS> MapperDomainToResult <TDS>(FilterBase filter, PaginateResult <SampleDetail> dataList)
 {
     return(base.MapperDomainToResult <SampleDetailDtoSpecializedResult>(filter, dataList) as IEnumerable <TDS>);
 }
Esempio n. 7
0
 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);
 }
Esempio n. 9
0
 public override Task <IPagedList <TOutput> > FilterAsync <TOutput>(FilterBase filter, CancellationToken cancellationToken = default)
 {
     throw new System.NotImplementedException();
 }
Esempio n. 10
0
 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");
		}
Esempio n. 12
0
 public async Task <IActionResult> Get(FilterBase filterBase)
 {
     return(Ok(await _service.GetAsync(filterBase)));
 }
Esempio n. 13
0
 /// <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));
 }
Esempio n. 14
0
 /// <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));
 }
Esempio n. 17
0
 public virtual ValidationSpecificationResult GetDomainValidation(FilterBase filters = null)
 {
     return(base._validationResult);
 }
Esempio n. 18
0
 public static ILogClient CreateDefaultClient(FilterBase filter)
 {
     return(CreateUnreliableClient(filter));
 }
 public RecipientsListsRepository(FilterBase filter, SpeakExpressionParserBase speakExpressionParser)
 {
     this.filter = filter;
     this.speakExpressionParser = speakExpressionParser;
 }
Esempio n. 20
0
        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());
        }
Esempio n. 21
0
        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);
        }
Esempio n. 22
0
 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));
 }
Esempio n. 24
0
 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));
 }
Esempio n. 27
0
 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);
 }
Esempio n. 30
0
        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
            });
        }
Esempio n. 31
0
        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);
		}
Esempio n. 33
0
        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);
        }
Esempio n. 34
0
 public void Add(FilterBase childFilter)
 {
     Log4JParserC.Log4JFilterAnyAdd (Handle, childFilter.Handle);
 }
Esempio n. 35
0
 protected abstract IQueryable <dynamic> DefineFieldsGetByFilters(IQueryable <T> source, FilterBase filters);
 public UsersInListRepository(FilterBase filter, SpeakExpressionParserBase speakExpressionParser)
 {
     this.filter = filter;
     this.speakExpressionParser = speakExpressionParser;
 }
Esempio n. 37
0
 protected Expression <Func <T, object> >[] DataAgregation(FilterBase filter)
 {
     return(DataAgregation(new Expression <Func <T, object> >[] { }, filter));
 }
Esempio n. 38
0
 protected virtual Expression <Func <T, object> >[] DataAgregation(Expression <Func <T, object> >[] includes, FilterBase filter)
 {
     return(includes);
 }
Esempio n. 39
0
 public void Remove(FilterBase childFilter)
 {
     Log4JParserC.Log4JFilterAnyRemove (Handle, childFilter.Handle);
 }
Esempio n. 40
0
 public FilterNot(FilterBase childFilter)
     : base(Init (childFilter.Handle))
 {
 }