/// <summary>
/// Indicate the source/target columns for the foreign key connector
/// </summary>
public override string GetToolTipText(DiagramItem item)
{
BinaryAssociation link = ((BarkerErModelContainsBinaryAssociation)ModelElement).BinaryAssociation;
return(string.Format(
"Association #{0}; Role 1: {1}, Role 2: {2}",
link.Number, link.RoleCollection[0].PredicateText, link.RoleCollection[1].PredicateText));
}
/// <summary>
/// for many-to-many associations; it is assumed that IsSimpleManyToManyAssociation has been
/// called on the passed-in concept type and returned true
/// </summary>
/// <param name="parentConceptType"></param>
/// <param name="notifyAdded"></param>
/// <param name="associationCounter"></param>
private static void CreateBinaryAssociation(ConceptType parentConceptType, INotifyElementAdded notifyAdded, ref int associationCounter)
{
if (BinaryAssociationHasConceptType.GetBinaryAssociation(parentConceptType).Count == 0)
{
LinkedElementCollection <ConceptTypeChild> associationChildren =
ConceptTypeHasChildAsPartOfAssociation.GetTargetCollection(parentConceptType);
ConceptTypeChild relation1, relation2;
ConceptType ct1, ct2;
if (null != (relation1 = associationChildren[0]) &&
null != (relation2 = associationChildren[1]) &&
null != (ct1 = relation1.Target as ConceptType) &&
null != (ct2 = relation2.Target as ConceptType))
{
// create association
BinaryAssociation b = new BinaryAssociation(parentConceptType.Store,
new PropertyAssignment[] { new PropertyAssignment(BinaryAssociation.NumberDomainPropertyId, associationCounter++) });
//new BinaryAssociationHasConceptTypeChild(b, relation);
BinaryAssociationHasConceptType.GetConceptType(b).Add(parentConceptType);
Role r1 = new Role(parentConceptType.Store,
new PropertyAssignment[] { new PropertyAssignment(Role.PredicateTextDomainPropertyId, ct1.Name) });
Role r2 = new Role(parentConceptType.Store,
new PropertyAssignment[] { new PropertyAssignment(Role.PredicateTextDomainPropertyId, ct2.Name) });
b.RoleCollection.Add(r1);
b.RoleCollection.Add(r2);
EntityType sourceEntity = EntityTypeIsPrimarilyForConceptType.GetEntityType(ct1);
EntityType targetEntity = EntityTypeIsPrimarilyForConceptType.GetEntityType(ct2);
sourceEntity.RoleCollection.Add(r1);
targetEntity.RoleCollection.Add(r2);
sourceEntity.BarkerErModel.BinaryAssociationCollection.Add(b);
//determine whether roles are mandatory or optional
//TODO
//set multi-values
r1.IsMultiValued = true;
r2.IsMultiValued = true;
//notify elements added
if (notifyAdded != null)
{
notifyAdded.ElementAdded(b, true);
notifyAdded.ElementAdded(r1, true);
notifyAdded.ElementAdded(r2, true);
}
}
}
}
/// <summary>
/// for regular relationships
/// </summary>
/// <param name="relation"></param>
/// <param name="source"></param>
/// <param name="target"></param>
/// <param name="notifyAdded"></param>
/// <param name="associationCounter"></param>
/// <returns></returns>
private static bool CreateBinaryAssociation(ConceptTypeChild relation, ConceptType source, ConceptType target, INotifyElementAdded notifyAdded, ref int associationCounter)
{
if (BinaryAssociationHasConceptTypeChild.GetBinaryAssociation(relation).Count > 0)
{
//it has already been created
return(true);
}
else if (EntityTypeIsPrimarilyForConceptType.GetEntityType(target) != null)
{
#region create association
BinaryAssociation b = new BinaryAssociation(relation.Store,
new PropertyAssignment[] { new PropertyAssignment(BinaryAssociation.NumberDomainPropertyId, associationCounter++) });
//new BinaryAssociationHasConceptTypeChild(b, relation);
BinaryAssociationHasConceptTypeChild.GetConceptTypeChildPath(b).Add(relation);
Role r1 = new Role(relation.Store,
new PropertyAssignment[] { new PropertyAssignment(Role.PredicateTextDomainPropertyId, source.Name) });
Role r2 = new Role(relation.Store,
new PropertyAssignment[] { new PropertyAssignment(Role.PredicateTextDomainPropertyId, target.Name) });
b.RoleCollection.Add(r1);
b.RoleCollection.Add(r2);
EntityType sourceEntity = EntityTypeIsPrimarilyForConceptType.GetEntityType(source);
EntityType targetEntity = EntityTypeIsPrimarilyForConceptType.GetEntityType(target);
sourceEntity.RoleCollection.Add(r1);
targetEntity.RoleCollection.Add(r2);
sourceEntity.BarkerErModel.BinaryAssociationCollection.Add(b);
#endregion
//determine whether roles are mandatory or optional
List <ConceptTypeChild> links = new List <ConceptTypeChild>(1);
links.Add(relation);
r1.IsMandatory = AllStepsMandatory(targetEntity, links);
if (relation is ConceptTypeAssimilatesConceptType)
{
r2.IsMandatory = AllStepsMandatory(sourceEntity, links);
}
#region determine whether roles are multivalued or not - and possibly rename
ORMCore.ObjectType sourceObjectType = ConceptTypeIsForObjectType.GetObjectType(source);
ORMCore.ObjectType targetObjectType = ConceptTypeIsForObjectType.GetObjectType(target);
ORMCore.UniquenessConstraint uSource = null, uTarget = null;
foreach (ORMCore.FactType factType in ConceptTypeChildHasPathFactType.GetPathFactTypeCollection(relation))
{
Debug.Assert(factType.RoleCollection.Count == 2, "Error when mapping to Barker ER; the fact type is not binary");
foreach (ORMCore.RoleBase r in factType.RoleCollection)
{
//need to use RoleBase because we might run into RoleProxy
ORMCore.Role role = r.Role;
foreach (ORMCore.ConstraintRoleSequence constraintRoleSequence in role.ConstraintRoleSequenceCollection)
{
ORMCore.UniquenessConstraint uninquenessConstraint = constraintRoleSequence as ORMCore.UniquenessConstraint;
if (uninquenessConstraint != null && //check that it's a uniqueness constraint
uninquenessConstraint.Modality == ORMCore.ConstraintModality.Alethic && //check it's alethic
uninquenessConstraint.IsInternal) //check it's internal
{
if (role.RolePlayer == sourceObjectType)
{
uSource = uninquenessConstraint;
}
if (role.RolePlayer == targetObjectType)
{
uTarget = uninquenessConstraint;
}
}
}
}
//name the roles properly
//TODO this is a hack; proper name generation is yet to be implemented
foreach (ORMCore.ReadingOrder order in factType.ReadingOrderCollection)
{
string text = order.ReadingText;
int first = text.IndexOf('}') + 1;
text = text.Substring(first, text.LastIndexOf('{') - first);
text = text.Trim();
if (!string.IsNullOrEmpty(text) &&
order.RoleCollection != null && order.RoleCollection.Count > 0 &&
order.RoleCollection[0].Role != null)
{
ORMCore.ObjectType o = order.RoleCollection[0].Role.RolePlayer;
if (o == sourceObjectType)
{
r1.PredicateText = text;
}
else if (o == targetObjectType)
{
r2.PredicateText = text;
}
}
}
}
if (uSource != null && uSource == uTarget)
{
//it's many-to-many
r1.IsMultiValued = true;
r2.IsMultiValued = true;
}
else if (uSource == null || uTarget == null)
{
//it's one-to-many
r1.IsMultiValued = uSource != null;
r2.IsMultiValued = uTarget != null;
}
else if (uSource != null && uTarget != null)
{
//it's one-to-one
r1.IsMultiValued = false;
r2.IsMultiValued = false;
}
else
{
Debug.Fail("Found a fact type with no uniqueness constraints!");
}
#endregion
#region primary id?
foreach (Uniqueness u in UniquenessIncludesConceptTypeChild.GetUniquenessCollection(relation))
{
if (u.IsPreferred)
{
r1.IsPrimaryIdComponent = true;
break;
}
}
#endregion
//notify elements added
if (notifyAdded != null)
{
notifyAdded.ElementAdded(b, true);
notifyAdded.ElementAdded(r1, true);
notifyAdded.ElementAdded(r2, true);
}
return(true);
}
else
{
//should not create binary association in this case
return(false);
}
}