public EntitySchema MapAttributeSchemaDefinition(AttributeSchemaDefinition attributeSchemaDefinition, AbstractLookupHelper lookupHelper, AbstractMappingEngine masterMapper)
{
//TODO
//- Map AttributeGroupDefinitions - how to track changes?
//- Add DateModified to Rdbms model
var mapped = new EntitySchema();
MapAttributeSchemaDefinition(attributeSchemaDefinition, mapped, lookupHelper, masterMapper);
return(mapped);
}
private static IQueryOver <NodeVersion, NodeVersion> AddSchemasToOuterQuery(IQueryOver <NodeVersion, NodeVersion> mainLoaderQuery, NhCriteriaVisitor.FilterResult filteringSubquery)
{
if (filteringSubquery.RequiredSchemaAliases != null && filteringSubquery.RequiredSchemaAliases.Any())
{
AttributeSchemaDefinition schema = null;
mainLoaderQuery = mainLoaderQuery
.JoinAlias(x => x.AttributeSchemaDefinition, () => schema)
.Where(() => schema.Alias.IsIn(filteringSubquery.RequiredSchemaAliases.ToArray()));
}
if (filteringSubquery.RequiredNodeIds != null && filteringSubquery.RequiredNodeIds.Any())
{
mainLoaderQuery = mainLoaderQuery
.Where(x => x.Node.Id.IsIn(filteringSubquery.RequiredNodeIds.ToArray()));
}
return(mainLoaderQuery);
}
private static IQueryOver <AggregateNodeStatus, AggregateNodeStatus> AddSchemasToOuterQuery(IQueryOver <AggregateNodeStatus, AggregateNodeStatus> aggQuery, NhAggregateCriteriaVisitor.FilterResult filteringSubquery)
{
if (filteringSubquery.RequiredSchemaAliases != null && filteringSubquery.RequiredSchemaAliases.Any())
{
AttributeSchemaDefinition schema = null;
NodeVersion v = null;
aggQuery = aggQuery
.JoinAlias(x => x.NodeVersion, () => v)
.JoinAlias(() => v.AttributeSchemaDefinition, () => schema)
.Where(() => schema.Alias.IsIn(filteringSubquery.RequiredSchemaAliases.ToArray()));
}
if (filteringSubquery.RequiredNodeIds != null && filteringSubquery.RequiredNodeIds.Any())
{
aggQuery = aggQuery
.Where(x => x.Node.Id.IsIn(filteringSubquery.RequiredNodeIds.ToArray()));
}
return(aggQuery);
}
public void From_AttributeSchemaDefinition_With_Relations_To_EntitySchema()
{
//Arrange
var mapper = new ManualMapper(new FakeLookupHelper(), new FakeHiveProvider());
mapper.Configure();
var entityParent = new AttributeSchemaDefinition()
{
Id = Guid.NewGuid(), Alias = "test-parent"
};
var entityChild = new AttributeSchemaDefinition()
{
Id = Guid.NewGuid(), Alias = "test-child"
};
entityParent.OutgoingRelations.Add(new NodeRelation()
{
StartNode = entityParent,
EndNode = entityChild,
NodeRelationType = new NodeRelationType()
{
Alias = FixedRelationTypes.SchemaTreeRelationType.RelationName,
Id = FixedRelationTypes.SchemaTreeRelationType.RelationName.EncodeAsGuid()
}
});
//Act
var resultParent = mapper.Map <AttributeSchemaDefinition, EntitySchema>(entityParent);
//var resultChild = mapper.Map<TypedEntity, NodeVersion>(entityChild);
//Assert
Assert.AreEqual(entityParent.Alias, resultParent.Alias);
Assert.AreEqual(entityParent.OutgoingRelations.Count(), resultParent.Relations.Count());
Assert.AreEqual(entityParent.OutgoingRelations.Single().StartNode.Id, (Guid)resultParent.Relations.Single().Source.Id.Value);
Assert.AreEqual(entityParent.OutgoingRelations.Single().EndNode.Id, (Guid)resultParent.Relations.Single().Destination.Id.Value);
//BUG: If you call entityChild.Relations.Count() an infinite loop occurs :(
//Assert.AreEqual(entityChild.Relations.Count(), resultChild.Node.IncomingRelations.Count);
}
//public void MapAttributeGroup(AttributeGroup destination, AttributeDefinitionGroup source)
//{
// destination.Alias = source.Alias;
// destination.Id = source.Id;
// destination.Name = source.Name;
// destination.UtcCreated = source.DateCreated;
//}
//public AttributeGroup MapAttributeGroup(AttributeDefinitionGroup attributeGroup)
//{
// // TODO:
// // - Attributes and AttributeDefinitions navigator on the stack model will be tricky to track changes
// // - Add Ordinal to Rdbms model
// var mapped = new AttributeGroup();
// MapAttributeGroup(mapped, attributeGroup);
// return mapped;
//}
public void MapAttributeSchemaDefinition(AttributeSchemaDefinition source, EntitySchema destination, AbstractLookupHelper lookupHelper, AbstractMappingEngine masterMapper)
{
destination.Alias = source.Alias;
destination.Id = (HiveId)source.Id;
destination.Name = source.Name;
destination.UtcCreated = source.DateCreated;
destination.SchemaType = source.SchemaType;
if (!string.IsNullOrEmpty(source.XmlConfiguration))
{
destination.XmlConfiguration = XDocument.Parse(source.XmlConfiguration); // else the constructor will initialize it
}
destination.AttributeGroups.Clear();
destination.AttributeDefinitions.Clear();
//destination.AttributeTypes.Clear();
foreach (var attributeDefinitionGroup in source.AttributeDefinitionGroups)
{
var mappedGroup = MapAttributeGroupDefinition(attributeDefinitionGroup, lookupHelper, masterMapper);
destination.AttributeGroups.Add(mappedGroup);
}
//create a local cache of AttributeTypes to pass to the mappers so that we can
//ensure that the same AttributeType based on the alias is the same used across all
//AttributeDefinitions.
var attributeTypeCache = new List <Model.Attribution.MetaData.AttributeType>();
foreach (var attributeDefinition in source.AttributeDefinitions)
{
var localAttribCopy = attributeDefinition;
var newDef = MapAttributeDefinition(localAttribCopy, lookupHelper, masterMapper, attributeTypeCache);
newDef.AttributeGroup = destination.AttributeGroups.SingleOrDefault(x => x.Alias == localAttribCopy.AttributeDefinitionGroup.Alias);
if (newDef.AttributeGroup == null)
{
throw new InvalidOperationException(
"Could not find group with alias {0} for mapping".InvariantFormat(
localAttribCopy.AttributeDefinitionGroup.Alias));
}
destination.AttributeDefinitions.Add(newDef);
}
MapRelations(source, destination, lookupHelper, masterMapper);
}
public static void MapAttributeSchemaDefinition(EntitySchema source, AttributeSchemaDefinition destinationSchema, AbstractLookupHelper lookupHelper, AbstractMappingEngine masterMapper)
{
destinationSchema.Alias = source.Alias;
destinationSchema.Id = (Guid)source.Id.Value;
destinationSchema.Name = source.Name;
destinationSchema.DateCreated = source.UtcCreated;
destinationSchema.XmlConfiguration = source.XmlConfiguration.ToString();
destinationSchema.SchemaType = source.SchemaType;
// Find groups in both source and destination that exist, and remap them at the destination
// Then find groups only at the source, and add them
// Then find groups only at the destination, and remove them
var groupsToRemove = MergeMapCollections(
source.AttributeGroups,
destinationSchema.AttributeDefinitionGroups,
(sourceGroup, destGroup) => MapAttributeDefinitionGroup(sourceGroup, destGroup, lookupHelper, masterMapper),
sourceGroup => MapAttributeDefinitionGroup(sourceGroup, lookupHelper, masterMapper),
(sourceGroup, destGroup) => destGroup.AttributeSchemaDefinition = destinationSchema,
(sourceGroup, destGroup) => sourceGroup.Alias == destGroup.Alias
);
// Now do the same for the attribute definitions
var defsToRemove = MergeMapCollections(
source.AttributeDefinitions,
destinationSchema.AttributeDefinitions,
(sourceDef, destDef) => MapAttributeDefinition(sourceDef, destDef, lookupHelper, masterMapper),
sourceDef => MapAttributeDefinition(sourceDef, lookupHelper, masterMapper),
(sourceDef, destDef) =>
{
destDef.AttributeSchemaDefinition = destinationSchema;
if (sourceDef.AttributeGroup == null)
{
return;
}
var localDefCopy = sourceDef;
var mappedGroup = destinationSchema.AttributeDefinitionGroups.Single(x => x.Alias == localDefCopy.AttributeGroup.Alias);
destDef.AttributeDefinitionGroup = mappedGroup;
},
(sourceGroup, destGroup) => sourceGroup.Alias == destGroup.Alias
);
// Hack for beta: make sure if there are any remaining AttributeDefinitions referenced via a group, but not in the AttributeDefinitions collection,
// we delete it from the group
var defsToDelete = new List <AttributeDefinition>();
foreach (var attributeDefinitionGroup in destinationSchema.AttributeDefinitionGroups)
{
foreach (var attributeDefinition in attributeDefinitionGroup.AttributeDefinitions)
{
if (!destinationSchema.AttributeDefinitions.Contains(attributeDefinition))
{
defsToDelete.Add(attributeDefinition);
}
}
}
foreach (var attributeDefinition in defsToDelete)
{
foreach (var attributeDefinitionGroup in destinationSchema.AttributeDefinitionGroups)
{
attributeDefinitionGroup.AttributeDefinitions.Remove(attributeDefinition);
}
}
MapRelations(destinationSchema, source, lookupHelper, masterMapper);
}
public void SavingNodeVersion_ViaAddingToNodeCollection_UpdatesExistingInstance_WhenMerging()
{
var setup = new NhibernateTestSetupHelper();
var node = new Node() { IsDisabled = false };
using (var tran = setup.SessionForTest.BeginTransaction())
{
node = setup.SessionForTest.Merge(node) as Node;
//setup.SessionForTest.SaveOrUpdate(node);
tran.Commit();
}
Assert.That(node.Id, Is.Not.EqualTo(Guid.Empty));
setup.SessionForTest.Clear();
Assert.That(setup.SessionForTest.QueryOver<Node>().List().Count, Is.EqualTo(1));
Assert.That(node.Id, Is.Not.EqualTo(Guid.Empty));
NodeVersion nodeVersion = null;
using (var tran = setup.SessionForTest.BeginTransaction())
{
// Get the node from the cleared session to mimic what the NH revision repository is doing
node = setup.SessionForTest.Get<Node>(node.Id);
var currentNodeId = node.Id;
Assert.That(currentNodeId, Is.Not.EqualTo(Guid.Empty));
var schema = new AttributeSchemaDefinition { Alias = "tes1", SchemaType = "content" };
nodeVersion = new NodeVersion { DefaultName = "test", Node = node, AttributeSchemaDefinition = schema };
nodeVersion = setup.SessionForTest.Merge(nodeVersion) as NodeVersion;
node.NodeVersions.Add(nodeVersion);
node = setup.SessionForTest.Merge(node) as Node;
tran.Commit();
Assert.That(currentNodeId, Is.EqualTo(node.Id));
Assert.That(node.NodeVersions.Count, Is.EqualTo(1));
Assert.That(node.NodeVersions.First().Id, Is.EqualTo(nodeVersion.Id));
Assert.That(nodeVersion.Id, Is.Not.EqualTo(Guid.Empty));
}
setup.SessionForTest.Clear();
Assert.That(setup.SessionForTest.QueryOver<Node>().List().Count, Is.EqualTo(2)); // One for the Node, one for the Schema
Assert.That(node.Id, Is.Not.EqualTo(Guid.Empty));
node = setup.SessionForTest.Get<Node>(node.Id);
Assert.That(node.NodeVersions, Is.Not.Empty);
Assert.That(node.NodeVersions.Count, Is.EqualTo(1));
Assert.That(nodeVersion.Id, Is.Not.EqualTo(Guid.Empty));
Assert.That(node.NodeVersions.First().Id, Is.EqualTo(nodeVersion.Id));
}
public void WhenAddingNodeVersionToSession_ThenClearingAndResettingAttributesCollection_BeforeCommitting_AttributesCollectionIsCorrect()
{
var setup = new NhibernateTestSetupHelper();
var node = new Node() { IsDisabled = false };
using (var tran = setup.SessionForTest.BeginTransaction())
{
node = setup.SessionForTest.Merge(node) as Node;
tran.Commit();
}
setup.SessionForTest.Clear();
NodeVersion nodeVersion = null;
using (var tran = setup.SessionForTest.BeginTransaction())
{
// Get the node from the cleared session to mimic what the NH revision repository is doing
node = setup.SessionForTest.Get<Node>(node.Id);
var currentNodeId = node.Id;
Assert.That(currentNodeId, Is.Not.EqualTo(Guid.Empty));
var schema = new AttributeSchemaDefinition { Alias = "tes1", SchemaType = "content" };
var type = new AttributeType { Alias = "type1" };
var def = new AttributeDefinition
{ Alias = "def1", AttributeDefinitionGroup = new AttributeDefinitionGroup { Alias = "group1", AttributeSchemaDefinition = schema}, AttributeSchemaDefinition = schema, AttributeType = type};
schema.AttributeDefinitions.Add(def);
nodeVersion = new NodeVersion { DefaultName = "test", Node = node, AttributeSchemaDefinition = schema };
nodeVersion.Attributes.Add(new Attribute { AttributeDefinition = def, NodeVersion = nodeVersion });
nodeVersion.Node = node;
// Merge the version into the session, which will add it to 1st-level cache but we haven't committed to db yet
nodeVersion = setup.SessionForTest.Merge(nodeVersion) as NodeVersion;
var persister = setup.SessionForTest.GetSessionImplementation().PersistenceContext;
nodeVersion.Attributes.Clear();
nodeVersion.Attributes.Add(new Attribute { AttributeDefinition = def, NodeVersion = nodeVersion });
nodeVersion = setup.SessionForTest.Merge(nodeVersion) as NodeVersion;
node.NodeVersions.Add(nodeVersion);
setup.SessionForTest.Merge(node);
tran.Commit();
}
setup.SessionForTest.Clear();
using (var tran = setup.SessionForTest.BeginTransaction())
{
var reloadVersion = setup.SessionForTest.Get<NodeVersion>(nodeVersion.Id);
reloadVersion.Attributes.Clear();
setup.SessionForTest.Merge(reloadVersion);
tran.Commit();
}
using (var tran = setup.SessionForTest.BeginTransaction())
{
var reloadVersion = setup.SessionForTest.Get<NodeVersion>(nodeVersion.Id);
Assert.That(reloadVersion.Attributes.Count, Is.EqualTo(1));
}
}
public void WhenAddingNodeVersionToSession_ThenClearingAndResettingAttributesCollection_BeforeCommitting_AttributesCollectionIsCorrect()
{
var setup = new NhibernateTestSetupHelper();
var node = new Node()
{
IsDisabled = false
};
using (var tran = setup.SessionForTest.BeginTransaction())
{
node = setup.SessionForTest.Merge(node) as Node;
tran.Commit();
}
setup.SessionForTest.Clear();
NodeVersion nodeVersion = null;
using (var tran = setup.SessionForTest.BeginTransaction())
{
// Get the node from the cleared session to mimic what the NH revision repository is doing
node = setup.SessionForTest.Get <Node>(node.Id);
var currentNodeId = node.Id;
Assert.That(currentNodeId, Is.Not.EqualTo(Guid.Empty));
var schema = new AttributeSchemaDefinition {
Alias = "tes1", SchemaType = "content"
};
var type = new AttributeType {
Alias = "type1"
};
var def = new AttributeDefinition
{
Alias = "def1", AttributeDefinitionGroup = new AttributeDefinitionGroup {
Alias = "group1", AttributeSchemaDefinition = schema
}, AttributeSchemaDefinition = schema, AttributeType = type
};
schema.AttributeDefinitions.Add(def);
nodeVersion = new NodeVersion {
DefaultName = "test", Node = node, AttributeSchemaDefinition = schema
};
nodeVersion.Attributes.Add(new Attribute {
AttributeDefinition = def, NodeVersion = nodeVersion
});
nodeVersion.Node = node;
// Merge the version into the session, which will add it to 1st-level cache but we haven't committed to db yet
nodeVersion = setup.SessionForTest.Merge(nodeVersion) as NodeVersion;
var persister = setup.SessionForTest.GetSessionImplementation().PersistenceContext;
nodeVersion.Attributes.Clear();
nodeVersion.Attributes.Add(new Attribute {
AttributeDefinition = def, NodeVersion = nodeVersion
});
nodeVersion = setup.SessionForTest.Merge(nodeVersion) as NodeVersion;
node.NodeVersions.Add(nodeVersion);
setup.SessionForTest.Merge(node);
tran.Commit();
}
setup.SessionForTest.Clear();
using (var tran = setup.SessionForTest.BeginTransaction())
{
var reloadVersion = setup.SessionForTest.Get <NodeVersion>(nodeVersion.Id);
reloadVersion.Attributes.Clear();
setup.SessionForTest.Merge(reloadVersion);
tran.Commit();
}
using (var tran = setup.SessionForTest.BeginTransaction())
{
var reloadVersion = setup.SessionForTest.Get <NodeVersion>(nodeVersion.Id);
Assert.That(reloadVersion.Attributes.Count, Is.EqualTo(1));
}
}
public void SavingNodeVersion_ViaAddingToNodeCollection_UpdatesExistingInstance_WhenMerging()
{
var setup = new NhibernateTestSetupHelper();
var node = new Node()
{
IsDisabled = false
};
using (var tran = setup.SessionForTest.BeginTransaction())
{
node = setup.SessionForTest.Merge(node) as Node;
//setup.SessionForTest.SaveOrUpdate(node);
tran.Commit();
}
Assert.That(node.Id, Is.Not.EqualTo(Guid.Empty));
setup.SessionForTest.Clear();
Assert.That(setup.SessionForTest.QueryOver <Node>().List().Count, Is.EqualTo(1));
Assert.That(node.Id, Is.Not.EqualTo(Guid.Empty));
NodeVersion nodeVersion = null;
using (var tran = setup.SessionForTest.BeginTransaction())
{
// Get the node from the cleared session to mimic what the NH revision repository is doing
node = setup.SessionForTest.Get <Node>(node.Id);
var currentNodeId = node.Id;
Assert.That(currentNodeId, Is.Not.EqualTo(Guid.Empty));
var schema = new AttributeSchemaDefinition {
Alias = "tes1", SchemaType = "content"
};
nodeVersion = new NodeVersion {
DefaultName = "test", Node = node, AttributeSchemaDefinition = schema
};
nodeVersion = setup.SessionForTest.Merge(nodeVersion) as NodeVersion;
node.NodeVersions.Add(nodeVersion);
node = setup.SessionForTest.Merge(node) as Node;
tran.Commit();
Assert.That(currentNodeId, Is.EqualTo(node.Id));
Assert.That(node.NodeVersions.Count, Is.EqualTo(1));
Assert.That(node.NodeVersions.First().Id, Is.EqualTo(nodeVersion.Id));
Assert.That(nodeVersion.Id, Is.Not.EqualTo(Guid.Empty));
}
setup.SessionForTest.Clear();
Assert.That(setup.SessionForTest.QueryOver <Node>().List().Count, Is.EqualTo(2)); // One for the Node, one for the Schema
Assert.That(node.Id, Is.Not.EqualTo(Guid.Empty));
node = setup.SessionForTest.Get <Node>(node.Id);
Assert.That(node.NodeVersions, Is.Not.Empty);
Assert.That(node.NodeVersions.Count, Is.EqualTo(1));
Assert.That(nodeVersion.Id, Is.Not.EqualTo(Guid.Empty));
Assert.That(node.NodeVersions.First().Id, Is.EqualTo(nodeVersion.Id));
}
