public void RemoveUnusedColumns_WithCount_Ensure_AggregateExpressionWithGrouping_Removed( ) { ResourceEntity resNode = new ResourceEntity( ); AggregateEntity aggNode = new AggregateEntity { GroupedEntity = resNode }; aggNode.GroupBy.Add(new ResourceDataColumn( )); SelectColumn col1 = new SelectColumn { Expression = new ResourceDataColumn( ) }; SelectColumn col2 = new SelectColumn { Expression = new AggregateExpression { NodeId = aggNode.NodeId } }; StructuredQuery query = new StructuredQuery( ); query.RootEntity = aggNode; query.SelectColumns.Add(col1); query.SelectColumns.Add(col2); ClientAggregate agg = new ClientAggregate( ); agg.AggregatedColumns.Add(new ReportAggregateField { AggregateMethod = AggregateMethod.Count }); StructuredQuery result = ReportRollupHelper.RemoveUnusedColumns(query, agg); Assert.That(result.SelectColumns.Count, Is.EqualTo(2)); Assert.That(result.SelectColumns [0].Expression, Is.TypeOf <IdExpression>( )); Assert.That(result.SelectColumns [1].Expression, Is.TypeOf <AggregateExpression>( )); }
void Apply(Created e) { entity_ = new AggregateEntity(); AddEntity(entity_); id_ = e.ID; }
public static ProjectedAggregate Project(AggregateEntity aggregate, Layer layer, Matrix4 transform) { var loc = transform.Transform(aggregate.Location); var newOrigin = transform.Transform(Point.Origin); var offset = (Point)loc - (Point)newOrigin; return(new ProjectedAggregate(aggregate, layer, offset, aggregate.Children.Select(c => Project(c, layer, transform)))); }
internal virtual ILexical CreateILexical() { ILexical target = new AggregateEntity( new PersonalPronoun("him"), new ProperSingularNoun("Patrick"), new NounPhrase(new ProperSingularNoun("Brittany")) ); return(target); }
public void AggregateEntityConstructorTest1() { IEntity americans = new NounPhrase(new ProperPluralNoun("Americans")); IEntity canadians = new NounPhrase(new ProperPluralNoun("Canadians")); var target = new AggregateEntity(americans, canadians); Check.That(target).Contains(americans); Check.That(target).Contains(canadians); }
public void JoinedRightTest() { var target = new Conjunction("and"); ILexical expected = new AggregateEntity(new ProperSingularNoun("Jacob"), new ProperSingularNoun("Jessica")); ILexical actual; target.JoinedRight = expected; actual = target.JoinedRight; Check.That(actual).IsEqualTo(expected); }
private async Task Aggregate(TPHEntity reading) { var aggregateTable = new GenericTableStorage(connString, "Aggregates"); var dayEntityTask = aggregateTable.GetSingle <AggregateEntity>(reading.PartitionKey + "D", reading.ReadAt.ToString("yyMMdd")); var hourEntityTask = aggregateTable.GetSingle <AggregateEntity>(reading.PartitionKey + "H", reading.ReadAt.ToString("yyMMddHH")); var monthEntityTask = aggregateTable.GetSingle <AggregateEntity>(reading.PartitionKey + "M", reading.ReadAt.ToString("yyMM")); var dayEntity = await dayEntityTask; if (dayEntity == null) { dayEntity = new AggregateEntity() { PartitionKey = reading.PartitionKey + "D", RowKey = reading.ReadAt.ToString("yyMMdd") }; } var dayRecord = Mapper.Map <AggregateEntity, IAggregateRecord>(dayEntity); UpdateAggregateValues(reading.Temperature, dayRecord.Temperature); UpdateAggregateValues(reading.Pressure, dayRecord.Pressure); UpdateAggregateValues(reading.Humidity, dayRecord.Humidity); await aggregateTable.InsertOrReplaceAsync(Mapper.Map <IAggregateRecord, AggregateEntity>(dayRecord)); var hourEntity = await hourEntityTask; if (hourEntity == null) { hourEntity = new AggregateEntity() { PartitionKey = reading.PartitionKey + "H", RowKey = reading.ReadAt.ToString("yyMMddHH") }; } var hourRecord = Mapper.Map <AggregateEntity, IAggregateRecord>(hourEntity); UpdateAggregateValues(reading.Temperature, hourRecord.Temperature); UpdateAggregateValues(reading.Pressure, hourRecord.Pressure); UpdateAggregateValues(reading.Humidity, hourRecord.Humidity); await aggregateTable.InsertOrReplaceAsync(Mapper.Map <IAggregateRecord, AggregateEntity>(hourRecord)); var monthEntity = await monthEntityTask; if (monthEntity == null) { monthEntity = new AggregateEntity() { PartitionKey = reading.PartitionKey + "M", RowKey = reading.ReadAt.ToString("yyMM") }; } var monthRecord = Mapper.Map <AggregateEntity, IAggregateRecord>(monthEntity); UpdateAggregateValues(reading.Temperature, monthRecord.Temperature); UpdateAggregateValues(reading.Pressure, monthRecord.Pressure); UpdateAggregateValues(reading.Humidity, monthRecord.Humidity); await aggregateTable.InsertOrReplaceAsync(Mapper.Map <IAggregateRecord, AggregateEntity>(monthRecord)); }
public void AggregateEntityConstructorTest() { IEntity[] members = { new NounPhrase(new ProperPluralNoun("Americans")), new NounPhrase(new ProperPluralNoun("Canadians")) }; var target = new AggregateEntity(members); Check.That(target).Contains(members); }
public static bool EquivalentTo(this AggregateEntity agg, Entity entity) { if (entity is AggregateEntity other) { return(agg.Location.CloseTo(other.Location) && agg.Children.Count == other.Children.Count && agg.Children.Zip(other.Children, (a, b) => a.EquivalentTo(b)).All(x => x)); } return(false); }
public void MetaWeightTest() { IEnumerable <IEntity> members = new IEntity[] { }; var target = new AggregateEntity(members); var expected = new Random().NextDouble(); double actual; target.MetaWeight = expected; actual = target.MetaWeight; Check.That(actual).IsEqualTo(expected); }
public void WeightTest() { var members = Empty <IEntity>(); var target = new AggregateEntity(members); var expected = new Random().NextDouble(); double actual; target.Weight = expected; actual = target.Weight; Check.That(actual).IsEqualTo(expected); }
public void AddPossessionTest() { var target = new AggregateEntity( new NounPhrase(new CommonPluralNoun("cats")), new NounPhrase(new CommonPluralNoun("dogs")) ); IPossessable possession = new NounPhrase(new CommonSingularNoun("fur")); target.AddPossession(possession); Check.That(target.Possessions).Contains(possession); }
public void TextTest() { var target = new AggregateEntity( new NounPhrase(new ProperPluralNoun("Americans")), new NounPhrase(new ProperPluralNoun("Canadians")) ); var expected = "Americans ," + " Canadians"; string actual; actual = target.Text; Check.That(actual).IsEqualTo(expected); }
public void ToStringTest() { var target = new AggregateEntity( new NounPhrase(new ProperPluralNoun("Americans")), new NounPhrase(new ProperPluralNoun("Canadians")) ); var expected = "[ 2 ] NounPhrase \"Americans\" NounPhrase \"Canadians\""; string actual; actual = target.ToString(); Check.That(actual).IsEqualTo(expected); }
public void BindDescriptorTest() { var target = new AggregateEntity( new NounPhrase(new ProperPluralNoun("Americans")), new NounPhrase(new ProperPluralNoun("Canadians")) ); IDescriptor descriptor = new Adjective("rambunctious"); target.BindDescriptor(descriptor); Check.That(target.Descriptors).Contains(descriptor); }
public void AggregateIndirectObjectTest() { var target = CreateIInderectObjectTaker(); IAggregateEntity actual = new AggregateEntity(new IEntity[] { new PersonalPronoun("him"), new ProperSingularNoun("Patrick"), new NounPhrase(new ProperSingularNoun("Brittany")) }); actual = target.AggregateIndirectObject; Assert.True(target.AggregateIndirectObject.SequenceEqual(actual)); }
public void PossessorTest() { var target = new AggregateEntity( new NounPhrase(new CommonPluralNoun("cats")), new NounPhrase(new CommonPluralNoun("dogs")) ); IPossessor expected = new NounPhrase(new ProperPluralNoun("Americans")); target.Possessor = expected; var actual = target.Possessor; Check.That(actual).IsEqualTo(expected); }
public void SubjectOfTest() { var target = new AggregateEntity( new NounPhrase(new CommonPluralNoun("cats")), new NounPhrase(new CommonPluralNoun("dogs")) ); IVerbal expected = new BaseVerb("eat"); IVerbal actual; target.BindAsSubjectOf(expected); actual = target.SubjectOf; Check.That(actual).IsEqualTo(expected); }
public void IndirectObjectOfTest() { var target = new AggregateEntity( new CommonSingularNoun("spoon"), new CommonSingularNoun("fork") ); IVerbal expected = new VerbPhrase(new PastTenseVerb("were"), new PastParticiple("eaten")); IVerbal actual; target.BindAsIndirectObjectOf(expected); actual = target.IndirectObjectOf; Check.That(actual).IsEqualTo(expected); }
public void GetEnumeratorTest() { var members = Empty <IEntity>(); var target = new AggregateEntity(members); using (var expected = members.GetEnumerator()) using (var actual = target.GetEnumerator()) { while (expected.MoveNext() | actual.MoveNext()) { Check.That(actual.Current).IsEqualTo(expected.Current); } } }
public void AggregateDirectObjectTest() { var target = new BaseVerb("slay"); IAggregateEntity aggregateObject = new AggregateEntity( new NounPhrase(new ProperSingularNoun("John"), new ProperSingularNoun("Smith")), new NounPhrase(new PossessivePronoun("his"), new CommonPluralNoun("cats")) ); target.BindDirectObject(aggregateObject); var actual = target.AggregateDirectObject; Check.That(actual).ContainsExactly(aggregateObject).And.Not.IsNull().And.Not.IsEmpty(); }
public void AggregateDirectObjectTest() { var target = CreateVerbPhrase(); IAggregateEntity directObject = new AggregateEntity( new NounPhrase(new ProperSingularNoun("John"), new ProperSingularNoun("Smith")), new NounPhrase(new PossessivePronoun("his"), new CommonPluralNoun("cats")) ); target.BindDirectObject(directObject); IAggregateEntity actual; actual = target.AggregateDirectObject; Check.That(directObject.Except(actual)).IsEmpty(); }
public void DirectObjectOfTest() { var target = new AggregateEntity( new NounPhrase(new CommonPluralNoun("cats")), new NounPhrase(new CommonPluralNoun("dogs")) ); var expected = new VerbPhrase(new BaseVerb("eat")); target.BindAsDirectObjectOf(expected); var actual = target.DirectObjectOf; Check.That(actual).IsEqualTo(expected); }
public void Test_WalkNodes_RootAggregate( ) { StructuredQuery sq = new StructuredQuery( ); var agg = new AggregateEntity( ); sq.RootEntity = agg; var related2 = new RelatedResource( ); agg.GroupedEntity = related2; var related3 = new RelatedResource( ); related2.RelatedEntities.Add(related3); AssertNodes(sq, agg, related2, related3); }
public void Test_WalkExpressions_GroupBy(bool filteringOnly, int expected) { StructuredQuery sq = new StructuredQuery( ); AggregateEntity root = new AggregateEntity( ); sq.RootEntity = root; root.GroupedEntity = new ResourceEntity( ); root.GroupBy.Add(new IdExpression( )); root.GroupBy.Add(new MutateExpression { Expression = new IdExpression( ) }); var res = StructuredQueryHelper.WalkExpressions(sq, filteringOnly); Assert.That(res.Count( ), Is.EqualTo(expected)); }
public void BoundPronounsTest() { var target = new AggregateEntity( new NounPhrase(new ProperPluralNoun("Americans")), new NounPhrase(new ProperPluralNoun("Canadians")) ); IEnumerable <IReferencer> actual; IEnumerable <IReferencer> expected = new[] { new PersonalPronoun("them") }; foreach (var r in expected) { target.BindReferencer(r); } actual = target.Referencers; Check.That(actual).Contains(expected); }
public void NotPruned_UnusedRootAggregate( ) { StructuredQuery sq = new StructuredQuery( ); var agg = new AggregateEntity( ); sq.RootEntity = agg; var related2 = new RelatedResource( ); agg.GroupedEntity = related2; var related3 = new RelatedResource( ); related2.RelatedEntities.Add(related3); var pruned = StructuredQueryHelper.PruneQueryTree(sq); Assert.That(pruned, Is.SameAs(sq)); AssertNodes(pruned, agg, related2, related3); }
public void DescriptorsTest() { var target = new AggregateEntity( new NounPhrase(new ProperPluralNoun("Americans")), new NounPhrase(new ProperPluralNoun("Canadians")) ); IEnumerable <IDescriptor> actual; IDescriptor adj1 = new Adjective("western"); IDescriptor adj2 = new Adjective("proud"); target.BindDescriptor(adj1); target.BindDescriptor(adj2); actual = target.Descriptors; Check.That(target.Descriptors).Contains(adj1); Check.That(adj1.Describes).IsEqualTo(target); Check.That(target.Descriptors).Contains(adj2); Check.That(adj2.Describes).IsEqualTo(target); }
public void BindPronounTest() { IEntity[] members = { new NounPhrase(new ProperPluralNoun("Americans")), new NounPhrase(new ProperPluralNoun("Canadians")) }; var target = new AggregateEntity(members); var them = new PersonalPronoun("them"); target.BindReferencer(them); Check.That(target.Referencers).Contains(them); Check.That(them.RefersTo.Contains(target) || them.RefersTo == target || them.RefersTo.SetEqual(target)).IsTrue(); foreach (var member in members) { Assert.True(them.RefersTo.Contains(member) || them.RefersTo == member); } }
public void PossessedTest() { var target = new AggregateEntity( new NounPhrase(new CommonPluralNoun("cats")), new NounPhrase(new CommonPluralNoun("dogs")) ); var possessions = new[] { new NounPhrase(new CommonPluralNoun("claws")), new NounPhrase(new CommonPluralNoun("teeth")) }; foreach (var possession in possessions) { target.AddPossession(possession); } IEnumerable <IPossessable> actual; actual = target.Possessions; Check.That(actual).Contains(possessions); }
/// <summary> /// Cleans the contact info entity. /// </summary> /// <param name="owner">The owner.</param> /// <param name="entity">The entity.</param> public void CleanContactInfoEntity(AggregateEntity owner, ContactDomainEntity entity) { //entity.SetOwner(owner); entity.CleanBeforeSave(); //entity.SetTableLevelAuditItems(owner); }
/// <summary> /// Sets the owner. /// </summary> /// <param name="entity">The entity.</param> public void SetOwner(AggregateEntity entity) { if (entity != null && entity.Guid.EqualsIgnoreCase(Guid.Empty.ToString())) return; Owner = entity; }
/// <summary> /// Sets the table level audit items. /// </summary> /// <param name="owner">The owner.</param> public void SetTableLevelAuditItems(AggregateEntity owner) { var auditDateTime = DateTime.UtcNow; if (IsNew) { CreatedBy = owner.Guid; CreatedByDate = auditDateTime; } LastModifiedBy = owner.Guid; LastModifiedByDate = auditDateTime; }
/// <summary> /// Cleans the before save. /// </summary> public void CleanBeforeSave(AggregateEntity entity) { base.CleanBeforeSave(); if (Tenant == null && entity is ITenantAggregateEntity) { Tenant = ((ITenantAggregateEntity)entity).Tenant; } SetOwner(entity); }