metadatadbprovider.cs

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

            try
            {
                FieldCollectionMaster fields = new FieldCollectionMaster();
                DataTable table = GetFieldsAsDataTable(view);
                foreach (DataRow row in table.Rows)
                {
                    MetaFieldType fieldTypeId = (MetaFieldType)row[ColumnNames.FIELD_TYPE_ID];
                    Field field = null;
                    switch (fieldTypeId)
                    {
                        case MetaFieldType.Text:
                            field = new SingleLineTextField(view);
                            break;
                        case MetaFieldType.LabelTitle:
                            field = new LabelField(view);
                            break;
                        case MetaFieldType.TextUppercase:
                            field = new UpperCaseTextField(view);
                            break;
                        case MetaFieldType.Multiline:
                            field = new MultilineTextField(view);
                            break;
                        case MetaFieldType.Number:
                            field = new NumberField(view);
                            break;
                        case MetaFieldType.PhoneNumber:
                            field = new PhoneNumberField(view);
                            break;
                        case MetaFieldType.Date:
                            field = new DateField(view);
                            break;
                        case MetaFieldType.Time:
                            field = new TimeField(view);
                            break;
                        case MetaFieldType.DateTime:
                            field = new DateTimeField(view);
                            break;
                        case MetaFieldType.Checkbox:
                            field = new CheckBoxField(view);
                            break;
                        case MetaFieldType.YesNo:
                            field = new YesNoField(view);
                            break;
                        case MetaFieldType.Option:
                            field = new OptionField(view);
                            break;
                        case MetaFieldType.CommandButton:
                            field = new CommandButtonField(view);
                            break;
                        case MetaFieldType.Image:
                            field = new ImageField(view);
                            break;
                        case MetaFieldType.Mirror:
                            field = new MirrorField(view);
                            break;
                        case MetaFieldType.Grid:
                            field = new GridField(view);
                            break;
                        case MetaFieldType.LegalValues:
                            field = new DDLFieldOfLegalValues(view);
                            break;
                        case MetaFieldType.Codes:
                            field = new DDLFieldOfCodes(view);
                            break;
                        case MetaFieldType.CommentLegal:
                            field = new DDLFieldOfCommentLegal(view);
                            break;
                        case MetaFieldType.Relate:
                            field = new RelatedViewField(view);
                            break;
                        case MetaFieldType.RecStatus:
                            field = new RecStatusField(view);
                            break;
                        case MetaFieldType.UniqueKey:
                            field = new UniqueKeyField(view);
                            break;
                        default:
                            throw new GeneralException("Invalid Field Type");
                    }
                    field.LoadFromRow(row);
                    fields.Add(field);
                }
                return (fields);
            }
            finally
            {
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="field"></param>
        /// <returns></returns>
        public List<GridColumn> GetGridColumnCollection(GridField field)
        {
            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="gml">GML document</param>