コード例 #1
0
        public static DbGeometry FromWkt(string type, string wkt, int systemid)
        {
            type = type.ToUpper();
            switch (type)
            {
            case "POINT":
                return(DbGeometry.PointFromText(wkt, systemid));

            case "POLYGON":
                return(DbGeometry.PolygonFromText(wkt, systemid));

            case "LINE":
                return(DbGeometry.LineFromText(wkt, systemid));

            case "MULTIPOINT":
                return(DbGeometry.MultiPointFromText(wkt, systemid));

            case "MULTIPOLYGON":
                return(DbGeometry.MultiPolygonFromText(wkt, systemid));

            case "MULTILINE":
                return(DbGeometry.MultiLineFromText(wkt, systemid));

            default:
                return(null);
            }
        }
コード例 #2
0
        static void Main(string[] args)
        {
            string     path   = @"D:\GoogleDrive\CPC_CODE\ConvertExcelToDB\ConvertExcelToDB\Content\鄉鎮市框線.geojson";
            Rootobject movie1 = JsonConvert.DeserializeObject <Rootobject>(File.ReadAllText(path));

            //// deserialize JSON directly from a file
            //using (StreamReader file = File.OpenText(path))
            //{
            //    JsonSerializer serializer = new JsonSerializer();
            //    Rootobject movie2 = (Rootobject)serializer.Deserialize(file, typeof(Rootobject));
            //}
            List <Feature> ff1 = new List <Feature>();
            TaiwanCode     tc1;

            foreach (var feature in movie1.features)
            {
                //if (feature.properties.名稱 != "南投縣國姓鄉") continue;
                tc1 = _cpi.TaiwanCode.Where(item => item.Name == feature.properties.稱).FirstOrDefault();
                if (tc1 == null)
                {
                    continue;
                }

                string multiPolygon = "";//@"MULTIPOLYGON(((1 1, 1 -1, -1 -1, -1 1, 1 1)),((1 1, 3 1, 3 3, 1 3, 1 1)))";
                string pointString = "", lineString = "";
                foreach (var lines in feature.geometry.coordinates)
                {
                    lineString = "";
                    foreach (var line in lines)
                    {
                        pointString = "";
                        foreach (var point in line)
                        {
                            pointString = string.Format("{0}{1} {2}, ", pointString, point[0], point[1]);
                        }
                        lineString = string.Format("{0}(({1})),", lineString, pointString.Substring(0, pointString.Length - 2));
                    }
                    lineString = lineString.Substring(0, lineString.Length - 1);
                }
                multiPolygon = string.Format("MULTIPOLYGON({0})", lineString);

                //MULTIPOLYGON(((120.8221 24.1035, 120.8592 24.0894, 120.8681 24.1035, 120.8221 24.1035)), ((120.8746 24.1000, 120.8712 24.0887, 120.9134 24.0975, 120.8746 24.1000)))
                tc1.Polygon = DbGeometry.MultiPolygonFromText(multiPolygon, 4326);
            }
            //_cpi.SaveChanges();
        }
コード例 #3
0
                private static IEnumerable <MethodInfo> GetSupportedMethods()
                {
                    yield return(GetStaticMethod(() => DbGeography.FromText(default(string))));

                    yield return(GetStaticMethod(() => DbGeography.FromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.PointFromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.LineFromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.PolygonFromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.MultiPointFromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.MultiLineFromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.MultiPolygonFromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.GeographyCollectionFromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.FromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.FromBinary(default(byte[]))));

                    yield return(GetStaticMethod(() => DbGeography.PointFromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.LineFromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.PolygonFromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.MultiPointFromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.MultiLineFromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.MultiPolygonFromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.GeographyCollectionFromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeography.FromGml(default(string))));

                    yield return(GetStaticMethod(() => DbGeography.FromGml(default(string), default(int))));

                    yield return(GetInstanceMethod((DbGeography geo) => geo.AsBinary()));

                    yield return(GetInstanceMethod((DbGeography geo) => geo.AsGml()));

                    yield return(GetInstanceMethod((DbGeography geo) => geo.AsText()));

                    yield return(GetInstanceMethod((DbGeography geo) => geo.SpatialEquals(default(DbGeography))));

                    yield return(GetInstanceMethod((DbGeography geo) => geo.Disjoint(default(DbGeography))));

                    yield return(GetInstanceMethod((DbGeography geo) => geo.Intersects(default(DbGeography))));

                    yield return(GetInstanceMethod((DbGeography geo) => geo.Buffer(default(double))));

                    yield return(GetInstanceMethod((DbGeography geo) => geo.Distance(default(DbGeography))));

                    yield return(GetInstanceMethod((DbGeography geo) => geo.Intersection(default(DbGeography))));

                    yield return(GetInstanceMethod((DbGeography geo) => geo.Union(default(DbGeography))));

                    yield return(GetInstanceMethod((DbGeography geo) => geo.Difference(default(DbGeography))));

                    yield return(GetInstanceMethod((DbGeography geo) => geo.SymmetricDifference(default(DbGeography))));

                    yield return(GetInstanceMethod((DbGeography geo) => geo.ElementAt(default(int))));

                    yield return(GetInstanceMethod((DbGeography geo) => geo.PointAt(default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.FromText(default(string))));

                    yield return(GetStaticMethod(() => DbGeometry.FromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.PointFromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.LineFromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.PolygonFromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.MultiPointFromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.MultiLineFromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.MultiPolygonFromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.GeometryCollectionFromText(default(string), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.FromBinary(default(byte[]))));

                    yield return(GetStaticMethod(() => DbGeometry.FromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.PointFromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.LineFromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.PolygonFromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.MultiPointFromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.MultiLineFromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.MultiPolygonFromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.GeometryCollectionFromBinary(default(byte[]), default(int))));

                    yield return(GetStaticMethod(() => DbGeometry.FromGml(default(string))));

                    yield return(GetStaticMethod(() => DbGeometry.FromGml(default(string), default(int))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.AsBinary()));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.AsGml()));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.AsText()));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.SpatialEquals(default(DbGeometry))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.Disjoint(default(DbGeometry))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.Intersects(default(DbGeometry))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.Touches(default(DbGeometry))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.Crosses(default(DbGeometry))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.Within(default(DbGeometry))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.Contains(default(DbGeometry))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.Overlaps(default(DbGeometry))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.Relate(default(DbGeometry), default(string))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.Buffer(default(double))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.Distance(default(DbGeometry))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.Intersection(default(DbGeometry))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.Union(default(DbGeometry))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.Difference(default(DbGeometry))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.SymmetricDifference(default(DbGeometry))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.ElementAt(default(int))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.PointAt(default(int))));

                    yield return(GetInstanceMethod((DbGeometry geo) => geo.InteriorRingAt(default(int))));
                }
コード例 #4
0
                private static Dictionary <MethodInfo, string> GetRenamedMethodFunctions()
                {
                    var result = new Dictionary <MethodInfo, string>();

                    result.Add(GetStaticMethod(() => DbGeography.FromText(default(string))), "GeographyFromText");
                    result.Add(GetStaticMethod(() => DbGeography.FromText(default(string), default(int))), "GeographyFromText");
                    result.Add(GetStaticMethod(() => DbGeography.PointFromText(default(string), default(int))), "GeographyPointFromText");
                    result.Add(GetStaticMethod(() => DbGeography.LineFromText(default(string), default(int))), "GeographyLineFromText");
                    result.Add(
                        GetStaticMethod(() => DbGeography.PolygonFromText(default(string), default(int))), "GeographyPolygonFromText");
                    result.Add(
                        GetStaticMethod(() => DbGeography.MultiPointFromText(default(string), default(int))), "GeographyMultiPointFromText");
                    result.Add(
                        GetStaticMethod(() => DbGeography.MultiLineFromText(default(string), default(int))), "GeographyMultiLineFromText");
                    result.Add(
                        GetStaticMethod(() => DbGeography.MultiPolygonFromText(default(string), default(int))),
                        "GeographyMultiPolygonFromText");
                    result.Add(
                        GetStaticMethod(() => DbGeography.GeographyCollectionFromText(default(string), default(int))),
                        "GeographyCollectionFromText");
                    result.Add(GetStaticMethod(() => DbGeography.FromBinary(default(byte[]), default(int))), "GeographyFromBinary");
                    result.Add(GetStaticMethod(() => DbGeography.FromBinary(default(byte[]))), "GeographyFromBinary");
                    result.Add(
                        GetStaticMethod(() => DbGeography.PointFromBinary(default(byte[]), default(int))), "GeographyPointFromBinary");
                    result.Add(GetStaticMethod(() => DbGeography.LineFromBinary(default(byte[]), default(int))), "GeographyLineFromBinary");
                    result.Add(
                        GetStaticMethod(() => DbGeography.PolygonFromBinary(default(byte[]), default(int))), "GeographyPolygonFromBinary");
                    result.Add(
                        GetStaticMethod(() => DbGeography.MultiPointFromBinary(default(byte[]), default(int))),
                        "GeographyMultiPointFromBinary");
                    result.Add(
                        GetStaticMethod(() => DbGeography.MultiLineFromBinary(default(byte[]), default(int))),
                        "GeographyMultiLineFromBinary");
                    result.Add(
                        GetStaticMethod(() => DbGeography.MultiPolygonFromBinary(default(byte[]), default(int))),
                        "GeographyMultiPolygonFromBinary");
                    result.Add(
                        GetStaticMethod(() => DbGeography.GeographyCollectionFromBinary(default(byte[]), default(int))),
                        "GeographyCollectionFromBinary");
                    result.Add(GetStaticMethod(() => DbGeography.FromGml(default(string))), "GeographyFromGml");
                    result.Add(GetStaticMethod(() => DbGeography.FromGml(default(string), default(int))), "GeographyFromGml");
                    result.Add(GetInstanceMethod((DbGeography geo) => geo.AsBinary()), "AsBinary");
                    result.Add(GetInstanceMethod((DbGeography geo) => geo.AsGml()), "AsGml");
                    result.Add(GetInstanceMethod((DbGeography geo) => geo.AsText()), "AsText");
                    result.Add(GetInstanceMethod((DbGeography geo) => geo.SpatialEquals(default(DbGeography))), "SpatialEquals");
                    result.Add(GetInstanceMethod((DbGeography geo) => geo.Disjoint(default(DbGeography))), "SpatialDisjoint");
                    result.Add(GetInstanceMethod((DbGeography geo) => geo.Intersects(default(DbGeography))), "SpatialIntersects");
                    result.Add(GetInstanceMethod((DbGeography geo) => geo.Buffer(default(double))), "SpatialBuffer");
                    result.Add(GetInstanceMethod((DbGeography geo) => geo.Distance(default(DbGeography))), "Distance");
                    result.Add(GetInstanceMethod((DbGeography geo) => geo.Intersection(default(DbGeography))), "SpatialIntersection");
                    result.Add(GetInstanceMethod((DbGeography geo) => geo.Union(default(DbGeography))), "SpatialUnion");
                    result.Add(GetInstanceMethod((DbGeography geo) => geo.Difference(default(DbGeography))), "SpatialDifference");
                    result.Add(
                        GetInstanceMethod((DbGeography geo) => geo.SymmetricDifference(default(DbGeography))), "SpatialSymmetricDifference");
                    result.Add(GetInstanceMethod((DbGeography geo) => geo.ElementAt(default(int))), "SpatialElementAt");
                    result.Add(GetInstanceMethod((DbGeography geo) => geo.PointAt(default(int))), "PointAt");
                    result.Add(GetStaticMethod(() => DbGeometry.FromText(default(string))), "GeometryFromText");
                    result.Add(GetStaticMethod(() => DbGeometry.FromText(default(string), default(int))), "GeometryFromText");
                    result.Add(GetStaticMethod(() => DbGeometry.PointFromText(default(string), default(int))), "GeometryPointFromText");
                    result.Add(GetStaticMethod(() => DbGeometry.LineFromText(default(string), default(int))), "GeometryLineFromText");
                    result.Add(GetStaticMethod(() => DbGeometry.PolygonFromText(default(string), default(int))), "GeometryPolygonFromText");
                    result.Add(
                        GetStaticMethod(() => DbGeometry.MultiPointFromText(default(string), default(int))), "GeometryMultiPointFromText");
                    result.Add(
                        GetStaticMethod(() => DbGeometry.MultiLineFromText(default(string), default(int))), "GeometryMultiLineFromText");
                    result.Add(
                        GetStaticMethod(() => DbGeometry.MultiPolygonFromText(default(string), default(int))),
                        "GeometryMultiPolygonFromText");
                    result.Add(
                        GetStaticMethod(() => DbGeometry.GeometryCollectionFromText(default(string), default(int))),
                        "GeometryCollectionFromText");
                    result.Add(GetStaticMethod(() => DbGeometry.FromBinary(default(byte[]))), "GeometryFromBinary");
                    result.Add(GetStaticMethod(() => DbGeometry.FromBinary(default(byte[]), default(int))), "GeometryFromBinary");
                    result.Add(GetStaticMethod(() => DbGeometry.PointFromBinary(default(byte[]), default(int))), "GeometryPointFromBinary");
                    result.Add(GetStaticMethod(() => DbGeometry.LineFromBinary(default(byte[]), default(int))), "GeometryLineFromBinary");
                    result.Add(
                        GetStaticMethod(() => DbGeometry.PolygonFromBinary(default(byte[]), default(int))), "GeometryPolygonFromBinary");
                    result.Add(
                        GetStaticMethod(() => DbGeometry.MultiPointFromBinary(default(byte[]), default(int))),
                        "GeometryMultiPointFromBinary");
                    result.Add(
                        GetStaticMethod(() => DbGeometry.MultiLineFromBinary(default(byte[]), default(int))), "GeometryMultiLineFromBinary");
                    result.Add(
                        GetStaticMethod(() => DbGeometry.MultiPolygonFromBinary(default(byte[]), default(int))),
                        "GeometryMultiPolygonFromBinary");
                    result.Add(
                        GetStaticMethod(() => DbGeometry.GeometryCollectionFromBinary(default(byte[]), default(int))),
                        "GeometryCollectionFromBinary");
                    result.Add(GetStaticMethod(() => DbGeometry.FromGml(default(string))), "GeometryFromGml");
                    result.Add(GetStaticMethod(() => DbGeometry.FromGml(default(string), default(int))), "GeometryFromGml");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.AsBinary()), "AsBinary");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.AsGml()), "AsGml");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.AsText()), "AsText");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.SpatialEquals(default(DbGeometry))), "SpatialEquals");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.Disjoint(default(DbGeometry))), "SpatialDisjoint");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.Intersects(default(DbGeometry))), "SpatialIntersects");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.Touches(default(DbGeometry))), "SpatialTouches");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.Crosses(default(DbGeometry))), "SpatialCrosses");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.Within(default(DbGeometry))), "SpatialWithin");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.Contains(default(DbGeometry))), "SpatialContains");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.Overlaps(default(DbGeometry))), "SpatialOverlaps");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.Relate(default(DbGeometry), default(string))), "SpatialRelate");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.Buffer(default(double))), "SpatialBuffer");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.Distance(default(DbGeometry))), "Distance");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.Intersection(default(DbGeometry))), "SpatialIntersection");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.Union(default(DbGeometry))), "SpatialUnion");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.Difference(default(DbGeometry))), "SpatialDifference");
                    result.Add(
                        GetInstanceMethod((DbGeometry geo) => geo.SymmetricDifference(default(DbGeometry))), "SpatialSymmetricDifference");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.ElementAt(default(int))), "SpatialElementAt");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.PointAt(default(int))), "PointAt");
                    result.Add(GetInstanceMethod((DbGeometry geo) => geo.InteriorRingAt(default(int))), "InteriorRingAt");
                    return(result);
                }
コード例 #5
0
        public HttpResponseMessage UploadMapShape()
        {
            HttpResponseMessage result = null;
            int bcount = 0;

            try
            {
                var httpRequest = HttpContext.Current.Request;

                PROJECT_IMPACT importInfo = null;

                if (httpRequest.Form.Count > 0)
                {
                    var imageInfo = httpRequest.Form["ImageInfo"];
                    if (imageInfo != null)
                    {
                        importInfo = (new System.Web.Script.Serialization.JavaScriptSerializer()).Deserialize <PROJECT_IMPACT>(imageInfo);
                    }
                }



                List <Geometry> geometries = new List <Geometry>(0);
                if (httpRequest.Files.Count > 0)
                {
                    string sessionID = Guid.NewGuid().ToString();



                    var docfiles = new List <string>();
                    foreach (string file in httpRequest.Files)
                    {
                        var postedFile = httpRequest.Files[file];

                        string targetFolder = $@"{HttpContext.Current.Server.MapPath("~")}UploadShape\{sessionID}";
                        if (!System.IO.Directory.Exists(targetFolder))
                        {
                            System.IO.Directory.CreateDirectory(targetFolder);
                        }

                        /*save file from client*/
                        var zipFilePath = $@"{targetFolder}\{postedFile.FileName}";
                        postedFile.SaveAs(zipFilePath);
                        docfiles.Add(zipFilePath);

                        /*extract zip file*/
                        var extractFilePath = $"{targetFolder}";
                        System.IO.Compression.ZipFile.ExtractToDirectory(zipFilePath, extractFilePath, System.Text.Encoding.UTF8);

                        /*process unzip file*/

                        var zipDirs = System.IO.Directory.GetDirectories(targetFolder);
                        zipDirs.ToList().ForEach(zipDir =>
                        {
                            var dirs = System.IO.Directory.GetDirectories(zipDir);
                            dirs.ToList().ForEach(dir =>
                            {
                                var loop = true;
                                /*search shape file*/
                                while (loop)
                                {
                                    loop      = false;
                                    var files = System.IO.Directory.GetFiles(dir, "*.shp", System.IO.SearchOption.AllDirectories);
                                    /*if dbf file not found then search shp*/
                                    if (files.Count() == 0)
                                    {
                                        files = System.IO.Directory.GetFiles(dir, "*.dbf", System.IO.SearchOption.AllDirectories);
                                    }

                                    files.ToList().ForEach(f =>
                                    {
                                        var fileInfo = new System.IO.FileInfo(f);

                                        try
                                        {
                                            Shapefile indexMapFile = Shapefile.OpenFile(f);
                                            indexMapFile.Reproject(KnownCoordinateSystems.Geographic.Asia.Indian1975);



                                            TDM.Models.Util.LatLngUTMConverter latLngUTMConverter = new TDM.Models.Util.LatLngUTMConverter("WGS 84");
                                            //var rr = latLngUTMConverter.convertLatLngToUtm(15.000095111201411, 100.64638250268084);

                                            string utmShape = "";
                                            foreach (IFeature feature in indexMapFile.Features)
                                            {
                                                if (feature != null && feature.Geometry != null)
                                                {
                                                    utmShape = feature.Geometry.Coordinates
                                                               .Select(coordinate => latLngUTMConverter.convertLatLngToUtm(coordinate.Y, coordinate.X))
                                                               .Select(utm => $"{utm.Easting} {utm.Northing}")
                                                               .Aggregate((current, next) => current + ", " + next);

                                                    geometries.Add(new Geometry()
                                                    {
                                                        //Shape = feature.Geometry.ToString(),
                                                        Shape    = $"{feature.Geometry.OgcGeometryType.ToString().ToUpper()} (({utmShape}))",
                                                        AREA     = Convert.ToDecimal(feature.DataRow["AREA"]),
                                                        ORIGIN_X = feature.DataRow["ORIGIN_X"].ToString(),
                                                        ORIGIN_Y = feature.DataRow["ORIGIN_Y"].ToString()
                                                    });
                                                }
                                            }
                                        }
                                        catch (Exception ex)
                                        {
                                            string k = "";
                                        }
                                    });
                                }
                            });
                        });
                    }


                    /*save data*/

                    importInfo.ID   = 0;
                    importInfo.Area = geometries.Sum(g => g.AREA);
                    PROJECT_IMPACT saveProject = tdmEntities.PROJECT_IMPACT.Add(importInfo);
                    tdmEntities.SaveChanges();

                    foreach (var geometry in geometries)
                    {
                        if (!geometry.Shape.Contains("MULTIPO"))
                        {
                            tdmEntities.PROJECT_IMPACT_GEOMETRY.Add(new PROJECT_IMPACT_GEOMETRY()
                            {
                                ProjectImpactID = importInfo.ID,
                                OriginX         = geometry.ORIGIN_X,
                                OriginY         = geometry.ORIGIN_Y,
                                Area            = geometry.AREA,
                                Shape           = (geometry.Shape.Contains("MULTIPO")) ? DbGeometry.MultiPolygonFromText(geometry.Shape, 4326) : DbGeometry.PolygonFromText(geometry.Shape, 4326),
                                UpdateDate      = DateTime.Now,
                                CreateDate      = DateTime.Now
                            });
                        }
                    }

                    tdmEntities.SaveChanges();

                    result = Request.CreateResponse(HttpStatusCode.Created, "Success");
                }
                else
                {
                    result = Request.CreateResponse(HttpStatusCode.BadRequest);
                }
            }
            catch (Exception exc)
            {
                result = Request.CreateResponse(HttpStatusCode.InternalServerError, exc.Message);
            }

            return(result);
        }