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))
{
}
