public static IQueryable <T> Filter <T>(this IQueryable <T> query, EntityFilter filter)
{
if (filter is null)
{
return(query);
}
if (query is null)
{
throw new ArgumentNullException(nameof(query));
}
var builder = new LinqExpressionBuilder();
builder.Build(filter);
var predicate = builder.Expression;
var parameters = builder.Parameters.ToArray();
// nothing to filter
if (string.IsNullOrWhiteSpace(predicate))
{
return(query);
}
return(query.Where(predicate, parameters));
}
protected void Awake()
{
FilterRules weaponHolderFilterRules = FilterRulesBuilder.SetupHasTagBuilder("WeaponDisplay")
.AddHasComponentRule <Weapon>(true).Result();
_weaponHolderFilter = EntityFilter.Create(weaponHolderFilterRules, OnEntityTracked, OnEntityUntracked);
}
protected void Awake()
{
_entityFilter = EntityFilter <CommercialFilterData> .Create(OnTracked, OnUntracked);
_building1 = new Building(50);
_building2 = new Building(75);
}
public bool ImportEntities(
string projectId = "your-project-id",
string inputUrl = "gs://datastore-admin-bucket/data_to_import",
string kind = "Task",
string namespaceId = "default")
{
// Create client
DatastoreAdminClient datastoreAdminClient = DatastoreAdminClient.Create();
IDictionary <string, string> labels = new Dictionary <string, string> {
{ "cloud_datastore_samples", "true" },
};
EntityFilter entityFilter = new EntityFilter()
{
Kinds = { kind },
NamespaceIds = { namespaceId }
};
Operation <Empty, ImportEntitiesMetadata> response = datastoreAdminClient.ImportEntities(projectId, labels, inputUrl, entityFilter);
// Poll until the returned long-running operation is complete
Operation <Empty, ImportEntitiesMetadata> completedResponse = response.PollUntilCompleted();
if (completedResponse.IsFaulted)
{
Console.WriteLine($"Error while Importing Entities: {completedResponse.Exception}");
throw completedResponse.Exception;
}
Console.WriteLine($"Entities imported successfully.");
return(completedResponse.IsCompleted);
}
public void OrderByDescendingSuccessfully()
{
// Arrange
const int max = 30;
var filterRules = new OrderByFilterRules()
{
Take = 5, Orderby = "Created"
};
var entities = Enumerable.Range(1, max)
.Select(value => new UserProjectEntity
{
Created = DateTime.MinValue + TimeSpan.FromDays(value),
Name = value.ToString(CultureInfo.InvariantCulture)
})
.ToList();
IFilter filter = new EntityFilter(_lambdaCreator);
// Act
var result = filter.FilterWithOrder(entities, filterRules);
string firstElementName = result.First().Name;
// Assert
Assert.AreEqual(max.ToString(), firstElementName);
}
public void TakeLastElementSuccessfully()
{
// Arrange
const string expectedName = "Expected";
var filterRules = new OrderByFilterRules()
{
Skip = 2,
Take = 1
};
var entities = new List <UserProfileEntity>
{
new UserProfileEntity(),
new UserProfileEntity(),
new UserProfileEntity {
UserName = expectedName
}
};
IFilter filter = new EntityFilter(_lambdaCreator);
// Act
var result = filter.FilterWithOrder(entities, filterRules);
// Assert
Assert.AreEqual(1, result.Count);
Assert.AreEqual(expectedName, result[0].UserName);
}
public void FilterByContainsSuccessfully()
{
// Arrange
const int max = 30;
var contains = new ContainsFilterRules {
MemberName = "Description", MemberValue = max.ToString(CultureInfo.InvariantCulture)
};
var entities = Enumerable.Range(1, max)
.Select(value => new UserProjectEntity
{
Created = DateTime.MaxValue - TimeSpan.FromDays(value),
Name = value.ToString(CultureInfo.InvariantCulture),
Description = (value > 4 && value < 10)
? max.ToString(CultureInfo.InvariantCulture)
: "Other description"
})
.ToList();
IFilter filter = new EntityFilter(_lambdaCreator);
// Act
var result = filter.FilterWithContains(entities, contains);
string firstElementName = result.First().Name;
// Assert
Assert.IsTrue(result.All(project => project.Description == max.ToString()));
Assert.AreEqual("5", firstElementName);
Assert.AreEqual(5, result.Count);
}
public bool MergeDWG(string SourcePath, EntityFilter filter = null)
{
if (File.Exists(SourcePath))
{
BlockHelper TargetSpace = BlockMgr.ModelSpace; //目标DWG模型空间
TargetSpace.StartTransaction(); //开启事务
using (Database SourceDB = new Database(false, false))
{
SourceDB.ReadDwgFile(SourcePath, FileShare.Read, false, null);
BlockTableRecord SourceBtr = SourceDB.CurrentSpaceId.GetObject(OpenMode.ForRead) as BlockTableRecord;//来源DWG模型空间
foreach (ObjectId ObjId in SourceBtr)
{
Entity ent = ObjId.GetObject(OpenMode.ForRead) as Entity;
if (filter == null || filter.Check(ent))
{
TargetSpace.CloneEntity(ent);
}
}
}
TargetSpace.CommitTransaction();//提交事务
return(true);
}
else
{
Logger.log("MergeDWG", "DWG文件不存在");
}
return(false);
}
public void TakeLastElementSuccessfully()
{
// Arrange
const string expectedName = "Expected";
var filterRules = new OrderByFilterRules()
{
Skip = 2,
Take = 1
};
var entities = new List<UserProfileEntity>
{
new UserProfileEntity(),
new UserProfileEntity(),
new UserProfileEntity{UserName = expectedName}
};
IFilter filter = new EntityFilter(_lambdaCreator);
// Act
var result = filter.FilterWithOrder(entities, filterRules);
// Assert
Assert.AreEqual(1, result.Count);
Assert.AreEqual(expectedName, result[0].UserName);
}
public async Task EntitySelectQueryDeleteNested()
{
var mediator = ServiceProvider.GetService <IMediator>();
mediator.Should().NotBeNull();
var mapper = ServiceProvider.GetService <IMapper>();
mapper.Should().NotBeNull();
var filter = new EntityFilter
{
Filters = new List <EntityFilter>
{
new EntityFilter {
Name = "IsDeleted", Value = true
},
new EntityFilter {
Name = "StatusId", Value = StatusConstants.NotStarted.Id
}
}
};
var select = new EntitySelect(filter);
var selectQuery = new EntitySelectQuery <TaskReadModel>(MockPrincipal.Default, select);
var selectResult = await mediator.Send(selectQuery).ConfigureAwait(false);
selectResult.Should().NotBeNull();
}
protected override void Init(IServiceCollection services)
{
_filter = CreateFilter(new EntityFilterConfiguration().With <RectTransform>());
_transform = GetReadOnly <RectTransform>();
_renderQueue = services.Get <BoundingBoxRenderQueue>();
}
public async Task <IActionResult> GetAllAddressByAgent(CancellationToken cancellationToken, int productId)
{
var returnResponse = new EntityResponseListModel <ProductImageReadDto>();
try
{
var filter = new EntityFilter()
{
Filters = new List <EntityFilter>()
{
new EntityFilter()
{
Name = "ProductId",
Operator = EntityFilterOperators.Equal,
Value = productId
},
}
};
var query = new EntityListQuery <EntityResponseListModel <ProductImageReadDto> >(filter);
var result = await Mediator.Send(query, cancellationToken).ConfigureAwait(false);
if (result.ReturnStatus == false)
{
return(BadRequest(result));
}
return(Ok(result));
}
catch (Exception ex)
{
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
return(BadRequest(returnResponse));
}
}
private void AddQueryFilter(List <EntityFilter> filters)
{
if (Query.IsNullOrWhiteSpace())
{
return;
}
var value = Query.Trim();
var textFilter = new EntityFilter
{
Logic = EntityFilterLogic.Or,
Filters = new[]
{
new EntityFilter
{
Name = nameof(TopicReadModel.Title),
Value = value,
Operator = EntityFilterOperators.Contains
},
new EntityFilter
{
Name = nameof(TopicReadModel.Description),
Value = value,
Operator = EntityFilterOperators.Contains
}
}
};
filters.Add(textFilter);
}
protected override EntityFilter CreateFilter()
{
var filter = new EntityFilter
{
Logic = EntityFilterLogic.Or,
Filters = new[]
{
new EntityFilter
{
Name = nameof(InstructorReadModel.GivenName),
Value = Query,
Operator = EntityFilterOperators.Contains
},
new EntityFilter
{
Name = nameof(InstructorReadModel.FamilyName),
Value = Query,
Operator = EntityFilterOperators.Contains
},
new EntityFilter
{
Name = nameof(InstructorReadModel.EmailAddress),
Value = Query,
Operator = EntityFilterOperators.Contains
}
}
};
return(filter);
}
public void FilterLogicalOr()
{
var entityFilter = new EntityFilter
{
Logic = "or",
Filters = new List <EntityFilter>
{
new EntityFilter {
Name = "Rank", Value = 7
},
new EntityFilter {
Name = "Name", Value = "Apple"
}
}
};
var builder = new LinqExpressionBuilder();
builder.Build(entityFilter);
builder.Expression.Should().NotBeEmpty();
builder.Expression.Should().Be("(Rank == @0 or Name == @1)");
builder.Parameters.Count.Should().Be(2);
builder.Parameters[0].Should().Be(7);
builder.Parameters[1].Should().Be("Apple");
}
private void Awake()
{
var camera = Camera.main;
minZValue = Mathf.CeilToInt(camera.transform.position.z + camera.nearClipPlane + DISTANCE_TO_CAMERA);
entityFilter = GetComponent <EntityFilter>();
}
public void FilterLogicalAnd()
{
var entityFilter = new EntityFilter
{
Filters = new List <EntityFilter>
{
new EntityFilter {
Name = "Rank", Value = 7
},
new EntityFilter {
Name = "Name", Value = "Blueberry"
}
}
};
var builder = new LinqExpressionBuilder();
builder.Build(entityFilter);
builder.Expression.Should().NotBeEmpty();
builder.Expression.Should().Be("(Rank == @0 and Name == @1)");
builder.Parameters.Count.Should().Be(2);
builder.Parameters[0].Should().Be(7);
builder.Parameters[1].Should().Be("Blueberry");
}
internal ICollection <T> Get <T>(EntityFilter filter) where T : Entity
{
// The returned entity type is determined by
// 1) the filter passed in or 2) the type of T if there is no filter.
var targetEntityType = filter != null ? filter.EntityType : typeof(T);
var type = ResolveAssetType(targetEntityType);
var query = new Query(type);
if (filter != null)
{
var defaultToken = GetDefaultOrderByToken(targetEntityType);
IAttributeDefinition defaultOrderBy = null;
if (defaultToken != null)
{
defaultOrderBy = instance.MetaModel.GetAttributeDefinition(defaultToken);
}
query.Filter = filter.BuildFilter(type, instance);
query.Find = filter.BuildFind(type);
query.OrderBy = filter.BuildOrderBy(type, defaultOrderBy);
query.Selection = filter.BuildSelection(type);
}
return(instance.QueryToEntityEnum <T>(query));
}
protected override void Init(IServiceCollection services)
{
_filter = CreateFilter(new EntityFilterConfiguration().With <RectTransform>().With <AnimateTranslation>());
_transform = GetMutable <RectTransform>();
_animation = GetMutable <AnimateTranslation>();
}
public async Task <UsageDataTableResult> GetExceptions(Guid telemetryKey, TelemetryItemTypes itemType, int skip
, int take, IEnumerable <Tuple <string, bool> > sortBy, ISearch requestSearch
, List <string> searchableColumns)
{
Program program = await this.portalContext.Programs.FirstOrDefaultAsync(x => x.TelemetryKey == telemetryKey).ConfigureAwait(false);
if (program == null)
{
throw new ArgumentException($"Program with key {telemetryKey} does not exist");
}
IQueryable <ExceptionInfo> query = this.telemetryContext.Exceptions.Where(x => x.ProgramId == program.Id);
int totalCount = await this.telemetryContext.Exceptions.CountAsync(x => x.ProgramId == program.Id).ConfigureAwait(false);
if (take == -1)
{
take = totalCount;
}
IQueryable <ExceptionInfo> filteredQuery = EntityFilter.Match(query
, property => property.Contains(requestSearch.Value)
, new List <Expression <Func <ExceptionInfo, string> > >()
{
{ x => x.Sequence },
{ x => x.Message },
{ x => x.TypeName },
{ x => x.ProgramVersion },
{ x => x.ParsedStack },
{ x => x.UserName },
});
List <ExceptionInfo> ordered = await ApplyOrderingQuery(sortBy, filteredQuery, skip, take).ConfigureAwait(false);
List <ExceptionData> result = new List <ExceptionData>();
foreach (ExceptionInfo exception in ordered)
{
ExceptionData data = new ExceptionData
{
Timestamp = exception.Timestamp
, UserName = exception.UserName
, EntryKey = exception.TypeName
, Note = exception.Note
, ProgramVersion = exception.ProgramVersion
, Sequence = exception.Sequence
, ErrorMessage = exception.Message
, StackTrace = GetStackTrace(exception.ParsedStack)
, Properties = exception.TelemetryUnits.Where(x => x.UnitType == TelemetryUnit.UnitTypes.Property).ToDictionary(x => x.Key, x => x.ValueString)
, Metrics = exception.TelemetryUnits.Where(x => x.UnitType == TelemetryUnit.UnitTypes.Metric).ToDictionary(x => x.Key, x => x.ValueDouble)
};
result.Add(data);
}
return(new UsageDataTableResult {
TotalCount = totalCount, FilteredCount = totalCount, UsageData = result
});
}
/// <summary>Snippet for ImportEntities</summary>
public void ImportEntities()
{
// Snippet: ImportEntities(string, IDictionary<string,string>, string, EntityFilter, CallSettings)
// Create client
DatastoreAdminClient datastoreAdminClient = DatastoreAdminClient.Create();
// Initialize request argument(s)
string projectId = "";
IDictionary <string, string> labels = new Dictionary <string, string> {
{ "", "" },
};
string inputUrl = "";
EntityFilter entityFilter = new EntityFilter();
// Make the request
Operation <Empty, ImportEntitiesMetadata> response = datastoreAdminClient.ImportEntities(projectId, labels, inputUrl, entityFilter);
// Poll until the returned long-running operation is complete
Operation <Empty, ImportEntitiesMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <Empty, ImportEntitiesMetadata> retrievedResponse = datastoreAdminClient.PollOnceImportEntities(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Empty retrievedResult = retrievedResponse.Result;
}
// End snippet
}
/// <summary>
/// Returns a <see cref="string" /> that represents this instance.
/// </summary>
/// <returns>A <see cref="string" /> that represents this instance.</returns>
public override string ToString()
{
var sb = new StringBuilder();
sb.Append(" EntityName: ");
sb.AppendLine(EntityName);
sb.Append(" EntitySubscription: ");
sb.AppendLine(EntitySubscriptionName ?? "[NOT SET]");
sb.Append(" EntityFilter: ");
sb.AppendLine(EntityFilter.IsNullOrDefault() || !EntityFilter.HasValue ? "[NOT SET]" : string.Format(EntityFilter.Value.Key, EntityFilter.Value.Value, "{0}/{1}"));
sb.Append(" CreateEntityIfNotExists: ");
sb.AppendLine(CreateEntityIfNotExists.ToString(CultureInfo.InvariantCulture));
sb.Append(" ReadFromErrorQueue: ");
sb.AppendLine(ReadFromErrorQueue.ToString(CultureInfo.InvariantCulture));
sb.Append(" SupportStringBodyType: ");
sb.AppendLine(SupportStringBodyType.ToString(CultureInfo.InvariantCulture));
sb.Append(" LockRenewalTimeInSeconds: ");
sb.AppendLine(LockRenewalTimeInSeconds.ToString(CultureInfo.InvariantCulture));
sb.Append(" LockTimeThreshold: ");
sb.AppendLine(LockRenewalTimeThreshold.ToString(CultureInfo.InvariantCulture));
sb.Append(" PollFrequencyInSeconds: ");
sb.Append(PollFrequencyInSeconds.ToString(CultureInfo.InvariantCulture));
return(sb.ToString());
}
protected override EntityFilter CreateFilter()
{
var filters = new List <EntityFilter>
{
new EntityFilter
{
Name = nameof(NotificationReadModel.UserName),
Value = User.Identity.Name,
Operator = EntityFilterOperators.Equal
}
};
var filter = new EntityFilter
{
Logic = EntityFilterLogic.And,
Filters = filters
};
if (string.IsNullOrWhiteSpace(Query))
{
return(filter);
}
filters.Add(new EntityFilter
{
Name = nameof(NotificationReadModel.Message),
Value = Query,
Operator = EntityFilterOperators.Contains
});
return(filter);
}
public void ReturnResultEvenIfRangeIsBiggerThanLength()
{
// Arrange
const int max = 15;
const int skip = 10;
var filterRules = new OrderByFilterRules()
{
Take = 10, Orderby = "Created", Skip = skip
};
var entities = Enumerable.Range(1, max)
.Select(value => new UserProjectEntity
{
Created = DateTime.MinValue + TimeSpan.FromDays(value),
Name = value.ToString(CultureInfo.InvariantCulture)
})
.ToList();
IFilter filter = new EntityFilter(_lambdaCreator);
// Act
var result = filter.FilterWithOrder(entities, filterRules);
// Assert
Assert.AreEqual(5, result.Count);
}
protected override EntityFilter CreateFilter()
{
var filter = new EntityFilter
{
Logic = EntityFilterLogic.Or,
Filters = new[]
{
new EntityFilter
{
Name = nameof(LocationReadModel.Name),
Value = Query,
Operator = EntityFilterOperators.Contains
},
new EntityFilter
{
Name = nameof(LocationReadModel.Description),
Value = Query,
Operator = EntityFilterOperators.Contains
},
new EntityFilter
{
Name = nameof(LocationReadModel.City),
Value = Query,
Operator = EntityFilterOperators.Contains
}
}
};
return(filter);
}
private void ButtonNewFilter_Click(object sender, RoutedEventArgs e)
{
var newFilter = new EntityFilter();
EntityFilterList.EntityFilters.Add(newFilter);
EntityFilterList.SelectedFilterIndex = EntityFilterList.EntityFilters.IndexOf(newFilter);
}
private void ApplyEntityFilter()
{
if (EntityFilter.Any())
{
RetrieveMultipleFuncs.Add((s, q) =>
{
var qe = q as QueryExpression;
if (qe == null)
{
return(s.RetrieveMultiple(q));
}
foreach (var entityGroup in EntityFilter)
{
var idLogicalName = EntityHelper.GetIdAttributeName(entityGroup.Key);
foreach (var filter in qe.GetEntityFilters(entityGroup.Key))
{
filter.AddConditionEnforceAndFilterOperator(new ConditionExpression(idLogicalName, ConditionOperator.In, entityGroup.Value.Select(i => (object)i).ToArray()));
}
}
return(s.RetrieveMultiple(q));
});
}
}
protected override void Init(IServiceCollection services)
{
_filter = CreateFilter(new EntityFilterConfiguration().With <CameraComponent>().With <Transform3D>());
//_camera = GetMutable<CameraComponent>();
_transform = GetMutable <Transform3D>();
_window = services.Get <GameWindow>();
}
public override void FigureCheckState()
{
if (this.filter == null)
{
this.filter = new EntityFilter();
this.filter.triggerPlayers = true;
}
}
/// <summary>
/// Adds a condition to all RetrieveMultiple calls that constrains the results to only the entities with ids given for entities with their logical name in the entityIds collection.
/// Entities of a Type other than the given logicalName will not be constrainted
/// </summary>
/// <param name="logicalName">Entity Logical Name.</param>
/// <param name="ids">The entity ids.</param>
/// <returns></returns>
public TDerived WithEntityFilter(string logicalName, IEnumerable <Guid> ids)
{
foreach (var id in ids)
{
EntityFilter.AddOrAppend(logicalName, id);
}
return(This);
}
public ConveyorLikeMachine(ModCreateSegmentEntityParameters parameters)
: base(parameters)
{
outputLocation = new RelativeLocation(this, Vector3.forward);
inputLocation = new RelativeLocation(this, Vector3.back);
SetAnimationState(AnimateStill());
}
public void Return0ElementsIfTakeIsLesserThan1()
{
// Arrange
var invalidFilter = new OrderByFilterRules() {Take = -1};
var entities = Enumerable.Range(1, 30)
.Select(_ => new UserProjectEntity())
.ToList();
IFilter entityFilter = new EntityFilter(_lambdaCreator);
// Act
var res = entityFilter.FilterWithOrder(entities, invalidFilter);
Assert.AreEqual(0, res.Count);
}
public void OrderByDescendingSuccessfully()
{
// Arrange
const int max = 30;
var filterRules = new OrderByFilterRules() {Take = 5, Orderby = "Created"};
var entities = Enumerable.Range(1, max)
.Select(value => new UserProjectEntity
{
Created = DateTime.MinValue + TimeSpan.FromDays(value),
Name = value.ToString(CultureInfo.InvariantCulture)
})
.ToList();
IFilter filter = new EntityFilter(_lambdaCreator);
// Act
var result = filter.FilterWithOrder(entities, filterRules);
string firstElementName = result.First().Name;
// Assert
Assert.AreEqual(max.ToString(), firstElementName);
}
public void FilterWithEqualsSuccessfully()
{
// Arrange
const string propertyName = "IntProp";
var equals = new EqualsFilterRules<int>{MemberName = propertyName, MemberValue = 2};
var entities = Enumerable.Range(1, 2).SelectMany(i => Enumerable.Repeat(new LambdaCreatorShould.Poco { IntProp = i }, 10)).ToList();
var lambdaCreator = new LambdaCreator();
IFilter entityFilter = new EntityFilter(lambdaCreator);
// Act
List<LambdaCreatorShould.Poco> res = entityFilter.FilterWithEquals(entities, @equals);
// Assert
Assert.AreEqual(10, res.Count);
Assert.IsTrue(res.All(elem => elem.IntProp == 2));
}
public void ReturnResultEvenIfRangeIsBiggerThanLength()
{
// Arrange
const int max = 15;
const int skip = 10;
var filterRules = new OrderByFilterRules() { Take = 10, Orderby = "Created", Skip = skip};
var entities = Enumerable.Range(1, max)
.Select(value => new UserProjectEntity
{
Created = DateTime.MinValue + TimeSpan.FromDays(value),
Name = value.ToString(CultureInfo.InvariantCulture)
})
.ToList();
IFilter filter = new EntityFilter(_lambdaCreator);
// Act
var result = filter.FilterWithOrder(entities, filterRules);
// Assert
Assert.AreEqual(5, result.Count);
}
public void ApplyFilter(EntityFilter filter)
{
_filters.Add(filter);
filter.FilterEntities(_globalStorage);
}
public void ParseObjectExpressionsSuccessfully()
{
var rules = new ContainsFilterRules {MemberName = "value", MemberValue = "10"};
var entities = Enumerable.Range(1, 10).Select(i => new {id = i, value = "lala" + i.ToString(CultureInfo.InvariantCulture)}).ToList();
var lamdaCreator = new LambdaCreator();
var filter = new EntityFilter(lamdaCreator);
var res = filter.FilterWithContains(entities, rules);
Assert.AreEqual(1, res.Count);
Assert.AreEqual(10, res[0].id);
}
public void DisableFilter(EntityFilter filter)
{
_filters.Remove(filter);
filter.Clear();
}
public void FilterByContainsSuccessfully()
{
// Arrange
const int max = 30;
var contains = new ContainsFilterRules {MemberName = "Description", MemberValue = max.ToString(CultureInfo.InvariantCulture)};
var entities = Enumerable.Range(1, max)
.Select(value => new UserProjectEntity
{
Created = DateTime.MaxValue - TimeSpan.FromDays(value),
Name = value.ToString(CultureInfo.InvariantCulture),
Description = (value > 4 && value < 10)
? max.ToString(CultureInfo.InvariantCulture)
: "Other description"
})
.ToList();
IFilter filter = new EntityFilter(_lambdaCreator);
// Act
var result = filter.FilterWithContains(entities, contains);
string firstElementName = result.First().Name;
// Assert
Assert.IsTrue(result.All(project => project.Description == max.ToString()));
Assert.AreEqual("5", firstElementName);
Assert.AreEqual(5, result.Count);
}
