public TEntity Add()
{
TEntity added = DbEntityRepository.CreateInstance <TEntity>(_userId);
Add(added);
return(added);
}
public EntityRelationListResponse Read(List <DbEntity> storageEntityList = null)
{
EntityRelationListResponse response = new EntityRelationListResponse();
response.Timestamp = DateTime.UtcNow;
response.Object = null;
try
{
var relations = Cache.GetRelations();
if (relations != null)
{
response.Object = relations;
response.Hash = Cache.GetRelationsHash();
response.Success = true;
response.Message = null;
return(response);
}
relations = DbContext.Current.RelationRepository.Read().Select(x => x.MapTo <EntityRelation>()).ToList();
List <DbEntity> dbEntities = storageEntityList;
if (dbEntities == null)
{
dbEntities = new DbEntityRepository().Read();
}
foreach (EntityRelation relation in relations)
{
var originEntity = dbEntities.Single(x => x.Id == relation.OriginEntityId);
var targetEntity = dbEntities.Single(x => x.Id == relation.TargetEntityId);
relation.OriginEntityName = originEntity.Name;
relation.TargetEntityName = targetEntity.Name;
relation.OriginFieldName = originEntity.Fields.Single(x => x.Id == relation.OriginFieldId).Name;
relation.TargetFieldName = targetEntity.Fields.Single(x => x.Id == relation.TargetFieldId).Name;
}
if (relations != null)
{
Cache.AddRelations(relations);
}
//we use instance from cache as return value, because in cache we deepcopy collection
response.Object = Cache.GetRelations();
response.Hash = Cache.GetRelationsHash();
response.Success = true;
response.Message = null;
return(response);
}
catch (Exception e)
{
response.Success = false;
response.Object = null;
response.Hash = null;
response.Timestamp = DateTime.UtcNow;
#if DEBUG
response.Message = e.Message + e.StackTrace;
#endif
return(response);
}
}
public void MarkPersisted_non_flat_one_to_one_and_one_to_many_relations()
{
MockEntity entity = new MockEntity();
MockEntity relationalEntity = new MockEntity();
relationalEntity.RelationalEntities.Add(new MockEntity());
entity.RelationalEntities.Add(new MockEntity()
{
RelationalEntity1 = relationalEntity
});
Assert.AreEqual(EntityState.New, entity.State);
Assert.AreEqual(EntityState.New, entity.RelationalEntities.Single().State);
Assert.AreEqual(EntityState.New, entity.RelationalEntities.Single().RelationalEntity1.State);
Assert.AreEqual(EntityState.New, entity.RelationalEntities.Single().RelationalEntity1.RelationalEntities.Single().State);
Tuple <string, object>[] primaryKeys = new Tuple <string, object>[] { new Tuple <string, object>("Key", "Value") };
Mock <IDataAccessLayer> mockDal = new Mock <IDataAccessLayer>();
mockDal.Setup(m => m.GetEntity <MockEntity, IDbEntityProjection>(primaryKeys)).Returns(Task.FromResult(entity));
DbEntityRepository.MarkPersisted(entity, entity.GetType());
Assert.AreEqual(EntityState.Persisted, entity.State);
Assert.AreEqual(EntityState.Persisted, entity.RelationalEntities.Single().State);
Assert.AreEqual(EntityState.Persisted, entity.RelationalEntities.Single().RelationalEntity1.State);
Assert.AreEqual(EntityState.Persisted, entity.RelationalEntities.Single().RelationalEntity1.RelationalEntities.Single().State);
}
private TAssociative CreateAssociativeEntity(TEntity entity)
{
TAssociative associativeEntity = DbEntityRepository.CreateInstance <TAssociative>(_userId);
_setForeignKeys(AssociativeCollectionOwner, entity, associativeEntity);
if (entity.State == EntityState.New)
{
_setForeignEntities(AssociativeCollectionOwner, entity, associativeEntity);
entity.CreatedByID = _userId;
}
return(associativeEntity);
}
public void MarkPersisted_flat_entity()
{
MockEntity entity = new MockEntity();
Assert.AreEqual(EntityState.New, entity.State);
Tuple <string, object>[] primaryKeys = new Tuple <string, object>[] { new Tuple <string, object>("Key", "Value") };
Mock <IDataAccessLayer> mockDal = new Mock <IDataAccessLayer>();
mockDal.Setup(m => m.GetEntity <MockEntity, IDbEntityProjection>(primaryKeys)).Returns(Task.FromResult(entity));
DbEntityRepository.MarkPersisted(entity, entity.GetType());
Assert.AreEqual(EntityState.Persisted, entity.State);
}