private bool IsDependentInOneToOneWith(EntityType entity, EntityType other)
{
return(entity.NavigationProperties.Any(p =>
DependsOn(p, other) &&
CodeGenerationHelper.GetAssociationType(p) == AssociationTypes.OneToOne &&
CodeGenerationHelper.IsPrincipal(p)));
}
/// <summary>
/// BFS algorithm
/// </summary>
public IList <EntityType> GetPartialDependencyOrder(IList <EntityType> entities, out bool converged)
{
//Discard abstract entities
//Consider entities to be treated with principal as done
//Start with independent entities and consider them as done also
IList <EntityType> abstractEntities = CodeGenerationHelper.GetAbstractEntities(entities).ToList();
IList <EntityType> entitiesToTreatWithPrincipal = GetEntitiesToTreatWithPrincipal(entities);
IList <EntityType> discardedEntities = abstractEntities.Concat(entitiesToTreatWithPrincipal).ToList();
IList <EntityType> toTreatEntities = entities.Where(x => !discardedEntities.Contains(x)).ToList(); //missing some Diff operation...
IList <EntityType> treatedEntities = new List <EntityType>();;
//While not all entities are treated
converged = true;
int previousToTreatEntitiesCount = 0;
do
{
if (previousToTreatEntitiesCount == toTreatEntities.Count)
{
converged = false; //Algorithm cannot converge, check the model...
break;
}
previousToTreatEntitiesCount = toTreatEntities.Count;
IList <EntityType> readyToTreatEntities = GetReadyToTreatEntities(discardedEntities, treatedEntities, toTreatEntities);
treatedEntities = treatedEntities.Concat(readyToTreatEntities).ToList();
toTreatEntities = toTreatEntities.Where(x => !treatedEntities.Contains(x)).ToList();
} while (toTreatEntities.Count > 0);
return(treatedEntities);
}
private bool HasNonNavigableToOneLinkWith(EntityType entity, EntityType other)
{
return
(entity.NavigationProperties.Any(p =>
DependsOn(p, other) &&
CodeGenerationHelper.Inverse(p) == null &&
p.FromEndMember.RelationshipMultiplicity == RelationshipMultiplicity.One));
}
public NonUniqueIndex GetNonUniqueIndexFor <T>(params string[] columns)
{
return(new NonUniqueIndex
{
TableName = CodeGenerationHelper.GetTableName <T>(),
ColumnNames = columns.ToList()
});
}
private IList <EntityType> GetReadyToTreatEntities(IList <EntityType> discardedEntities, IList <EntityType> treatedEntities, IList <EntityType> toTreatEntities)
{
return(toTreatEntities
.Where(x => x.NavigationProperties
.All(y => !CodeGenerationHelper.IsToOne(y) ||
discardedEntities.Contains(y.ToEndMember.GetEntityType()) ||
treatedEntities.Contains(y.ToEndMember.GetEntityType())))
.OrderBy(x => x.Name)
.ToList());
}
public IList <EntityType> AllExceptIgnoredAbstractAndDerived()
{
var allButIgnored = AllButIgnored();
var abstractEntities = CodeGenerationHelper.GetAbstractEntities(allButIgnored);
IEnumerable <EntityType> derived = new List <EntityType>();
foreach (var entity in abstractEntities)
{
derived = derived.Concat(CodeGenerationHelper.GetDerivedTypes(entity, allButIgnored));
}
return(allButIgnored
.Except(abstractEntities)
.Except(derived)
.ToList());
}
public IList <EntityType> AllButIgnored()
{
return(entities_.Where(e => !CodeGenerationHelper.Ignore(e) && !CodeGenerationHelper.IgnoreButInterAssembly(e)).OrderBy(e => e.Name).ToList());
}
private bool HasZeroOrOneToManyWithNoInverseWith(EntityType entity, EntityType other)
{
return(entity.NavigationProperties.Any(p => DependsOn(p, other) && CodeGenerationHelper.IsZeroOrOneToMany(p) && CodeGenerationHelper.Inverse(p) == null));
}
private bool HasManyToManyAndIsGreaterLexicographicallyThan(EntityType entity, EntityType other)
{
return(entity.NavigationProperties.Any(p => DependsOn(p, other) && CodeGenerationHelper.IsManyToMany(p) && !CodeGenerationHelper.IsLexicographicallyOrdered(p)));
}
private Table SmoTableFor <T>()
{
return(SmoDatabase.Tables[CodeGenerationHelper.GetTableName <T>()]);
}