private static EntityType GetOrCreateEntityType(
Type type,
ModelConfiguration modelConfiguration,
BreezeMetadata metadata)
{
if (metadata.StructuralTypes.FirstOrDefault(o => o.Type == type) is EntityType entityType)
{
return(entityType);
}
entityType = new EntityType(type)
{
DefaultResourceName = modelConfiguration.ResourceName,
AutoGeneratedKeyType = AutoGeneratedKeyType.KeyGenerator,
Custom = modelConfiguration.Custom
};
if (entityType.DefaultResourceName != null)
{
metadata.ResourceEntityTypeMap.Add(modelConfiguration.ResourceName, GetBreezeTypeFullName(type));
}
metadata.StructuralTypes.Add(entityType);
return(entityType);
}
private void AddComplexType(
IAbstractComponentType componentType,
ModelConfiguration modelConfiguration,
BreezeMetadata metadata,
bool partOfKey,
ISessionFactoryImplementor sessionFactory)
{
var type = componentType.ReturnedClass;
if (!_addedTypes.Add(type))
{
return;
}
var complexType = new ComplexType(type)
{
Custom = modelConfiguration.Custom
};
AddDataProperties(
componentType.PropertyNames,
componentType.Subtypes,
componentType.PropertyNullability,
null,
null,
partOfKey,
complexType,
modelConfiguration,
metadata,
sessionFactory);
// Add complex types at the beginning of the list
metadata.StructuralTypes.Insert(0, complexType);
}
private void AddComplexType(Type type, BreezeMetadata metadata)
{
if (!_addedTypes.Add(type))
{
return;
}
var modelConfiguration = _breezeConfigurator.GetModelConfiguration(type);
var complexType = new ComplexType(type)
{
Custom = modelConfiguration.Custom
};
foreach (var property in type.GetProperties())
{
if (!_dataTypeProvider.TryGetDataType(property.PropertyType, out var dataType))
{
continue;
}
complexType.DataProperties.Add(
CreateDataProperty(
property.Name,
dataType,
false,
IsNullable(property.PropertyType),
false,
modelConfiguration.GetMember(property.Name),
complexType,
null));
}
// Add complex types at the beginning of the list
metadata.StructuralTypes.Insert(0, complexType);
}
private void AddProperties(
EntityMetadata entityMetadata,
EntityType entityType,
ModelConfiguration modelConfiguration,
BreezeMetadata metadata)
{
var persister = entityMetadata.EntityPersister;
AddDataProperties(
persister.PropertyNames,
persister.PropertyTypes,
persister.PropertyNullability,
entityMetadata.DerivedPropertyNames,
persister.VersionProperty,
false,
entityType,
modelConfiguration,
metadata,
persister.Factory);
AddIdentifierProperties(persister, entityType, modelConfiguration, entityMetadata, metadata);
AddSyntheticMembers(entityType, modelConfiguration);
AddSyntheticForeignKeyProperties(entityMetadata, entityType, modelConfiguration);
AddIncludedMembers(entityType, modelConfiguration, entityMetadata);
// We do the association properties after the data properties, so we can do the foreign key lookups
AddAssociationProperties(
persister.PropertyNames,
persister.PropertyTypes,
false,
i => persister.PropertyCascadeStyles[i],
entityType,
entityMetadata.DerivedPropertyNames,
modelConfiguration,
entityMetadata);
}
public NorthwindIBModelController(
ISession session,
NorthwindPersistenceManager persistenceManager,
BreezeMetadata metadata)
{
_session = session;
_persistenceManager = persistenceManager;
_metadata = metadata;
}
public BreezeController(
ISession session,
PersistenceManager persistenceManager,
BreezeMetadata metadata)
{
_session = session;
_persistenceManager = persistenceManager;
_metadata = metadata;
}
public MultipleDatabaseController(
PersistenceManager persistenceManager,
BreezeMetadata metadata,
BarSession barSession,
FooSession fooSession)
{
_persistenceManager = persistenceManager;
_metadata = metadata;
_barSession = barSession;
_fooSession = fooSession;
}
private void AddIdentifierProperties(
AbstractEntityPersister persister,
EntityType entityType,
ModelConfiguration modelConfiguration,
EntityMetadata entityMetadata,
BreezeMetadata metadata)
{
// Add the identifier properties only for the root class
if (persister.IsInherited)
{
return;
}
if (persister.HasIdentifierProperty)
{
var memberConfiguration = modelConfiguration.GetMember(persister.IdentifierPropertyName);
var dataProperty = CreateDataProperty(
persister.IdentifierPropertyName,
persister.IdentifierType,
true,
false,
false,
memberConfiguration,
entityType,
persister.Factory);
entityType.DataProperties.Insert(0, dataProperty);
}
else if (persister.IdentifierType is IAbstractComponentType componentType)
{
modelConfiguration = _breezeConfigurator.GetModelConfiguration(componentType.ReturnedClass);
AddDataProperties(
componentType.PropertyNames,
componentType.Subtypes,
componentType.PropertyNullability,
null,
null,
true,
entityType,
modelConfiguration,
metadata,
persister.Factory);
AddAssociationProperties(
componentType.PropertyNames,
componentType.Subtypes,
true,
i => componentType.GetCascadeStyle(i),
entityType,
null,
modelConfiguration,
entityMetadata);
}
}
private BreezeMetadata GetMetadataFromContext(DbContext dbContext)
{
var metadata = new BreezeMetadata();
metadata.StructuralTypes = dbContext.Model.GetEntityTypes().Select(et => {
var mt = new MetaType();
metadata.StructuralTypes.Add(mt);
mt.ShortName = et.Name;
mt.Namespace = et.ClrType.Namespace;
mt.DataProperties = et.GetProperties().Select(p => {
var dp = new MetaDataProperty();
dp.NameOnServer = p.Name;
dp.IsNullable = p.IsNullable;
dp.IsPartOfKey = p.IsPrimaryKey();
dp.MaxLength = p.GetMaxLength();
dp.DataType = p.ClrType.ToString();
dp.ConcurrencyMode = p.IsConcurrencyToken ? "None" : "Identity";
var dfa = p.GetAnnotations().Where(a => a.Name == "DefaultValue").FirstOrDefault();
if (dfa != null)
{
dp.DefaultValue = dfa.Value;
}
return(dp);
}).ToList();
mt.NavigationProperties = et.GetNavigations().Select(p => {
var np = new MetaNavProperty();
np.NameOnServer = p.Name;
np.EntityTypeName = p.GetTargetType().Name;
np.IsScalar = !p.IsCollection();
// FK_<dependent type name>_<principal type name>_<foreign key property name>
np.AssociationName = BuildAssocName(p);
if (p.IsDependentToPrincipal())
{
np.AssociationName = BuildAssocName(p);
np.ForeignKeyNamesOnServer = p.ForeignKey.Properties.Select(fkp => fkp.Name).ToList();
}
else
{
np.AssociationName = BuildAssocName(p.FindInverse());
np.InvForeignKeyNamesOnServer = p.ForeignKey.Properties.Select(fkp => fkp.Name).ToList();
}
return(np);
}).ToList();
return(mt);
}).ToList();
return(metadata);
}
private BreezeMetadata GetMetadataFromContext(DbContext dbContext)
{
var metadata = new BreezeMetadata();
var dbSetMap = GetDbSetMap(dbContext);
metadata.StructuralTypes = dbContext.Model.GetEntityTypes()
.Where(et => !et.IsOwned())
.Select(et => CreateMetaType(et, dbSetMap)).ToList();
// get the enums out of the model types
// for nullable enum we must call Nullable.GetUnderlyingType
var enums = dbContext.Model.GetEntityTypes().Where(et => et.GetProperties().Any(p =>
p.PropertyInfo != null && (p.PropertyInfo.PropertyType.IsEnum || (Nullable.GetUnderlyingType(p.PropertyInfo.PropertyType) != null && Nullable.GetUnderlyingType(p.PropertyInfo.PropertyType).IsEnum))))
.Select(et => et.GetProperties().Where(p => p.PropertyInfo.PropertyType.IsEnum || (Nullable.GetUnderlyingType(p.PropertyInfo.PropertyType) != null && Nullable.GetUnderlyingType(p.PropertyInfo.PropertyType).IsEnum))).ToList();
foreach (var myEnum in enums)
{
var realType = myEnum.First().ClrType;
//check if realType is nullable
if (Nullable.GetUnderlyingType(realType) != null)
{
realType = Nullable.GetUnderlyingType(realType);
}
string[] enumNames = Enum.GetNames(realType);
var p = new Dictionary <string, object>();
p.Add("shortName", realType.Name);
p.Add("namespace", realType.Namespace);
p.Add("values", enumNames);
if (!metadata.EnumTypes.Exists(x => x.ContainsValue(realType.Name)))
{
metadata.EnumTypes.Add(p);
}
}
var complexTypes = dbContext.Model.GetEntityTypes()
.Where(et => et.IsOwned())
.Select(et => CreateMetaType(et, dbSetMap)).ToList();
// Complex types show up once per parent reference and we need to reduce
// this to just the unique types.
var complexTypesMap = complexTypes.ToDictionary(mt => mt.ShortName);
complexTypesMap.Values.ToList().ForEach(v => metadata.StructuralTypes.Insert(0, v));
return(metadata);
}
private void AddClientModelType(ClientModelMetadata modelMetadata, BreezeMetadata metadata)
{
var modelConfiguration = _breezeConfigurator.GetModelConfiguration(modelMetadata.Type);
var entityType = GetOrCreateEntityType(
modelMetadata.Type,
modelConfiguration,
metadata);
entityType.IsUnmapped = true;
foreach (var property in modelMetadata.Properties)
{
var memberConfiguration = modelConfiguration.GetMember(property.Name);
if (memberConfiguration?.Ignored == true)
{
continue;
}
if (property.IsAssociationType)
{
entityType.NavigationProperties.Add(CreateNavigationProperty(property, modelMetadata));
continue;
}
if (property.IsComplexType)
{
AddComplexType(property.Type, metadata);
}
var dataProperty = CreateDataProperty(property, memberConfiguration, entityType);
if (property.IsPartOfKey)
{
entityType.DataProperties.Insert(0, dataProperty);
}
else
{
entityType.DataProperties.Add(dataProperty);
}
}
AddSyntheticMembers(entityType, modelConfiguration);
AddSyntheticForeignKeyProperties(modelMetadata, entityType, modelConfiguration);
}
/// <summary>
/// Builds <see cref="BreezeMetadata"/>.
/// </summary>
/// <returns>The breeze metadata.</returns>
public BreezeMetadata Build()
{
var metadata = new BreezeMetadata
{
StructuralTypes = new List <StructuralType>(),
ResourceEntityTypeMap = new Dictionary <string, string>(),
EnumTypes = new List <EnumType>(),
LocalQueryComparisonOptions = _localQueryComparisonOptions ?? "caseInsensitiveSQL"
};
_addedTypes.Clear();
_entityMetadata = _classMetadataProvider.GetAll()
.Select(o => o.MappedClass)
.Where(o => o != null)
.Where(o => _includePredicate?.Invoke(o) ?? true)
.Distinct()
.Select(o => new { MappedClass = o, Metadata = _entityMetadataProvider.GetMetadata(o) })
.ToDictionary(o => o.MappedClass, o => o.Metadata);
foreach (var entityMetadata in _entityMetadata.Values)
{
AddEntityType(entityMetadata, metadata);
}
if (_clientModelAssemblies == null)
{
return(metadata);
}
// Add client models
_clientModelMetadata = _clientModelAssemblies?.SelectMany(assembly => assembly.GetTypes()
.Where(t => t.IsClass && !t.IsAbstract && _clientModelMetadataProvider.IsClientModel(t)))
.Where(t => _includePredicate?.Invoke(t) ?? true)
.Select(o => _clientModelMetadataProvider.GetMetadata(o))
.ToDictionary(o => o.Type, o => o);
foreach (var modelMetadata in _clientModelMetadata.Values)
{
AddClientModelType(modelMetadata, metadata);
}
return(metadata);
}
private BreezeMetadata GetMetadataFromContext(DbContext dbContext)
{
var metadata = new BreezeMetadata();
var dbSetMap = GetDbSetMap(dbContext);
metadata.StructuralTypes = dbContext.Model.GetEntityTypes()
.Where(et => !et.IsOwned())
.Select(et => CreateMetaType(et, dbSetMap)).ToList();
var complexTypes = dbContext.Model.GetEntityTypes()
.Where(et => et.IsOwned())
.Select(et => CreateMetaType(et, dbSetMap)).ToList();
// Complex types show up once per parent reference and we need to reduce
// this to just the unique types.
var complexTypesMap = complexTypes.ToDictionary(mt => mt.ShortName);
complexTypesMap.Values.ToList().ForEach(v => metadata.StructuralTypes.Add(v));
return(metadata);
}
private void AddEntityType(
EntityMetadata entityMetadata,
BreezeMetadata metadata)
{
var type = entityMetadata.Type;
var modelConfiguration = _breezeConfigurator.GetModelConfiguration(type);
var entityType = new EntityType(type)
{
BaseTypeName = entityMetadata.BaseType != null
? GetBreezeTypeFullName(entityMetadata.BaseType)
: null,
AutoGeneratedKeyType = modelConfiguration.AutoGeneratedKeyType ?? entityMetadata.AutoGeneratedKeyType,
DefaultResourceName = modelConfiguration.ResourceName ?? Pluralize(type.Name),
Custom = modelConfiguration.Custom
};
metadata.ResourceEntityTypeMap.Add(entityType.DefaultResourceName, GetBreezeTypeFullName(type));
AddProperties(entityMetadata, entityType, modelConfiguration, metadata);
metadata.StructuralTypes.Add(entityType);
}
private void AddDataProperties(
string[] propertyNames,
IType[] propertyTypes,
bool[] propertyNullability,
IReadOnlyCollection <string> superProperties,
int?versionPropertyIndex,
bool partsOfKey,
StructuralType structuralType,
ModelConfiguration modelConfiguration,
BreezeMetadata metadata,
ISessionFactoryImplementor sessionFactory)
{
for (var i = 0; i < propertyNames.Length; i++)
{
var propertyType = propertyTypes[i];
var propertyName = propertyNames[i];
var memberConfiguration = modelConfiguration.GetMember(propertyNames[i]);
if (
memberConfiguration?.Ignored == true ||
superProperties?.Contains(propertyName) == true ||
propertyType.IsAssociationType)
{
continue;
}
var dataProperty = CreateDataProperty(
propertyName,
propertyType,
partsOfKey,
propertyNullability[i],
i == versionPropertyIndex,
memberConfiguration,
structuralType,
sessionFactory);
if (propertyType is IAbstractComponentType componentType)
{
AddComplexType(
componentType,
_breezeConfigurator.GetModelConfiguration(propertyType.ReturnedClass),
metadata,
partsOfKey,
sessionFactory);
}
if (partsOfKey)
{
structuralType.DataProperties.Insert(0, dataProperty);
}
else
{
structuralType.DataProperties.Add(dataProperty);
}
// Map enum type
if (propertyType is AbstractEnumType nhEnumType && _addedTypes.Add(nhEnumType.ReturnedClass))
{
var enumType = nhEnumType.ReturnedClass;
metadata.EnumTypes.Add(new EnumType
{
Namespace = enumType.Namespace,
ShortName = enumType.Name,
Values = Enum.GetNames(enumType)
});
}
}
}
/// <summary>
/// Constructs an instance of <see cref="BreezeEntityValidator"/>.
/// </summary>
public BreezeEntityValidator(BreezeMetadata breezeMetadata)
{
_structuralTypes = breezeMetadata.StructuralTypes.ToDictionary(o => o.Type);
}
