public void AddRelationType(IRelationType relationType)
{
AssertNotNull(relationType, "relationType");
ValidateRelationType(relationType);
_relationTypes[relationType.Name] = relationType;
}
/// <summary>
/// Constructor for reconstructing the entity from the data source
/// </summary>
/// <param name="parentId"></param>
/// <param name="childId"></param>
/// <param name="parentObjectType"></param>
/// <param name="childObjectType"></param>
/// <param name="relationType"></param>
public Relation(int parentId, int childId, Guid parentObjectType, Guid childObjectType, IRelationType relationType)
{
_parentId = parentId;
_childId = childId;
_relationType = relationType;
ParentObjectType = parentObjectType;
ChildObjectType = childObjectType;
}
/// <summary>
/// Gets the entity identifier of the entity.
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns>The entity identifier of the entity.</returns>
public static GuidUdi GetUdi(this IRelationType entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
return(new GuidUdi(Constants.UdiEntityType.RelationType, entity.Key).EnsureClosed());
}
/// <inheritdoc />
public bool HasRelations(IRelationType relationType)
{
using (var scope = ScopeProvider.CreateCoreScope(autoComplete: true))
{
var query = Query <IRelation>().Where(x => x.RelationTypeId == relationType.Id);
return(_relationRepository.Get(query)?.Any() ?? false);
}
}
public bool ExistCompositeRoles(IRelationType relationType)
{
this.AssertNotDeleted();
HashSet <Strategy> roleStrategies;
this.compositesRoleByRoleType.TryGetValue(relationType.RoleType, out roleStrategies);
return(roleStrategies != null);
}
/// <summary>
/// Checks whether any relations exists for the passed in <see cref="RelationType"/>.
/// </summary>
/// <param name="relationType"><see cref="RelationType"/> to check for relations</param>
/// <returns>Returns <c>True</c> if any relations exists for the given <see cref="RelationType"/>, otherwise <c>False</c></returns>
public bool HasRelations(IRelationType relationType)
{
using (var repository = RepositoryFactory.CreateRelationRepository(UowProvider.GetUnitOfWork()))
{
var query = new Query <IRelation>().Where(x => x.RelationTypeId == relationType.Id);
return(repository.GetByQuery(query).Any());
}
}
public bool ExistUnitRole(IRelationType relationType)
{
this.AssertNotDeleted();
var roleType = relationType.RoleType;
this.session.MemoryDatabase.UnitRoleChecks(this, roleType);
return(this.unitRoleByRoleType.ContainsKey(roleType));
}
/// <inheritdoc />
public bool AreRelated(int parentId, int childId, IRelationType relationType)
{
using (var scope = ScopeProvider.CreateCoreScope(autoComplete: true))
{
var query = Query <IRelation>().Where(x => x.ParentId == parentId && x.ChildId == childId && x.RelationTypeId == relationType.Id);
return(_relationRepository.Get(query)?.Any() ?? false);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RelationTypeManyXmlWriter"/> class.
/// </summary>
/// <param name="relationType">The relation type.</param>
/// <param name="xmlWriter">The XML writer.</param>
internal RelationTypeManyXmlWriter(IRelationType relationType, XmlWriter xmlWriter)
{
this.relationType = relationType;
this.xmlWriter = xmlWriter;
this.rolesStringBuilder = new StringBuilder();
this.previousAssociationId = -1;
this.isClosed = false;
}
/// <summary>
/// Checks whether two items are related with a given relation type
/// </summary>
/// <param name="parentId">Id of the Parent relation</param>
/// <param name="childId">Id of the Child relation</param>
/// <param name="relationTypeAlias">Type of relation</param>
/// <returns>Returns <c>True</c> if any relations exists with the given Ids and relation type, otherwise <c>False</c></returns>
public bool AreRelated(int parentId, int childId, IRelationType relationType)
{
using (var repository = RepositoryFactory.CreateRelationRepository(UowProvider.GetUnitOfWork()))
{
var query = new Query <IRelation>().Where(x => x.ParentId == parentId && x.ChildId == childId && x.RelationTypeId == relationType.Id);
return(repository.GetByQuery(query).Any());
}
}
public virtual void RemoveCompositeRole(IRelationType relationType)
{
this.AssertExist();
RoleAssertions.CompositeRoleChecks(this, relationType.RoleType);
this.Roles.RemoveCompositeRole(relationType.RoleType);
}
public virtual IObject GetCompositeAssociation(IRelationType relationType)
{
this.AssertExist();
var association = this.Session.GetAssociation(this, relationType.AssociationType);
return(association?.Strategy.GetObject());
}
public virtual IObject GetCompositeRole(IRelationType relationType)
{
this.AssertExist();
var role = this.Roles.GetCompositeRole(relationType.RoleType);
return((role == null) ? null : this.Session.State.GetOrCreateReferenceForExistingObject(role.Value, this.Session).Strategy.GetObject());
}
public virtual object GetUnitRole(IRelationType relationType)
{
this.AssertExist();
var roleType = relationType.RoleType;
return(this.Roles.GetUnitRole(roleType));
}
public RelationType(int id)
{
RelationTypeEntity = ApplicationContext.Current.Services.RelationService.GetRelationTypeById(id);
if (RelationTypeEntity == null)
{
throw new NullReferenceException("No relation type found with id " + id);
}
}
public IObject GetCompositeAssociation(IRelationType relationType)
{
this.AssertNotDeleted();
Strategy strategy;
this.compositeAssociationByAssociationType.TryGetValue(relationType.AssociationType, out strategy);
return(strategy?.GetObject());
}
/// <summary>
/// Initializes a new instance of the <see cref="RelationTypeManyXmlWriter"/> class.
/// </summary>
/// <param name="relationType">The relation type.</param>
/// <param name="xmlWriter">The XML writer.</param>
public RelationTypeManyXmlWriter(IRelationType relationType, XmlWriter xmlWriter)
{
this.relationType = relationType;
this.xmlWriter = xmlWriter;
this.rolesStringBuilder = new StringBuilder();
this.previousAssociationId = -1;
this.isClosed = false;
}
public static IRelation SimpleMockedRelation(int id, int child, int parent, IRelationType relType)
{
return(Mock.Of <IRelation>(content =>
content.ChildId == child &&
content.ParentId == parent &&
content.Id == id &&
content.RelationType == relType &&
content.CreateDate == DateTime.Now));
}
public bool ExistRole(IRelationType relationType)
{
if (relationType.RoleType.ObjectType is IUnit)
{
return(this.ExistUnitRole(relationType));
}
return(relationType.RoleType.IsMany ? this.ExistCompositeRoles(relationType) : this.ExistCompositeRole(relationType));
}
public IObject GetCompositeRole(IRelationType relationType)
{
this.AssertNotDeleted();
var roleType = relationType.RoleType;
this.compositeRoleByRoleType.TryGetValue(roleType, out var strategy);
return(strategy?.GetObject());
}
public bool ExistCompositeAssociations(IRelationType relationType)
{
this.AssertNotDeleted();
HashSet <Strategy> strategies;
this.compositesAssociationByAssociationType.TryGetValue(relationType.AssociationType, out strategies);
return(strategies != null);
}
private static IRelation DtoToEntity(RelationDto dto, IRelationType relationType)
{
var entity = RelationFactory.BuildEntity(dto, relationType);
// reset dirty initial properties (U4-1946)
entity.ResetDirtyProperties(false);
return(entity);
}
private void LoadCompositeRelations(XmlReader reader, IRelationType relationType)
{
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
if (reader.Name.Equals(Serialization.Relation))
{
var associationString = reader.GetAttribute(Serialization.Association);
var association = new ObjectIdLong(long.Parse(associationString));
if (reader.IsEmptyElement)
{
this.OnRelationNotLoaded(relationType.Id, association.ToString(), null);
}
else
{
var value = reader.ReadString();
var roleStrings = value.Split(Serialization.ObjectsSplitterCharArray);
if (relationType.RoleType.IsOne && roleStrings.Length > 1)
{
foreach (var roleString in roleStrings)
{
this.OnRelationNotLoaded(relationType.Id, association.ToString(), roleString);
}
}
foreach (var roleString in roleStrings)
{
var role = new ObjectIdLong(long.Parse(roleString));
//this.OnRelationNotLoaded(relationType.Id, association.ToString(), r);
var cmdText = @"
INSERT INTO " + this.Mapping.GetTableName(relationType) + " (" + Mapping.ColumnNameForAssociation + "," + Mapping.ColumnNameForRole + @")
VALUES (" + Mapping.ParameterNameForAssociation + "," + Mapping.ParameterNameForRole + ")";
using (var command = this.CreateCommand(cmdText))
{
command.Parameters.Add(Mapping.ParameterNameForAssociation, Mapping.DbTypeForId).Value = association.Value;
command.Parameters.Add(Mapping.ParameterNameForRole, Mapping.DbTypeForId).Value = role.Value;
command.ExecuteNonQuery();
}
}
}
}
break;
case XmlNodeType.EndElement:
return;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TableSchemaValidationError"/> class.
/// </summary>
/// <param name="objectType">The invalid object type.</param>
/// <param name="relationType">The invalid relation type.</param>
/// <param name="role">The invalid role.</param>
/// <param name="tableName">Name of the table.</param>
/// <param name="columnName">Name of the column.</param>
/// <param name="errorKind">The kind of validation error.</param>
/// <param name="message">The validation error message.</param>
public TableSchemaValidationError(IObjectType objectType, IRelationType relationType, IRoleType role, string tableName, string columnName, SchemaValidationErrorKind errorKind, string message)
{
this.objectType = objectType;
this.relationType = relationType;
this.role = role;
this.tableName = tableName;
this.columnName = columnName;
this.kind = errorKind;
this.message = message;
}
private Dictionary <long, long> GetAssociationIdByRoleId(IRelationType relationType)
{
if (!this.associationIdByRoleIdByRelationTypeId.TryGetValue(relationType, out var associationIdByRoleId))
{
associationIdByRoleId = new Dictionary <long, long>();
this.associationIdByRoleIdByRelationTypeId[relationType] = associationIdByRoleId;
}
return(associationIdByRoleId);
}
// Umbraco.Code.MapAll -CreateDate -UpdateDate -DeleteDate
private static void Map(RelationTypeSave source, IRelationType target, MapperContext context)
{
target.Alias = source.Alias;
target.ChildObjectType = source.ChildObjectType;
target.Id = source.Id.TryConvertTo <int>().Result;
target.IsBidirectional = source.IsBidirectional;
target.Key = source.Key;
target.Name = source.Name;
target.ParentObjectType = source.ParentObjectType;
}
public object GetUnitRole(IRelationType relationType)
{
this.AssertNotDeleted();
var roleType = relationType.RoleType;
this.MemorySession.MemoryDatabase.UnitRoleChecks(this, roleType);
return(this.GetInternalizedUnitRole(roleType));
}
/// <inheritdoc />
public IRelation GetByParentAndChildId(int parentId, int childId, IRelationType relationType)
{
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
{
var query = Query <IRelation>().Where(x => x.ParentId == parentId &&
x.ChildId == childId &&
x.RelationTypeId == relationType.Id);
return(_relationRepository.Get(query).FirstOrDefault());
}
}
private Dictionary <long, object> GetRoleByAssociationId(IRelationType relationType)
{
if (!this.roleByAssociationIdByRelationTypeId.TryGetValue(relationType, out var roleByAssociationId))
{
roleByAssociationId = new Dictionary <long, object>();
this.roleByAssociationIdByRelationTypeId[relationType] = roleByAssociationId;
}
return(roleByAssociationId);
}
public virtual bool ExistAssociation(IRelationType relationType)
{
var associationType = relationType.AssociationType;
if (associationType.IsMany)
{
return(this.ExistCompositeAssociations(relationType));
}
return(this.ExistCompositeAssociation(relationType));
}
public virtual object GetRole(IRelationType relationType)
{
if (relationType.RoleType.ObjectType.IsUnit)
{
return(this.GetUnitRole(relationType));
}
return(relationType.RoleType.IsMany
? (object)this.GetCompositeRoles(relationType)
: this.GetCompositeRole(relationType));
}
public virtual object GetAssociation(IRelationType relationType)
{
var associationType = relationType.AssociationType;
if (associationType.IsMany)
{
return(this.GetCompositeAssociations(relationType));
}
return(this.GetCompositeAssociation(relationType));
}
public Relation(int parentId, int childId, IRelationType relationType)
{
_parentId = parentId;
_childId = childId;
_relationType = relationType;
}
public string GetTableName(IRelationType relationType)
{
string tableName;
this.tableNameByRelationType.TryGetValue(relationType, out tableName);
return tableName;
}
protected void LoadCompositeRelations(IRelationType relationType, List<CompositeRelation> relations)
{
while (this.reader.Read())
{
switch (this.reader.NodeType)
{
case XmlNodeType.Element:
if (this.reader.Name.Equals(Serialization.Relation))
{
var associationIdString = this.reader.GetAttribute(Serialization.Association);
if (string.IsNullOrEmpty(associationIdString))
{
throw new Exception("Association id is missing");
}
if (this.reader.IsEmptyElement)
{
throw new Exception("Role is missing");
}
var association = this.database.ObjectIds.Parse(associationIdString);
IObjectType associationConcreteClass;
this.objectTypeByObjectId.TryGetValue(association, out associationConcreteClass);
var value = this.reader.ReadString();
var rs = value.Split(Serialization.ObjectsSplitterCharArray);
if (associationConcreteClass == null ||
!this.database.ContainsConcreteClass(relationType.AssociationType.ObjectType, associationConcreteClass) ||
(relationType.RoleType.IsOne && rs.Length > 1))
{
foreach (var r in rs)
{
this.OnRelationNotLoaded(relationType.Id, associationIdString, r);
}
}
else
{
foreach (var r in rs)
{
var role = this.database.ObjectIds.Parse(r);
IObjectType roleConcreteClass;
this.objectTypeByObjectId.TryGetValue(role, out roleConcreteClass);
if (roleConcreteClass == null ||
!this.database.ContainsConcreteClass(relationType.RoleType.ObjectType, roleConcreteClass))
{
this.OnRelationNotLoaded(relationType.Id, associationIdString, r);
}
else
{
relations.Add(new CompositeRelation(association, role));
}
}
}
}
else
{
throw new Exception("Unknown child element <" + this.reader.Name + "> in parent element <" + Serialization.RelationTypeComposite + ">");
}
break;
case XmlNodeType.EndElement:
if (!this.reader.Name.Equals(Serialization.RelationTypeComposite))
{
throw new Exception("Expected closing element </" + Serialization.RelationTypeComposite + ">");
}
return;
}
}
}
protected void LoadUnitRelations(IRelationType relationType, Dictionary<IObjectType, List<UnitRelation>> relationsByExclusiveRootClass)
{
while (this.reader.Read())
{
switch (this.reader.NodeType)
{
case XmlNodeType.Element:
if (this.reader.Name.Equals(Serialization.Relation))
{
var associationIdString = this.reader.GetAttribute(Serialization.Association);
if (string.IsNullOrEmpty(associationIdString))
{
throw new Exception("Association id is missing");
}
var associationId = this.database.ObjectIds.Parse(associationIdString);
IObjectType associationConcreteClass;
this.objectTypeByObjectId.TryGetValue(associationId, out associationConcreteClass);
if (this.reader.IsEmptyElement)
{
if (associationConcreteClass == null ||
!this.database.ContainsConcreteClass(relationType.AssociationType.ObjectType, associationConcreteClass))
{
this.OnRelationNotLoaded(relationType.Id, associationIdString, string.Empty);
}
else
{
var exclusiveRootClass = associationConcreteClass;
switch (((IUnit)relationType.RoleType.ObjectType).UnitTag)
{
case UnitTags.AllorsString:
{
List<UnitRelation> relations;
if (
!relationsByExclusiveRootClass.TryGetValue(associationConcreteClass, out relations))
{
relations = new List<UnitRelation>();
relationsByExclusiveRootClass[exclusiveRootClass] = relations;
}
var unitRelation = new UnitRelation(associationId, string.Empty);
relations.Add(unitRelation);
}
break;
case UnitTags.AllorsBinary:
{
List<UnitRelation> relations;
if (!relationsByExclusiveRootClass.TryGetValue(associationConcreteClass, out relations))
{
relations = new List<UnitRelation>();
relationsByExclusiveRootClass[exclusiveRootClass] = relations;
}
var unitRelation = new UnitRelation(associationId, EmptyByteArray);
relations.Add(unitRelation);
}
break;
default:
this.OnRelationNotLoaded(relationType.Id, associationIdString, string.Empty);
break;
}
}
}
else
{
var value = this.reader.ReadString();
if (associationConcreteClass == null ||
!this.database.ContainsConcreteClass(relationType.AssociationType.ObjectType, associationConcreteClass))
{
this.OnRelationNotLoaded(relationType.Id, associationIdString, value);
}
else
{
try
{
var exclusiveRootClass = (IComposite)associationConcreteClass;
var unitTypeTag = ((IUnit)relationType.RoleType.ObjectType).UnitTag;
var unit = Serialization.ReadString(value, unitTypeTag);
List<UnitRelation> relations;
if (!relationsByExclusiveRootClass.TryGetValue(associationConcreteClass, out relations))
{
relations = new List<UnitRelation>();
relationsByExclusiveRootClass[exclusiveRootClass] = relations;
}
var unitRelation = new UnitRelation(associationId, unit);
relations.Add(unitRelation);
}
catch
{
this.OnRelationNotLoaded(relationType.Id, associationIdString, value);
}
}
}
}
else
{
throw new Exception("Unknown child element <" + this.reader.Name + "> in parent element <" + Serialization.RelationTypeUnit + ">");
}
break;
case XmlNodeType.EndElement:
if (!this.reader.Name.Equals(Serialization.RelationTypeUnit))
{
throw new Exception("Expected closing element </" + Serialization.RelationTypeUnit + ">");
}
return;
}
}
}
public RelationType()
{
_type = new EmptyType();
}
public string GetProcedureNameForGetAssociation(IRelationType relationType)
{
string procedureName;
this.procedureNameForGetAssociationByRelationType.TryGetValue(relationType, out procedureName);
return procedureName;
}
public RelationType(IRelationType type)
{
_type = type;
}
/// <summary>
/// Deletes all <see cref="Relation"/> objects based on the passed in <see cref="RelationType"/>
/// </summary>
/// <param name="relationType"><see cref="RelationType"/> to Delete Relations for</param>
public void DeleteRelationsOfType(IRelationType relationType)
{
var uow = _uowProvider.GetUnitOfWork();
using (var repository = _repositoryFactory.CreateRelationRepository(uow))
{
var query = new Query<IRelation>().Where(x => x.RelationTypeId == relationType.Id);
var list = repository.GetByQuery(query).ToList();
foreach (var relation in list)
{
repository.Delete(relation);
}
uow.Commit();
}
}
/// <summary>
/// Relates two objects that are based on the <see cref="IUmbracoEntity"/> interface.
/// </summary>
/// <param name="parent">Parent entity</param>
/// <param name="child">Child entity</param>
/// <param name="relationType">The type of relation to create</param>
/// <returns>The created <see cref="Relation"/></returns>
public IRelation Relate(IUmbracoEntity parent, IUmbracoEntity child, IRelationType relationType)
{
//Ensure that the RelationType has an indentity before using it to relate two entities
if(relationType.HasIdentity == false)
Save(relationType);
var relation = new Relation(parent.Id, child.Id, relationType);
var uow = _uowProvider.GetUnitOfWork();
using (var repository = _repositoryFactory.CreateRelationRepository(uow))
{
repository.AddOrUpdate(relation);
uow.Commit();
return relation;
}
}
/// <summary>
/// Checks whether any relations exists for the passed in <see cref="RelationType"/>.
/// </summary>
/// <param name="relationType"><see cref="RelationType"/> to check for relations</param>
/// <returns>Returns <c>True</c> if any relations exists for the given <see cref="RelationType"/>, otherwise <c>False</c></returns>
public bool HasRelations(IRelationType relationType)
{
using (var repository = _repositoryFactory.CreateRelationRepository(_uowProvider.GetUnitOfWork()))
{
var query = new Query<IRelation>().Where(x => x.RelationTypeId == relationType.Id);
return repository.GetByQuery(query).Any();
}
}
/// <summary>
/// Deletes a <see cref="RelationType"/>
/// </summary>
/// <param name="relationType">RelationType to Delete</param>
public void Delete(IRelationType relationType)
{
var uow = _uowProvider.GetUnitOfWork();
using (var repository = _repositoryFactory.CreateRelationTypeRepository(uow))
{
repository.Delete(relationType);
uow.Commit();
}
}
private void LoadCompositeRelations(IRelationType relationType)
{
while (this.reader.Read())
{
switch (this.reader.NodeType)
{
// eat everything but elements
case XmlNodeType.Element:
if (this.reader.Name.Equals(Serialization.Relation))
{
var associationId = this.session.ObjectIds.Parse(this.reader.GetAttribute(Serialization.Association));
var association = this.LoadInstantiateStrategy(associationId);
var value = string.Empty;
if (!this.reader.IsEmptyElement)
{
value = this.reader.ReadString();
}
if (!this.reader.IsEmptyElement)
{
var roleIdsString = value;
var roleIdStringArray = roleIdsString.Split(Serialization.ObjectsSplitterCharArray);
if (association == null ||
!this.session.MemoryDatabase.ContainsConcreteClass(relationType.AssociationType.ObjectType, association.UncheckedObjectType) ||
(relationType.RoleType.IsOne && roleIdStringArray.Length != 1))
{
foreach (var roleId in roleIdStringArray)
{
this.session.MemoryDatabase.OnRelationNotLoaded(relationType.Id, associationId.ToString(), roleId);
}
}
else
{
if (relationType.RoleType.IsOne)
{
var roleIdString = this.session.ObjectIds.Parse(roleIdStringArray[0]);
var role = this.LoadInstantiateStrategy(roleIdString);
if (role == null || !this.session.MemoryDatabase.ContainsConcreteClass((IComposite)relationType.RoleType.ObjectType, role.UncheckedObjectType))
{
this.session.MemoryDatabase.OnRelationNotLoaded(relationType.Id, associationId.ToString(), roleIdStringArray[0]);
}
else
{
if (relationType.RoleType.AssociationType.IsMany)
{
association.SetCompositeRoleMany2One(relationType.RoleType, role.GetObject());
}
else
{
association.SetCompositeRoleOne2One(relationType.RoleType, role.GetObject());
}
}
}
else
{
var roleStrategies = new HashSet<Strategy>();
foreach (var roleIdString in roleIdStringArray)
{
var roleId = this.session.ObjectIds.Parse(roleIdString);
var role = this.LoadInstantiateStrategy(roleId);
if (role == null || !this.session.MemoryDatabase.ContainsConcreteClass((IComposite)relationType.RoleType.ObjectType, role.UncheckedObjectType))
{
this.session.MemoryDatabase.OnRelationNotLoaded(relationType.Id, associationId.ToString(), roleId.ToString());
}
else
{
roleStrategies.Add(role);
}
}
if (relationType.RoleType.AssociationType.IsMany)
{
association.SetCompositeRolesMany2Many(relationType.RoleType, roleStrategies);
}
else
{
association.SetCompositesRoleOne2Many(relationType.RoleType, roleStrategies);
}
}
}
}
}
else
{
throw new Exception("Unknown child element <" + this.reader.Name + "> in parent element <" + Serialization.RelationTypeComposite + ">");
}
break;
case XmlNodeType.EndElement:
if (!this.reader.Name.Equals(Serialization.RelationTypeComposite))
{
throw new Exception("Expected closing element </" + Serialization.RelationTypeComposite + ">");
}
return;
}
}
}
private void ValidateRelationType(IRelationType type)
{
if (_relationTypes.ContainsKey(type.Name))
{
throw new InvalidRelationTypeException(type.Name, "Relation type with that name already registered.");
}
if (type.RoleInfos.Count == 0)
{
throw new InvalidRelationTypeException(type.Name, "Relation type contains no roles.");
}
foreach (RoleInfo info in type.RoleInfos)
{
if (info == null)
{
throw new InvalidRelationTypeException(type.Name, "Relation type contains null RoleInfo.");
}
foreach (RoleInfo i in type.RoleInfos)
{
if (!object.ReferenceEquals(i, info) && i.Name == info.Name)
{
throw new InvalidRelationTypeException(type.Name, "Relation type contains two roles with same name.");
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RelationTypeOneXmlWriter"/> class.
/// </summary>
/// <param name="relationType">Type of the relation.</param>
/// <param name="xmlWriter">The XML writer.</param>
internal RelationTypeOneXmlWriter(IRelationType relationType, XmlWriter xmlWriter)
{
this.relationType = relationType;
this.xmlWriter = xmlWriter;
this.isClosed = false;
}
public string GetProcedureNameForSetRole(IRelationType relationType)
{
string procedureName;
this.procedureNameForSetRoleByRelationType.TryGetValue(relationType, out procedureName);
return procedureName;
}
private void LoadUnitRelations(IRelationType relationType)
{
while (this.reader.Read())
{
switch (this.reader.NodeType)
{
// eat everything but elements
case XmlNodeType.Element:
if (this.reader.Name.Equals(Serialization.Relation))
{
var associationIdString = this.reader.GetAttribute(Serialization.Association);
var associationId = this.session.ObjectIds.Parse(associationIdString);
var strategy = this.LoadInstantiateStrategy(associationId);
var value = string.Empty;
if (!this.reader.IsEmptyElement)
{
value = this.reader.ReadString();
}
if (strategy == null)
{
this.session.MemoryDatabase.OnRelationNotLoaded(relationType.Id, associationIdString, value);
}
else
{
try
{
this.session.MemoryDatabase.UnitRoleChecks(strategy, relationType.RoleType);
if (this.reader.IsEmptyElement)
{
var unitType = (IUnit)relationType.RoleType.ObjectType;
switch (unitType.UnitTag)
{
case UnitTags.AllorsString:
strategy.SetUnitRole(relationType.RoleType, string.Empty);
break;
case UnitTags.AllorsBinary:
strategy.SetUnitRole(relationType.RoleType, emptyByteArray);
break;
}
}
else
{
var unitType = (IUnit)relationType.RoleType.ObjectType;
var unitTypeTag = unitType.UnitTag;
var unit = Serialization.ReadString(value, unitTypeTag);
strategy.SetUnitRole(relationType.RoleType, unit);
}
}
catch
{
this.session.MemoryDatabase.OnRelationNotLoaded(relationType.Id, associationId.ToString(), value);
}
}
}
else
{
throw new Exception("Unknown child element <" + this.reader.Name + "> in parent element <" + Serialization.RelationTypeUnit + ">");
}
break;
case XmlNodeType.EndElement:
if (!this.reader.Name.Equals(Serialization.RelationTypeUnit))
{
throw new Exception("Expected closing element </" + Serialization.RelationTypeUnit + ">");
}
return;
}
}
}
private void LoadUnitRelations(XmlReader reader, IRelationType relationType)
{
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
if (reader.Name.Equals(Serialization.Relation))
{
var associationString = reader.GetAttribute(Serialization.Association);
var association = ObjectIds.Parse(associationString);
if (reader.IsEmptyElement)
{
object role;
// OnRelationNotLoaded(relationType.Id, association.ToString(), String.Empty);
if (relationType.RoleType.ObjectType.Id == UnitIds.StringId)
{
role = string.Empty;
}
else if (relationType.RoleType.ObjectType.Id == UnitIds.BinaryId)
{
role = EmptyByteArray;
}
else
{
this.OnRelationNotLoaded(relationType.Id, association.ToString(), string.Empty);
continue;
}
var cmdText = @"
INSERT INTO " + this.SchemaName + "." + this.Mapping.GetTableName(relationType) + " (" + Mapping.ColumnNameForAssociation + "," + Mapping.ColumnNameForRole + @")
VALUES (" + Mapping.ParameterNameForAssociation + "," + Mapping.ParameterNameForRole + ")";
using (var command = this.CreateCommand(cmdText))
{
command.Parameters.Add(Mapping.ParameterNameForAssociation, this.mapping.SqlDbTypeForObject).Value = association.Value;
command.Parameters.Add(Mapping.ParameterNameForRole, this.mapping.GetSqlDbType(relationType.RoleType)).Value = role;
command.ExecuteNonQuery();
}
}
else
{
var value = reader.ReadString();
try
{
// TODO:
// OnRelationNotLoaded(relationType.Id, association.ToString(), value);
var unitTypeTag = ((IUnit)relationType.RoleType.ObjectType).UnitTag;
var role = Serialization.ReadString(value, unitTypeTag);
var cmdText = @"
INSERT INTO " + this.SchemaName + "." + this.Mapping.GetTableName(relationType) + " (" + Mapping.ColumnNameForAssociation + "," + Mapping.ColumnNameForRole + @")
VALUES (" + Mapping.ParameterNameForAssociation + "," + Mapping.ParameterNameForRole + ")";
using (var command = this.CreateCommand(cmdText))
{
command.Parameters.Add(Mapping.ParameterNameForAssociation, this.mapping.SqlDbTypeForObject).Value = association.Value;
command.Parameters.Add(Mapping.ParameterNameForRole, this.Mapping.GetSqlDbType(relationType.RoleType)).Value = role;
command.ExecuteNonQuery();
}
}
catch
{
this.OnRelationNotLoaded(relationType.Id, association.ToString(), value);
}
}
}
break;
case XmlNodeType.EndElement:
return;
}
}
}
private void LoadCompositeRelations(XmlReader reader, IRelationType relationType)
{
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
if (reader.Name.Equals(Serialization.Relation))
{
var associationString = reader.GetAttribute(Serialization.Association);
var association = ObjectIds.Parse(associationString);
if (reader.IsEmptyElement)
{
this.OnRelationNotLoaded(relationType.Id, association.ToString(), null);
}
else
{
var value = reader.ReadString();
var roleStrings = value.Split(Serialization.ObjectsSplitterCharArray);
if (relationType.RoleType.IsOne && roleStrings.Length > 1)
{
foreach (var roleString in roleStrings)
{
this.OnRelationNotLoaded(relationType.Id, association.ToString(), roleString);
}
}
foreach (var roleString in roleStrings)
{
var role = ObjectIds.Parse(roleString);
//this.OnRelationNotLoaded(relationType.Id, association.ToString(), r);
var cmdText = @"
INSERT INTO " + this.SchemaName + "." + this.Mapping.GetTableName(relationType) + " (" + Mapping.ColumnNameForAssociation + "," + Mapping.ColumnNameForRole + @")
VALUES (" + Mapping.ParameterNameForAssociation + "," + Mapping.ParameterNameForRole + ")";
using (var command = this.CreateCommand(cmdText))
{
command.Parameters.Add(Mapping.ParameterNameForAssociation, this.mapping.SqlDbTypeForObject).Value = association.Value;
command.Parameters.Add(Mapping.ParameterNameForRole, this.mapping.SqlDbTypeForObject).Value = role.Value;
command.ExecuteNonQuery();
}
}
}
}
break;
case XmlNodeType.EndElement:
return;
}
}
}
private void CreateIndex(SqlConnection connection, string indexName, IRelationType relationType, string tableName)
{
var sql = new StringBuilder();
sql.Append("CREATE INDEX " + indexName + "\n");
sql.Append("ON " + tableName + " (" + this.mapping.ColumnNameByRelationType[relationType] + ")");
using (var command = new SqlCommand(sql.ToString(), connection))
{
command.ExecuteNonQuery();
}
}
