public async Task CreateEntityAsync(string type, Guid id, Guid revision, Guid?author, string label, DateTime created, bool isProtected, IEnumerable <EntityFieldValue> fieldValues)
{
StoredEntity entity = new StoredEntity()
{
Type = type,
Id = id,
Revision = revision,
Author = author,
Label = label,
Created = created,
IsProtected = isProtected
};
await entityCollection.InsertOneAsync(entity);
IEnumerable <StoredEntityFieldValue> storedFieldValues = fieldValues
.Select(x => new StoredEntityFieldValue()
{
Revision = revision,
Name = x.Field.Name,
Value = x.Value
});
await fieldValueCollection.InsertManyAsync(storedFieldValues);
}
public async Task <IEnumerable <T> > LoadEntitiesAsync <T>(IEnumerable <Guid> ids, IEnumerable <EntityField> fields, IEnumerable <EntityField> nestedFields) where T : IEntity
{
List <T> result = new List <T>();
IEnumerable <string> fieldNames = fields.Select(x => x.Name);
foreach (Guid id in ids)
{
List <StoredEntity> storedEntities = await entityCollection.FindAsync(x => x.Id == id).Result.ToListAsync();
StoredEntity first = storedEntities.First();
T entity = Activator.CreateInstance <T>();
entity.GrantInitializeEntityDelegate(this);
List <EntityFieldValue> fieldValues = new List <EntityFieldValue>();
foreach (EntityField field in fields)
{
List <StoredEntityFieldValue> storedFieldValues = await fieldValueCollection.FindAsync(x => x.Revision == first.Revision && x.Name == field.Name).Result.ToListAsync();
if (storedFieldValues.Count > 0)
{
fieldValues.Add(new EntityFieldValue(field, field.Property, storedFieldValues.First().Value));
}
}
initializeEntityDelegate.Invoke(first.Id, first.Revision, first.Author, first.Created, first.Updated, fieldValues);
result.Add(entity);
}
return(result);
}
public void FindMultipleMatchingEntities()
{
var mockRepository = new MockRepository(MockBehavior.Strict);
var id1 = Guid.NewGuid();
var id2 = Guid.NewGuid();
var storedEntities = new StoredEntity[]
{
new StoredEntity()
{
EntityId = id1, Type = ""
},
new StoredEntity()
{
EntityId = id2, Type = ""
}
};
var eventStream = mockRepository.Create <IEventStream <TrackedEntityTestClass> >();
eventStream.Setup(x => x.Find("Property", "Value")).Returns(storedEntities);
var entityFactory = mockRepository.Create <ITrackedEntityFactory <TrackedEntityTestClass> >();
entityFactory.Setup(x => x.Create(id1, "")).Returns(new TrackedEntityTestClass(id1));
entityFactory.Setup(x => x.Create(id2, "")).Returns(new TrackedEntityTestClass(id2));
var repository = new Repository <TrackedEntityTestClass>(eventStream.Object, entityFactory.Object);
var entity = repository.Find("Property", "Value");
entity.Should().HaveCount(2);
mockRepository.Verify();
}
public Task Update(T item)
{
var storedEntity = new StoredEntity <T>
{
Id = KeyProvider.KeyProvider(item),
Entity = item
};
return(Client.UpsertDocumentAsync(DocumentCollectionUri, storedEntity));
}
public void Add(Guid entityId, string type, IEnumerable <Event> events)
{
var entity = new StoredEntity()
{
EntityId = entityId,
Type = type,
CurrentVersion = 0
};
entity.Events.AddRange(events);
_Entities.Add(entityId, entity);
}
public void Add(Guid entityId, string type, IDictionary <string, string> properties, IEnumerable <Event> events)
{
var entity = new StoredEntity()
{
EntityId = entityId,
Type = type,
CurrentVersion = 0
};
foreach (var item in properties)
{
entity.Properties.Add(item.Key, item.Value);
}
entity.Events.AddRange(events);
_Entities.Add(entityId, entity);
}
/// <inheritdoc />
public async Task SetEntityAsync(TKey key, TValue entity, Func <TKey, TValue, TValue> updateIfPresent, CancellationToken token)
{
Assert.IsNotNull(key);
Assert.IsNotNull(object.Equals(entity, default(TValue)));
Assert.IsNotNull(updateIfPresent);
var currentTime = DateTime.UtcNow;
var wrappedValue = new StoredEntity <TValue>(currentTime)
{
LastTouchedTimeUtc = currentTime, Entity = entity
};
long?sizeDelta = null;
// Set the entity value
await this.SetEntityInternalAsync(
this.defaultCollection,
key,
wrappedValue,
(k, v) =>
{
// Grab Old size
var beforeUpdateSize = v.GetSize();
// Update the value
v.Entity = updateIfPresent(k, v.Entity);
v.LastTouchedTimeUtc = DateTime.UtcNow;
// Calculate Delta
sizeDelta = v.GetSize() - beforeUpdateSize;
return(v);
},
token);
using (var tx = this.stateManager.CreateTransaction())
{
await
FabricClientRetryHelper.ExecuteFabricActionWithRetryAsync(
() => this.metadataMetricsCollection.AddOrUpdateAsync(tx, TotalStoredSizeInBytesKey, 0, (k, oldSize) => sizeDelta.HasValue ? oldSize + sizeDelta.Value : wrappedValue.GetSize() + Encoding.Unicode.GetByteCount(key.ToString())),
token).ConfigureAwait(false);
await tx.CommitAsync().ConfigureAwait(false);
}
}
public void GetAll()
{
var mockRepository = new MockRepository(MockBehavior.Strict);
var id1 = Guid.NewGuid();
var id2 = Guid.NewGuid();
var id3 = Guid.NewGuid();
var storedEntities = new StoredEntity[]
{
new StoredEntity()
{
EntityId = id1, Type = ""
},
new StoredEntity()
{
EntityId = id2, Type = ""
},
new StoredEntity()
{
EntityId = id3, Type = ""
}
};
var eventStream = mockRepository.Create <IEventStream <TrackedEntityTestClass> >();
eventStream.Setup(x => x.GetAll()).Returns(storedEntities);
var entityFactory = mockRepository.Create <ITrackedEntityFactory <TrackedEntityTestClass> >();
entityFactory.Setup(x => x.Create(id1, "")).Returns(new TrackedEntityTestClass(id1));
entityFactory.Setup(x => x.Create(id2, "")).Returns(new TrackedEntityTestClass(id2));
entityFactory.Setup(x => x.Create(id3, "")).Returns(new TrackedEntityTestClass(id3));
var repository = new Repository <TrackedEntityTestClass>(eventStream.Object, entityFactory.Object);
var entities = repository.All();
entities.Should().BeEquivalentTo(new object[] { new { Id = id1 }, new { Id = id2 }, new { Id = id3 } });
mockRepository.Verify();
}
public void Add(Guid entityId, string type, IDictionary <string, string> properties, IEnumerable <Event> events)
{
var entity = new StoredEntity()
{
EntityId = entityId,
Type = type
};
if (properties != null)
{
foreach (var item in properties)
{
entity.Properties.Add(item.Key, item.Value);
}
}
entity.Events.AddRange(events);
_Collection.InsertOne(entity);
}
