public void WhenSourceIsAccessed_LazyRelation_CallsRepository_WithBothSourceAndDestinationId()
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 50, context);
var idRoot = new Uri("oh-yeah://this-is-my-root/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
HiveId int1 = HiveId.ConvertIntToGuid(1);
HiveId int2 = HiveId.ConvertIntToGuid(2);
// Act & Assert
using (var uow = groupUnitFactory.Create())
{
var lazyRelation = new LazyRelation <TypedEntity>(uow.Repositories, FixedRelationTypes.DefaultRelationType, int1, int2, 0);
IReadonlyRelation <IRelatableEntity, IRelatableEntity> blah = lazyRelation;
IRelationById blah2 = lazyRelation;
Assert.False(lazyRelation.IsLoaded);
var source = lazyRelation.Source;
Assert.True(lazyRelation.IsLoaded);
var dest = lazyRelation.Destination;
Assert.NotNull(source);
Assert.NotNull(dest);
}
}
/// <summary>
/// Changes an existing relation's source, destination and ordinal
/// </summary>
/// <param name="session"></param>
/// <param name="originalRelation"></param>
/// <param name="newSourceId"></param>
/// <param name="newDestinationId"></param>
/// <param name="newOrdinal"></param>
public static void ChangeRelation(this ICoreRelationsRepository session, IRelationById originalRelation, HiveId newSourceId, HiveId newDestinationId, int newOrdinal = int.MinValue)
{
session.RemoveRelation(originalRelation);
var useOrdinal = newOrdinal == int.MinValue ? originalRelation.Ordinal : newOrdinal;
session.AddRelation(new Relation(originalRelation.Type, newSourceId, newDestinationId, useOrdinal, originalRelation.MetaData.ToArray()));
}
public void RemoveRelation(IRelationById item, AbstractScopedCache repositoryScopedCache)
{
var sessionIdAsString = GetSessionId().ToString("n");
using (DisposableTimer.TraceDuration <NhSessionHelper>("In RemoveRelation for session " + sessionIdAsString, "End RemoveRelation for session " + sessionIdAsString))
{
var relationType = GetOrCreateNodeRelationType(item.Type.RelationName, repositoryScopedCache);
// Nh should handle this for us but got an error with mappings atm in SqlCe (APN 09/11/11)
// Clear session cache to make sure it loads all of the tags in order to delete them all
NhSession.Flush();
// Clear the repository cache of this relation in case one has been added and then removed in the same unit of work
var cacheKey = GenerateCacheKeyForRelation(item, relationType);
repositoryScopedCache.InvalidateItems(cacheKey);
var sourceIdValue = (Guid)item.SourceId.Value;
var destinationIdValue = (Guid)item.DestinationId.Value;
var existingRelation = GetDbRelation(relationType.Alias, sourceIdValue, destinationIdValue).ToArray();
if (existingRelation.Any())
{
existingRelation.ForEach(x => NhSession.Delete(x));
}
}
}
public bool EqualsIgnoringProviderId(IRelationById other)
{
if (ReferenceEquals(other, null))
{
return(false);
}
if (ReferenceEquals(other, this))
{
return(true);
}
var equals = true;
if (Type != other.Type)
{
equals = false;
}
if (!SourceId.EqualsIgnoringProviderId(other.SourceId))
{
equals = false;
}
if (!DestinationId.EqualsIgnoringProviderId(other.DestinationId))
{
equals = false;
}
if (!MetaData.OrderBy(x => x.Key).SequenceEqual(other.MetaData.OrderBy(x => x.Key)))
{
equals = false;
}
return(equals);
}
public void RemoveRelation(IRelationById item)
{
var relationByIds = GetRelationsTable();
var countBefore = relationByIds.Count;
relationByIds.RemoveAll(item.Equals);
var success = countBefore != relationByIds.Count;
}
public void RemoveRelation(IRelationById item)
{
ExecuteInCancellableTask(item,
TaskTriggers.Hive.Relations.PreRelationRemoved,
TaskTriggers.Hive.Relations.PostRelationRemoved,
() => ChildSessions.RemoveRelation(item));
;
}
/// <summary>
/// Returns a composite Id to be used for a relation
/// </summary>
/// <param name="relation"></param>
/// <returns></returns>
internal static string GetCompositeId(this IRelationById relation)
{
Mandate.ParameterNotEmpty(relation.SourceId, "relation.SourceId");
Mandate.ParameterNotEmpty(relation.DestinationId, "relation.DestinationId");
Mandate.ParameterNotEmpty(relation.SourceId.Value, "relation.SourceId.Value");
Mandate.ParameterNotEmpty(relation.DestinationId.Value, "relation.SourceId.Value");
Mandate.ParameterNotNull(relation.Type, "relation.Type");
Mandate.ParameterNotNullOrEmpty(relation.Type.RelationName, "relation.Type.RelationName");
return(relation.SourceId.Value + "," + relation.DestinationId.Value + "," + relation.Type.RelationName);
}
/// <summary>
/// Removes the relation.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="transaction"></param>
public void PerformRemoveRelation(IRelationById item, ExamineTransaction transaction)
{
Mandate.ParameterNotNull(item, "item");
var delete = new LinearHiveIndexOperation()
{
OperationType = IndexOperationType.Delete,
Id = new Lazy <string>(item.GetCompositeId)
};
transaction.EnqueueIndexOperation(delete);
}
public void RemoveRelation(IRelationById item)
{
PerformRemoveRelation(item);
Transaction.CacheFlushActions.Add(() =>
{
if (!ContextCacheAvailable())
{
return;
}
HiveContext.GenerationScopedCache.RemoveWhereKeyMatches <HiveRelationCacheKey>(x => x.EntityId.Value == item.SourceId.Value || x.EntityId.Value == item.DestinationId.Value);
});
}
protected virtual void NotifyRelationCache(IRelationById item)
{
if (!ContextCacheAvailable())
{
return;
}
Transaction.CacheFlushActions.Add(
() =>
{
HiveContext.GenerationScopedCache.RemoveWhereKeyMatches <HiveRelationCacheKey>(
x => x.EntityId.Value == item.SourceId.Value || x.EntityId.Value == item.DestinationId.Value);
});
}
public static IRelationById CreateRelationByAbsoluteId(IRelationById relation, Uri root)
{
if (relation == null)
{
return(null);
}
return(new RelationById(
new HiveId(root, relation.SourceId.ProviderId, relation.SourceId.Value),
new HiveId(root, relation.DestinationId.ProviderId, relation.DestinationId.Value),
relation.Type,
relation.Ordinal,
relation.MetaData.ToArray()));
}
protected override void PerformRemoveRelation(IRelationById relation)
{
if (relation.Type.RelationName != FixedRelationTypes.DefaultRelationType.RelationName)
{
var sourceMd5 = relation.SourceId.Value.ToString().ToMd5();
var destMd5 = relation.DestinationId.Value.ToString().ToMd5();
var searchPattern = sourceMd5 + "-" + destMd5 + ".xml";
if (Directory.Exists(Settings.RelationsStoragePath))
{
var files = Directory.GetFiles(Settings.RelationsStoragePath, searchPattern);
foreach (var filePath in files)
{
System.IO.File.Delete(filePath);
}
}
}
}
internal static IRelationById FindRelation(this IEnumerable <IReadonlyProviderRelationsRepository> sessions, HiveId sourceId, HiveId destinationId, Uri idRoot, RelationType relationType = null)
{
IRelationById result = null;
foreach (var readonlyRelationsRepository in sessions)
{
if (readonlyRelationsRepository.CanReadRelations)
{
result = readonlyRelationsRepository.FindRelation(sourceId, destinationId, relationType);
}
if (result != null)
{
break;
}
}
return(GroupSessionHelper.CreateRelationByAbsoluteId(result, idRoot));
}
private static IReadonlyRelation <IRelatableEntity, IRelatableEntity> CreateLazyOrUseExistingRelation <T>(
ICoreReadonlyRepository <T> readonlyRepository, IRelationById relationById) where T : class, IRelatableEntity
{
// Check if the repository has actually already eagerly loaded the relation in which case we can just return that
var upCast = relationById as IReadonlyRelation <IRelatableEntity, IRelatableEntity>;
if (upCast != null && upCast.Source != null && upCast.Destination != null)
{
return(upCast);
}
// Otherwise, return a LazyRelation to load on demand
return(new LazyRelation <T>(
readonlyRepository,
relationById.Type,
relationById.SourceId,
relationById.DestinationId,
relationById.Ordinal,
relationById.MetaData.ToArray()));
}
/// <summary>
/// Updates a relation to be of a new relation type
/// </summary>
/// <param name="session"></param>
/// <param name="originalRelation"></param>
/// <param name="newRelationType"></param>
public static void ChangeRelationType(this ICoreRelationsRepository session, IRelationById originalRelation, RelationType newRelationType)
{
session.RemoveRelation(originalRelation);
session.AddRelation(new Relation(newRelationType, originalRelation.SourceId, originalRelation.DestinationId, originalRelation.Ordinal, originalRelation.MetaData.ToArray()));
}
public HiveRelationByIdPostActionEventArgs(IRelationById relation, AbstractScopedCache scopedCache)
: base(scopedCache)
{
Relation = relation;
}
protected override void PerformRemoveRelation(IRelationById item)
{
_helper.CacheHelper.RemoveRelation(item);
}
public void RemoveRelation(IRelationById item)
{
ChildSessions.RemoveRelation(item);
}
protected override void PerformRemoveRelation(IRelationById item)
{
Helper.PerformDelete(item.GetCompositeId(), ExamineTransaction);
}
internal static void RemoveRelation(this IEnumerable <ICoreRelationsRepository> session, IRelationById relation)
{
foreach (var relationsRepository in session)
{
relationsRepository.RemoveRelation(relation);
}
}
protected abstract void PerformRemoveRelation(IRelationById item);
protected override void PerformRemoveRelation(IRelationById item)
{
Helper.RemoveRelation(item, this.RepositoryScopedCache);
}
private void ExecuteInCancellableTask(IRelationById entity, string preActionTaskTrigger, string postActionTaskTrigger, Action execution)
{
FrameworkContext.TaskManager.ExecuteInCancellableTask(this, entity, preActionTaskTrigger, postActionTaskTrigger, execution, x => new HiveRelationByIdPreActionEventArgs(x, UnitScopedCache), x => new HiveRelationByIdPostActionEventArgs(x, UnitScopedCache), FrameworkContext);
}
public void RemoveRelation(IRelationById item)
{
Transaction.EnsureBegun();
PerformRemoveRelation(item);
}
internal static IRelationById CreateRelationByIdWithProviderId(ProviderMetadata providerMetadata, IRelationById relation)
{
if (relation == null)
{
return(null);
}
return(new RelationById(
CreateMappedProviderId(providerMetadata, relation.SourceId),
CreateMappedProviderId(providerMetadata, relation.DestinationId),
relation.Type,
relation.Ordinal,
relation.MetaData.ToArray()));
}
protected override void PerformRemoveRelation(IRelationById item)
{
return;
}
protected override void PerformRemoveRelation(IRelationById item)
{
throw new NotImplementedException();
}
public HiveRelationByIdPostActionEventArgs(IRelationById relation, AbstractScopedCache scopedCache)
: base(scopedCache)
{
Relation = relation;
}
public void RemoveRelation(IRelationById item)
{
PerformRemoveRelation(item);
}
private static string GenerateCacheKeyForRelation(IRelationById item, NodeRelationType nodeRelationType)
{
return(GenerateCacheKeyForRelation(nodeRelationType, item.SourceId, item.DestinationId));
}
