metadataxmlprovider.cs

EpiInfo 开源的导航系统远程序,不知道在哪里下的了,分享一下,有兴趣的

        {
            List<GridColumn> columns = new List<GridColumn>();
            DataTable table = GetGridColumns(field.Id);
            foreach (DataRow row in table.Rows)
            {
                switch ((MetaFieldType)row["FieldTypeId"])
                {
                    case MetaFieldType.UniqueKey:
                        columns.Add(new UniqueKeyColumn(row, field));
                        break;
                    case MetaFieldType.RecStatus:
                        columns.Add(new RecStatusColumn(row, field));
                        break;
                    case MetaFieldType.Text:
                        columns.Add(new TextColumn(row, field));
                        break;
                    case MetaFieldType.Number:
                        columns.Add(new NumberColumn(row, field));
                        break;
                    case MetaFieldType.PhoneNumber:
                        columns.Add(new PhoneNumberColumn(row, field));
                        break;
                    case MetaFieldType.Date:
                        columns.Add(new DateColumn(row, field));
                        break;
                    default:
                        break;
                }
            }
            return columns;
        }

        /// <summary>
        /// Gets a datatable containing all the option items of an option field
        /// </summary>
        /// <param name="field">An option field</param>
        /// <returns>List containing all the option items of the option field</returns>
        public List<string> GetOptionFieldItems(OptionField field)
        {
            List<string> items = new List<string>();
            Query query = db.CreateQuery("SELECT O.[Text] FROM metaOptions O WHERE O.[FieldId] = @FieldId ORDER BY O.[OptionId]");
            query.Parameters.Add(new QueryParameter("@FieldId", DbType.Int32, field.Id));
            DataTable table = db.Select(query);
            foreach (DataRow row in table.Rows)
            {
                if (!string.IsNullOrEmpty(row["Text"].ToString()))
                {
                    items.Add(row["Text"].ToString());
                }
            }
            return items;
        }


        /// <summary>
        /// Gets all columns belonging to a grid control
        /// </summary>
        /// <param name="fieldId">Id of the grid control</param>
        /// <returns>Datatable containing column info</returns>
        public DataTable GetGridColumns(int fieldId)
        {
            try
            {
                #region Input Validation
                if (fieldId < 1)
                {
                    throw new ArgumentOutOfRangeException("FieldId");
                }
                #endregion

                Query query = db.CreateQuery("SELECT G.[GridColumnId], G.[Name], G.[Width], G.[Size], G.[Position], G.[FieldTypeId], " +
                    "G.[Text], G.[ShouldRepeatLast], G.[IsRequired], G.[IsReadOnly], G.[Pattern], G.[Upper], G.[Lower] " +
                    "FROM metaGridColumns G " +
                    "WHERE G.[FieldId] = @FieldId");
                query.Parameters.Add(new QueryParameter("@FieldId", DbType.Int32, fieldId));
                return db.Select(query);
            }
            catch (Exception ex)
            {
                throw new GeneralException("Could not retrieve grid column", ex);
            }
        }

        /// <summary>
        /// Gets all field types
        /// </summary>
        /// <returns>Datatable containing field type info</returns>
        public DataTable GetFieldTypes()
        {
            try
            {
                Query query = db.CreateQuery("SELECT F.[FieldTypeId], D.[DataTypeId], F.[Name], D.[HasPattern], D.[HasSize], F.[HasRepeatLast], F.[HasRequired], F.[HasReadOnly], F.[HasRetainImageSize], D.[HasRange], F.[HasFont], F.[IsGridColumn], F.[IsDropDown] " +
                    "FROM metaFieldTypes F LEFT OUTER JOIN metaDatatypes D ON F.[DataTypeId] = D.[DataTypeId] " +
                    "WHERE F.[IsSystem] = @IsSystem");
                query.Parameters.Add(new QueryParameter("@IsSystem", System.Data.DbType.Boolean, false));
                return db.Select(query);
            }
            catch (Exception ex)
            {
                throw new GeneralException("Could not retrieve field types", ex);
            }
        }

        /// <summary>
        /// Gets all stored map layers
        /// </summary>
        /// <returns>Datatable</returns>
        public MapMetadata.metaLayersDataTable GetLayers()
        {
            try
            {
                MapMetadata.metaLayersDataTable table = new MapMetadata.metaLayersDataTable();
                Query query = db.CreateQuery("SELECT [LayerId], [Name], [Description] FROM metaLayers");
                table.Merge(db.Select(query));
                return table;
            }
            catch (Exception ex)
            {
                throw new GeneralException("Could not retrieve map layers", ex);
            }
        }

        /// <summary>
        /// Gets a Map Layer
        /// </summary>
        /// <param name="mapLayerId">Map Layer Id</param>
        /// <returns>MapLayersRow</returns>
        public MapMetadata.metaMapLayersRow GetMapLayer(int mapLayerId)
        {
            try
            {
                MapMetadata map = new MapMetadata();
                Query query = db.CreateQuery("SELECT [MapLayerId], [MapId], [LayerId], [LayerRenderTypeId], [RenderField], [MarkerColor], [RampBeginColor], [RampEndColor], [ClassBreaks] FROM metaMapLayers WHERE [MapLayerId] = @MapLayerId");
                query.Parameters.Add(new QueryParameter("@MapLayerId", System.Data.DbType.Int32, mapLayerId));
                map.metaMapLayers.Merge(db.Select(query));
                if (map.metaMapLayers.Count > 0)
                {
                    map.metaLayers.ImportRow(GetLayer(map.metaMapLayers[0].LayerId));
                    return map.metaMapLayers[0];
                }
                else
                {
                    throw new GeneralException("Map layer not found");
                }
            }
            catch (Exception ex)
            {
                throw new GeneralException("Could not retrieve map layer", ex);
            }
        }

        /// <summary>
        /// Gets all the maps of a project
        /// </summary>
        /// <returns>MapsDataTable</returns>
        public MapMetadata.metaMapsDataTable GetMaps()
        {
            try
            {
                MapMetadata map = new MapMetadata();
                Query query = db.CreateQuery("SELECT [MapId], [Name], [Title] FROM metaMaps");
                map.metaMaps.Merge(db.Select(query));
                return map.metaMaps;
            }
            catch (Exception ex)
            {
                throw new GeneralException("Could not retrieve maps", ex);
            }
        }

        /// <summary>
        /// Gets a map by its ID
        /// </summary>
        /// <param name="mapId">Map Id</param>
        /// <returns>MapsDataTable</returns>
        public MapMetadata.metaMapsDataTable GetMap(int mapId)
        {
            try
            {
                MapMetadata map = new MapMetadata();
                Query query = db.CreateQuery("SELECT [MapId], [Name], [Title] FROM metaMaps WHERE [MapId] = @MapId");
                query.Parameters.Add(new QueryParameter("@MapId", DbType.Int32, mapId));
                map.metaMaps.Merge(db.Select(query));
                return map.metaMaps;
            }
            catch (Exception ex)
            {
                throw new GeneralException("Could not retrieve map", ex);
            }
        }

        /// <summary>
        /// Creates a map record in the database
        /// </summary>
        /// <param name="name">Name of the map</param>
        /// <param name="description">Description of the map</param>
        /// <returns>The map's ID</returns>
        public int CreateMap(string name, string description)
        {
            try
            {
                Query insertQuery = db.CreateQuery("INSERT INTO metaMaps ([Name], [Title]) VALUES (@Name, @Description)");
                insertQuery.Parameters.Add(new QueryParameter("@Name", DbType.String, name));
                insertQuery.Parameters.Add(new QueryParameter("@Description", DbType.String, description));
                db.ExecuteNonQuery(insertQuery);
                return GetMaxMapId();
            }
            catch (Exception ex)
            {
                throw new GeneralException("Could not insert map record", ex);
            }
        }

        /// <summary>
        /// Creates a map layer in the database
        /// </summary>
        /// <param name="fileName">Shapefile name</param>
        /// <returns>The layer's ID</returns>
        public int CreateLayer(string fileName)
        {
            Query insertQuery = db.CreateQuery("INSERT INTO metaLayers ([FileName], [Name]) VALUES (@FileName, @Name)");
            insertQuery.Parameters.Add(new QueryParameter("@FileName", DbType.String, fileName));
            insertQuery.Parameters.Add(new QueryParameter("@Name", DbType.String, Path.GetFileNameWithoutExtension(fileName)));
            db.ExecuteNonQuery(insertQuery);
            return GetMaxLayerId();
        }

        /// <summary>
        /// Creates a map layer in the database
        /// </summary>
        /// <param name="gml">GML document</param>
        /// <param name="gmlSchema">GML schema document</param>
        /// <param name="layerName">Name of the layer</param>
        /// <returns>The layer's ID</returns>
        public int CreateLayer(string gml, string gmlSchema, string layerName)
        {
            Query insertQuery = db.CreateQuery("INSERT INTO metaLayers ([Gml], [GmlSchema], [Name]) VALUES (@Gml, @GmlSchema, @Name)");
            insertQuery.Parameters.Add(new QueryParameter("@Gml", DbType.String, gml));
            insertQuery.Parameters.Add(new QueryParameter("@GmlSchema", DbType.String, gmlSchema));
            insertQuery.Parameters.Add(new QueryParameter("@Name", DbType.String, layerName));
            db.ExecuteNonQuery(insertQuery);
            return GetMaxLayerId();
        }

        /// <summary>
        /// Gets all layers of a map
        /// </summary>
        /// <param name="mapId">Map Id</param>
        /// <returns>Map Layers Datatable</returns>
        public MapMetadata.metaMapLayersDataTable GetMapLayers(int mapId)
        {
            try
            {
                MapMetadata map = new MapMetadata();
                Query query = db.CreateQuery("SELECT [MapLayerId], [MapId], [LayerId], [LayerRenderTypeId], [RenderField], [MarkerColor], [RampBeginColor], [RampEndColor], [ClassBreaks], [DataTableName], [DataTableKey], [FeatureKey], [LineColor], [FillColor], [PolygonOutlineColor] FROM metaMapLayers WHERE [MapId] = @MapId ORDER BY [MapLayerId] ASC");
                query.Parameters.Add(new QueryParameter("@MapId", System.Data.DbType.Int32, mapId));
                map.metaMapLayers.Merge(db.Select(query));
                foreach (MapMetadata.metaMapLayersRow mapLayer in map.metaMapLayers)
                {
                    map.metaLayers.ImportRow(GetLayer(mapLayer.LayerId));
                }
                return map.metaMapLayers;
            }
            catch (Exception ex)
            {
                throw new GeneralException("Could not retrieve map layers", ex);
            }
        }

        /// <summary>
        /// Gets all points of a map
        /// </summary>
        /// <param name="mapId">Map Id</param>
        /// <returns>Map Points Datatable</returns>
        public MapMetadata.metaMapPointsDataTable GetMapPoints(int mapId)
        {
            try
            {
                MapMetadata map = new MapMetadata();
                Query query = db.CreateQuery("SELECT [MapPointId], [MapId], [DataSourceTableName], [DataSourceXCoordinateColumnName], [DataSourceYCoordinateColumnName], [DataSourceLabelColumnName], [Size], [Color] FROM metaMapPoints WHERE [MapId] = @MapId");
                query.Parameters.Add(new QueryParameter("@MapId", DbType.Int32, mapId));
                map.metaMapPoints.Merge(db.Select(query));
                return map.metaMapPoints;
            }
            catch (Exception ex)
            {
                throw new GeneralException("Could not retrieve map points", ex);
            }
        }

        /// <summary>
        /// Gets a GML map layer based on ID
        /// </summary>
        /// <param name="layerId">MapLayerId</param>
        /// <returns>GML</returns>
        public MapMetadata.metaLayersRow GetLayer(int layerId)
        {
            try
            {
                MapMetadata.metaLayersDataTable table = new MapMetadata.metaLayersDataTable();
                Query query = db.CreateQuery("SELECT [LayerId], [Gml], [GmlSchema], [Name] FROM metaLayers WHERE [LayerId] = @LayerId");
                query.Parameters.Add(new QueryParameter("@LayerId", System.Data.DbType.String, layerId));
                table.Merge(db.Select(query));
                if (table.Rows.Count > 0)
                {
                    return table[0];
                }
                else