コード例 #1
0
 /// <summary>
 /// Default constructor
 /// </summary>
 /// <param name="queryMap">The query map</param>
 /// <param name="type">The type that contains the <see cref="PropertyInfo"/></param>
 /// <param name="property">The property that's getting map.</param>
 /// <param name="column">
 /// The column.
 /// NOTE: The column will be <see cref="null"/> when the <see cref="PropertyInfo"/> is a navigation property!
 /// </param>
 public PropertyMap(QueryMap queryMap, Type type, PropertyInfo property, IDbProviderColumn column = null) : base()
 {
     Column       = column;
     QueryMap     = queryMap ?? throw new ArgumentNullException(nameof(queryMap));
     Type         = type ?? throw new ArgumentNullException(nameof(type));
     PropertyInfo = property ?? throw new ArgumentNullException(nameof(property));
     Table        = QueryMap.Tables.First(x => x.TableName == queryMap.GetTableName(type));
 }
コード例 #2
0
        /// <summary>
        /// Updates the specified <paramref name="model"/>
        /// </summary>
        /// <param name="model">The model</param>
        /// <returns></returns>
        public async Task <IFailable <object> > UpdateDataAsync(object model)
        {
            // Create the result
            var result = new Failable <object>();

            try
            {
                // Get the type of the model
                var modelType = model.GetType();

                // Get the name of the table
                var tableName = QueryMap.GetTableName(modelType);

                // Get the primary key column
                var primaryKeyColumn = QueryMap.Columns.First(x => x.TableName == tableName && x.IsPrimaryKey);

                // Get the primary key property
                var primaryKeyProperty = modelType.GetProperty(primaryKeyColumn.ColumnName);

                // Get the existing model
                var existingModel = await DbContext.FindAsync(modelType, primaryKeyProperty.GetValue(model));

                // For every property of the model...
                // TODO: Better implementation by using AutoMapper!
                foreach (var property in modelType.GetProperties())
                {
                    // Update the property value of the existing model
                    property.SetValue(existingModel, property.GetValue(model));
                }

                // Mark the existing model for update
                DbContext.Update(existingModel);

                // Save the changes
                await DbContext.SaveChangesAsync();
            }
            catch (Exception ex)
            {
                // Set the error
                result.ErrorMessage = ex.Message;
            }

            // Return the result
            return(result);
        }
コード例 #3
0
ファイル: QueryMap.cs プロジェクト: PapLabros/CeidDiplomatiki
        /// <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);
        }
コード例 #4
0
 /// <summary>
 /// Default constructor
 /// </summary>
 /// <param name="presenterMap">The data grid presenter map</param>
 public DataGridPresenterDataStorage(DataGridPresenterMap presenterMap) : base(presenterMap)
 {
     DataGridMap        = PresenterMap.DataGrids.First(x => x.Type == QueryMap.RootType);
     PrimaryKeyColumn   = QueryMap.Columns.First(x => x.IsPrimaryKey && x.TableName == QueryMap.GetTableName(QueryMap.RootType));
     PrimaryKeyProperty = QueryMap.RootType.GetProperty(PrimaryKeyColumn.ColumnName);
 }