/// <summary>
/// Default constructor
/// </summary>
/// <param name="database">The database</param>
/// <param name="databaseOptions">The database options</param>
public QueryMapsPage(IDbProviderDatabase database, BaseDatabaseOptionsDataModel databaseOptions) : base()
{
Database = database ?? throw new System.ArgumentNullException(nameof(database));
DatabaseOptions = databaseOptions ?? throw new ArgumentNullException(nameof(databaseOptions));
CreateGUI();
}
/// <summary>
/// Unregisters the specified <paramref name="database"/>
/// </summary>
/// <param name="database">The database</param>
public void Unregister(BaseDatabaseOptionsDataModel database)
{
// Remove the database
mDatabases.Remove(database);
// Fire the event
DatabaseUnregistered(this, database);
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="databaseOptions">The database options</param>
/// <param name="database">The database that contains the mapped table</param>
/// <param name="columns">The columns of the tables</param>
/// <param name="joins">The joins</param>
/// <param name="tables">The tables</param>
protected QueryMap(BaseDatabaseOptionsDataModel databaseOptions, IDbProviderDatabase database, IEnumerable <IDbProviderTable> tables, IEnumerable <IDbProviderColumn> columns, IEnumerable <JoinMap> joins) : base()
{
Database = database ?? throw new ArgumentNullException(nameof(database));
Joins = joins ?? Enumerable.Empty <JoinMap>();
DatabaseOptions = databaseOptions ?? throw new ArgumentNullException(nameof(databaseOptions));
Tables = tables.NotNullOrEmpty();
Columns = columns.NotNullOrEmpty();
PropertyShortcodes = new Lazy <IEnumerable <PropertyShortcode> >(() =>
{
return(RootType.GetProperties().Select(x => new PropertyShortcode(x.Name, Blue, "Shortcodes", null, x, null)).ToList());
});
}
/// <summary>
/// Registers the specified <paramref name="database"/>
/// </summary>
/// <param name="database">The database</param>
public void Register(BaseDatabaseOptionsDataModel database)
{
// Add the database
mDatabases.Add(database);
// If the database doesn't have an id, meaning that's a new one...
if (database.Id.IsNullOrEmpty())
{
// Set a new id
database.Id = Guid.NewGuid().ToString();
}
// Fire the event
DatabaseRegistered(this, database);
}
/// <summary>
/// Creates and returns a <see cref="QueryMap"/> from the specified <paramref name="dataModel"/>.
/// NOTE: If the model is not set, then the default values are used!
/// </summary>
/// <param name="databaseOptions">The database options</param>
/// <param name="database">The database that contains the mapped table</param>
/// <param name="columns">The columns of the tables</param>
/// <param name="tables">The tables</param>
/// <param name="joins">The joins</param>
/// <param name="dataModel">The data model</param>
/// <returns></returns>
public static QueryMap FromDataModel(BaseDatabaseOptionsDataModel databaseOptions, IDbProviderDatabase database, IEnumerable <IDbProviderTable> tables, IEnumerable <IDbProviderColumn> columns, IEnumerable <JoinMap> joins, QueryMapDataModel dataModel = null)
{
// Create the map
var queryMap = new QueryMap(databaseOptions, database, tables, columns, joins);
// If there is a data model...
if (dataModel != null)
{
queryMap.Id = dataModel.Id;
queryMap.Color = dataModel.Color;
queryMap.Description = dataModel.Description;
queryMap.Name = dataModel.Name;
}
var tableToTypeBuilderMapper = new Dictionary <IDbProviderTable, TypeBuilder>();
// For every table...
foreach (var table in tables)
{
// Create the builder
var typeBuilder = CeidDiplomatikiHelpers.GetTypeBuilder(queryMap.Id + "-" + table.TableName);
// For every table column...
foreach (var column in columns.Where(x => x.TableName == table.TableName))
{
// Create a property
TypeBuilderHelpers.CreateProperty(typeBuilder, column.ColumnName, column.DataType);
}
// Map it
tableToTypeBuilderMapper.Add(table, typeBuilder);
}
// For every join...
foreach (var join in joins)
{
// Get the principle model type builder
var principleModelTypeBuilder = tableToTypeBuilderMapper.First(x => x.Key == join.Table).Value;
// Get the referenced model type builder
var referencedModelTypeBuilder = tableToTypeBuilderMapper.First(x => x.Key == join.ReferencedTable).Value;
// Create the principle navigation property type
var principleNavigationPropertyType = typeof(IEnumerable <>).MakeGenericType(referencedModelTypeBuilder);
// Add it to the principle model
TypeBuilderHelpers.CreateProperty(principleModelTypeBuilder, CeidDiplomatikiHelpers.GetPluralForm(join.ReferencedTable.TableName), principleNavigationPropertyType);
// Add the foreign navigation property type
TypeBuilderHelpers.CreateProperty(referencedModelTypeBuilder, join.Table.TableName, principleModelTypeBuilder);
}
var tableToTypeMapper = new Dictionary <IDbProviderTable, Type>();
// For every table to type builder map...
foreach (var map in tableToTypeBuilderMapper)
{
// Build the type
var type = map.Value.CreateType();
if (joins.Any(x => x.Index == 0 && x.Table.TableName == map.Key.TableName))
{
queryMap.RootType = type;
}
else if (joins.Count() == 0)
{
queryMap.RootType = type;
}
// Map it
tableToTypeMapper.Add(map.Key, type);
}
// Set the types to the query
queryMap.DataModelTypes = tableToTypeMapper.Select(x => x.Value).ToList();
// Create the db context type builder
var dbContextTypeBuilder = CeidDiplomatikiHelpers.GetTypeBuilder(Guid.NewGuid().ToString() + "-DbContext");
// Set the base type
var baseType = typeof(PresenterDbContext);
// Inherit from the PresenterDbContext
dbContextTypeBuilder.SetParent(baseType);
// For every data model type...
foreach (var map in tableToTypeMapper)
{
// Create the DbSet type that will be set as a property to the DbContext
var dbSetType = typeof(DbSet <>).MakeGenericType(map.Value);
// Add it to the type
TypeBuilderHelpers.CreateProperty(dbContextTypeBuilder, map.Key.TableName, dbSetType);
}
// Create the constructors
TypeBuilderHelpers.CreatePassThroughConstructors(dbContextTypeBuilder, baseType);
// Create the db context type
queryMap.DbContextType = dbContextTypeBuilder.CreateType();
// If there is a data model...
// NOTE: We create the column and the data presenter maps at the end of the initialization
// because some properties of the query map are required to get set!
if (dataModel != null)
{
dataModel.PropertyMaps.ForEach(model => queryMap.Add(PropertyMap.FromDataModel(queryMap, queryMap.DataModelTypes.First(x => queryMap.GetTableName(x) == model.TableName), dataModel.PropertyMaps.First(x => x.TableName == model.TableName && x.ColumnName == model.ColumnName))));
dataModel.DataGridPresenterMaps.ForEach(model => queryMap.Add(DataGridPresenterMap.FromDataModel(queryMap, model)));
}
// Return the map
return(queryMap);
}
