private void NewItemFromMailButton_Click(object sender, RibbonControlEventArgs e) { if (_mailItem == null) { return; } EnsureSettingsValid(); StringBuilder body = new StringBuilder(_mailItem.HTMLBody); foreach (Attachment attachment in _mailItem.Attachments) { var fileName = attachment.FileName; if (IsImageFileExtension(Path.GetExtension(fileName))) { string attach_content_id = @"http://schemas.microsoft.com/mapi/proptag/0x3712001E"; var contentId = attachment.PropertyAccessor.GetProperty(attach_content_id); if (body.ToString().IndexOf(string.Format("src=\"cid:{0}\"", contentId), StringComparison.OrdinalIgnoreCase) > 0) { var tempName = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + Path.GetExtension(fileName)); attachment.SaveAsFile(tempName); body.Replace(string.Format("src=\"cid:{0}\"", contentId), string.Format("src=\"file:///{0}\"", tempName)); } } } var settings = MySettingsManager.GetSettings <TfsSettings>(); var fields = new Dictionary <string, object>(); fields.Add(settings.FieldRefNameForMailBody, body.ToString()); UIHelper.OpenWorkItemForm(settings.WorkItemType, _mailItem.Subject, fields); }
/// <summary> /// Logs out the user in session. /// </summary> /// <param name="returnUrl">The return URL.</param> /// <returns></returns> public ActionResult LogOut(string returnUrl) { IUserContext userContext = SessionHandler.UserContext; if (userContext != null) { if (SessionHandler.MySettings != null) { MySettingsManager.SaveLastSettings(userContext, SessionHandler.MySettings); MySettingsManager.SaveToDisk(userContext, MySettingsManager.SettingsName, SessionHandler.MySettings); } CoreData.UserManager.Logout(userContext); SessionHandler.UserContext = null; // When logged out mySettings must be cleared SessionHandler.MySettings = new MySettings(); FormsService.SignOut(); } if (!String.IsNullOrEmpty(returnUrl)) { return(Redirect(returnUrl)); } else { return(RedirectToAction("Index", "Home")); } }
/// <summary> /// Deletes the selected uploaded gis layers. /// </summary> /// <param name="filenames">The filenames.</param> /// <returns></returns> public JsonNetResult DeleteUploadedGisLayers(string[] filenames) { JsonModel jsonModel; try { jsonModel = JsonModel.CreateSuccess("Ok"); foreach (string filename in filenames) { if (!MySettingsManager.DeleteMapDataFile(GetCurrentUser(), filename)) { jsonModel = JsonModel.CreateFailure("Deleting file failed."); } //Check if file layer is in use, if so, remove it var viewManager = new WfsLayersViewManager(GetCurrentUser(), SessionHandler.MySettings); var layer = viewManager.GetWfsLayers().FirstOrDefault(l => l.Name == GetLayerName(filename)); if (layer != null) { viewManager.RemoveWfsLayer(layer.Id); } } return(new JsonNetResult(jsonModel)); } catch (Exception ex) { jsonModel = JsonModel.CreateFailure(ex.Message); } return(new JsonNetResult(jsonModel)); }
/// <summary> /// Calculates the combined grid result. /// </summary> /// <param name="calculationCoordinateSystemId">The calculation coordinate system id.</param> /// <param name="gridCellSize">Size of the grid cell.</param> /// <param name="wfsLayerId">The WFS layer id.</param> /// <returns>Combined grid cell statistics.</returns> public CombinedGridStatisticsResult CalculateCombinedGridResult(int calculationCoordinateSystemId, int gridCellSize, int wfsLayerId) { GridSpecification gridSpecification = new GridSpecification(); CoordinateSystem displayCoordinateSystem = MySettings.Presentation.Map.DisplayCoordinateSystem; gridSpecification.GridCoordinateSystem = (GridCoordinateSystem)calculationCoordinateSystemId; gridSpecification.GridCellSize = gridCellSize; gridSpecification.IsGridCellSizeSpecified = true; gridSpecification.GridCellGeometryType = GridCellGeometryType.Polygon; if (MySettings.Filter.Spatial.IsActive) { // Create bounding box from spatial filter ObservableCollection <DataPolygon> polygons = MySettings.Filter.Spatial.Polygons; if (polygons.Count > 0) { BoundingBox boundingBox = polygons.GetBoundingBox(); CoordinateSystem toCoordinateSystem = CoordinateSystemHelper.GetCoordinateSystemFromGridCoordinateSystem(gridSpecification.GridCoordinateSystem); IPolygon convertedBoundingBoxPolygon = GisTools.CoordinateConversionManager.GetConvertedBoundingBox(boundingBox, MySettings.Filter.Spatial.PolygonsCoordinateSystem, toCoordinateSystem); BoundingBox convertedBoundingBox = convertedBoundingBoxPolygon.GetBoundingBox(); gridSpecification.BoundingBox = convertedBoundingBox; } } WfsLayerSetting wfsLayer = SessionHandler.MySettings.DataProvider.MapLayers.WfsLayers.FirstOrDefault(l => l.Id == wfsLayerId); string featuresUrl = ""; string featureCollectionJson = null; if (wfsLayer.IsFile) { featureCollectionJson = JObject.FromObject(MySettingsManager.GetMapDataFeatureCollection(UserContext, wfsLayer.GeometryName, gridSpecification.GridCoordinateSystem.GetCoordinateSystemId())).ToString(); } else { if (string.IsNullOrEmpty(wfsLayer.Filter)) { featuresUrl = string.Format("{0}?service=wfs&version=1.1.0&request=GetFeature&typeName={1}", wfsLayer.ServerUrl, wfsLayer.TypeName); } else { featuresUrl = string.Format("{0}?service=wfs&version=1.1.0&request=GetFeature&typeName={1}&filter={2}", wfsLayer.ServerUrl, wfsLayer.TypeName, wfsLayer.Filter); } } var speciesObservationSearchCriteriaManager = new SpeciesObservationSearchCriteriaManager(UserContext); SpeciesObservationSearchCriteria searchCriteria = speciesObservationSearchCriteriaManager.CreateSearchCriteria(MySettings); IList <IGridCellCombinedStatistics> gridCells = CoreData.AnalysisManager.GetGridCellFeatureStatisticsCombinedWithSpeciesObservationCounts(UserContext, gridSpecification, searchCriteria, null, featuresUrl, featureCollectionJson, displayCoordinateSystem); if (MySettings.Calculation.GridStatistics.GenerateAllGridCells) { gridCells = AddEmptyGridCells(gridCells, gridSpecification, displayCoordinateSystem); gridCells = RemoveGridCellsOutsideBounds(gridCells, gridSpecification); } gridCells = gridCells.OrderBy(x => x.Identifier).ToList(); return(CombinedGridStatisticsResult.Create( (CoordinateSystemId)calculationCoordinateSystemId, displayCoordinateSystem.Id, gridCellSize, gridCells)); }
public RedirectResult SaveCurrentMySettings(string returnUrl) { MySettings mySettings = SessionHandler.MySettings; if (mySettings.IsNotNull()) { MySettingsManager.SaveToDisk(SettingsName, mySettings); } return(Redirect(returnUrl)); }
public AddWfsLayerViewModel CreateAddWfsLayerViewModel(ModelStateDictionary modelState, string wfsUrl, string uploadUrl, string successUrl) { AddWfsLayerViewModel model; if (!string.IsNullOrEmpty(wfsUrl)) { try { var wfsCapabilities = WFSManager.GetWFSCapabilitiesAndMergeDescribeFeatureTypes(wfsUrl); var uri = new Uri(wfsUrl); var baseUrl = uri.GetLeftPart(UriPartial.Path); model = AddWfsLayerViewModel.Create(baseUrl, wfsCapabilities); } catch (Exception) { var baseUrl = new UriBuilder(wfsUrl).Uri.GetLeftPart(UriPartial.Path); modelState.AddModelError("", string.Format("The server: {0}, didn't respond correct", baseUrl)); model = AddWfsLayerViewModel.Create(baseUrl); } } else { model = new AddWfsLayerViewModel(); } model.UploadGeoJsonViewModel = new UploadGeoJsonViewModel(uploadUrl, successUrl) { FileFormatDescription = Resource.DataAddWfsLayeraFileUploadForm, FileNameRegEx = "geojson|zip", }; model.ShowFile = base.UserContext.User.PersonId != null; if (model.ShowFile) { var fileNames = MySettingsManager.GetSavedMapDataFiles(base.UserContext); if (fileNames != null) { model.Files = (from fn in fileNames select new AddWfsLayerViewModel.FileViewModel { FileName = fn, Name = fn.IndexOf(".", StringComparison.CurrentCulture) == -1 ? fn : fn.Substring(0, fn.LastIndexOf(".", StringComparison.CurrentCultureIgnoreCase - 1)) }).ToArray(); } } return(model); }
public string Index() { var srsName = Request["srsName"]; var typeName = Request["typeName"]; if (string.IsNullOrEmpty(typeName) && Request.HttpMethod == "POST") { XDocument payload; try { //Try to load xml from payload using (var input = Request.InputStream) { payload = XDocument.Load(input); input.Close(); } } catch { return(null); } if (payload == null || payload.Root == null) { return(null); } var outputFormatAttribute = payload.Root.Attribute("outputFormat"); if (outputFormatAttribute == null || outputFormatAttribute.Value != "json") { return(null); } var wfsQuery = payload.Root.Descendants(XName.Get("Query", payload.Root.Name.Namespace.NamespaceName)) .FirstOrDefault(); if (wfsQuery == null) { return(null); } srsName = wfsQuery.Attribute("srsName").Value; typeName = wfsQuery.Attribute("typeName").Value; } typeName = Server.UrlDecode(typeName); var fileName = typeName.Substring(typeName.LastIndexOf(":", StringComparison.CurrentCulture) + 1); var requestedCoordinateSystemId = GisTools.GeoJsonUtils.FindCoordinateSystemId(new NamedCRS(srsName)); return(JObject.FromObject(MySettingsManager.GetMapDataFeatureCollection(GetCurrentUser(), fileName, requestedCoordinateSystemId)).ToString()); }
private void Session_End(object sender, EventArgs e) { var userContext = Session["userContext"] as IUserContext; var mySettings = Session["mySettings"] as MySettings; if (userContext != null && mySettings != null) { LastUserSessionIdManager.UpdateLastUserSessionId(userContext.User.UserName, Session.SessionID); MySettingsManager.SaveLastSettings(userContext, mySettings); MySettingsManager.SaveToDisk(userContext, MySettingsManager.SettingsName, mySettings); } }
/// <summary> /// Adds selected uploaded gis layers to WFS layers. /// </summary> /// <param name="filenames">The filenames.</param> /// <returns></returns> public JsonNetResult AddUploadedGisLayers(string[] filenames) { JsonModel jsonModel = JsonModel.CreateSuccess("Ok"); try { foreach (string filename in filenames) { if (string.IsNullOrEmpty(filename)) { jsonModel = JsonModel.CreateFailure("No file selected."); return(new JsonNetResult(jsonModel)); } try { var featureCollection = MySettingsManager.GetMapDataFeatureCollection( GetCurrentUser(), filename, CoordinateSystemId.None); if (featureCollection == null) { jsonModel = JsonModel.CreateFailure("File not found."); return(new JsonNetResult(jsonModel)); } if (AddFileWfsLayer(filename, featureCollection)) { jsonModel = JsonModel.CreateSuccess("Ok"); } else { jsonModel = JsonModel.CreateFailure(Resource.SharedLayerAlreadyExists); break; } } catch (Exception) { jsonModel = JsonModel.CreateFailure(Resource.FilterSpatialUnableToParseGeoJsonFile); break; } } } catch (Exception ex) { jsonModel = JsonModel.CreateFailure(ex.Message); } return(new JsonNetResult(jsonModel)); }
public WfsStatisticsGridResult CalculateGridResult(IUserContext userContext, int coordinateSystemId, int gridSize, int wfsLayerId) { var requestedGridCoordinateSystem = (GridCoordinateSystem)coordinateSystemId; var gridSpecification = new GridSpecification { GridCoordinateSystem = requestedGridCoordinateSystem, GridCellSize = gridSize, IsGridCellSizeSpecified = true, GridCellGeometryType = GridCellGeometryType.Polygon }; if (MySettings.Filter.Spatial.IsActive) { // Create bounding box from spatial filter var polygons = MySettings.Filter.Spatial.Polygons; if (polygons.Count > 0) { var boundingBox = polygons.GetBoundingBox(); var toCoordinateSystem = CoordinateSystemHelper.GetCoordinateSystemFromGridCoordinateSystem(gridSpecification.GridCoordinateSystem); var convertedBoundingBoxPolygon = GisTools.CoordinateConversionManager.GetConvertedBoundingBox(boundingBox, MySettings.Filter.Spatial.PolygonsCoordinateSystem, toCoordinateSystem); gridSpecification.BoundingBox = convertedBoundingBoxPolygon.GetBoundingBox(); } } var displayCoordinateSystem = MySettings.Presentation.Map.DisplayCoordinateSystem; var wfsLayer = SessionHandler.MySettings.DataProvider.MapLayers.WfsLayers.FirstOrDefault(l => l.Id == wfsLayerId); string featuresUrl = null; string featureCollectionJson = null; if (wfsLayer.IsFile) { featureCollectionJson = JObject.FromObject(MySettingsManager.GetMapDataFeatureCollection(userContext, wfsLayer.GeometryName, requestedGridCoordinateSystem.GetCoordinateSystemId())).ToString(); } else { if (string.IsNullOrEmpty(wfsLayer.Filter)) { featuresUrl = string.Format("{0}?service=wfs&version=1.1.0&request=GetFeature&typeName={1}", wfsLayer.ServerUrl, wfsLayer.TypeName); } else { featuresUrl = string.Format("{0}?service=wfs&version=1.1.0&request=GetFeature&typeName={1}&filter={2}", wfsLayer.ServerUrl, wfsLayer.TypeName, wfsLayer.Filter); } } var list = CoreData.AnalysisManager.GetGridFeatureStatistics(UserContext, null, featuresUrl, featureCollectionJson, gridSpecification, displayCoordinateSystem); return(WfsStatisticsGridResult.Create(list)); }
/// <summary> /// Saves the current settings. /// </summary> public RedirectResult SaveMySettings(string returnUrl) { IUserContext userContext = GetCurrentUser(); if (!userContext.IsAuthenticated()) { throw new Exception("User is not logged in"); } MySettings mySettings = SessionHandler.MySettings; MySettingsManager.SaveToDisk(userContext, MySettingsManager.SettingsName, mySettings); SessionHandler.UserMessages.Add(new UserMessage(Resources.Resource.MySettingsSaved)); return(Redirect(returnUrl)); }
private void LoadMySettings(IUserContext userContext) { try { if (MySettingsManager.DoesNameExistOnDisk(userContext, MySettingsManager.SettingsName)) { var mySettings = MySettingsManager.LoadFromDisk(userContext, MySettingsManager.SettingsName); mySettings.EnsureDataProviders(userContext); SessionHandler.MySettings = mySettings; RemoveCookie("MapState"); } } catch (Exception) { } }
public RedirectResult LoadMySettings(string returnUrl) { try { if (MySettingsManager.DoesNameExistOnDisk(SettingsName)) { MySettings mySettings = MySettingsManager.LoadFromDisk(SettingsName); SessionHandler.MySettings = mySettings; } } catch (Exception) { } return(Redirect(returnUrl)); }
/// <summary> /// Loads a MySettings object from disk and uses this /// as the current settings. /// </summary> /// <returns></returns> public RedirectToRouteResult LoadMySettings() { try { IUserContext userContext = GetCurrentUser(); if (MySettingsManager.DoesNameExistOnDisk(userContext, MySettingsManager.SettingsName)) { MySettings mySettings = MySettingsManager.LoadFromDisk(userContext, MySettingsManager.SettingsName); SessionHandler.MySettings = mySettings; RemoveCookie("MapState"); } } catch (Exception) { } SessionHandler.UserMessages.Add(new UserMessage(Resources.Resource.MySettingsLoaded)); return(RedirectToAction("Index", "Home")); }
public void DoesLastSettingsExist_SettingsDontExist_ReturnFalse() { using (ShimsContext.Create()) { ShimFilePath(); IUserContext userContext; Boolean doesLastSettingsExist; // Arrange userContext = GetTestUserContext(); // Act MySettingsManager.DeleteLastSettingsFile(userContext); doesLastSettingsExist = MySettingsManager.DoesLastSettingsExist(userContext); // Assert Assert.IsFalse(doesLastSettingsExist); } }
public void GetLastSettingsSaveTime_LastSettingsDontExists_ReturnNull() { using (ShimsContext.Create()) { ShimFilePath(); IUserContext userContext; DateTime? lastSettingsSaveTime; // Arrange userContext = GetTestUserContext(); // Act MySettingsManager.DeleteLastSettingsFile(userContext); lastSettingsSaveTime = MySettingsManager.GetLastSettingsSaveTime(userContext); // Assert Assert.IsNull(lastSettingsSaveTime); } }
public JsonNetResult DeleteMapDataFile(string fileName) { var jsonModel = JsonModel.CreateSuccess("Ok"); if (!MySettingsManager.DeleteMapDataFile(GetCurrentUser(), fileName)) { jsonModel = JsonModel.CreateFailure("Deleting file failed."); } //Check if file layer is in use, if so, remove it var viewManager = new WfsLayersViewManager(GetCurrentUser(), SessionHandler.MySettings); var layer = viewManager.GetWfsLayers().FirstOrDefault(l => l.Name == GetLayerName(fileName)); if (layer != null) { viewManager.RemoveWfsLayer(layer.Id); } return(new JsonNetResult(jsonModel)); }
public void SerializeAndDeserializeMySettings() { using (ShimsContext.Create()) { ShimFilePath(); AnalysisPortal.MySettings.MySettings mySettings; AnalysisPortal.MySettings.MySettings loadedSettings; const string settingsName = "test"; // Arrange mySettings = CreateMySettingsObjectWithTaxonFilter(1, 2, 5); // Act MySettingsManager.SaveToDisk(settingsName, mySettings); loadedSettings = MySettingsManager.LoadFromDisk(settingsName); // Assert CollectionAssert.AreEqual(new[] { 1, 2, 5 }, loadedSettings.Filter.Taxa.TaxonIds); } }
/// <summary> /// Gets all uploaded gis files. /// </summary> /// <returns>A list with the logged in users all uploaded GIS-files.</returns> public List <AddWfsLayerViewModel.FileViewModel> GetAllUploadedGisFiles() { var fileNames = MySettingsManager.GetSavedMapDataFiles(base.UserContext); if (fileNames == null) { return(new List <AddWfsLayerViewModel.FileViewModel>()); } List <AddWfsLayerViewModel.FileViewModel> files = (from fn in fileNames select new AddWfsLayerViewModel.FileViewModel { FileName = fn, Name = fn.IndexOf(".", StringComparison.CurrentCulture) == -1 ? fn : fn.Substring(0, fn.LastIndexOf(".", StringComparison.CurrentCultureIgnoreCase - 1)) }).ToList(); return(files); }
// This test expects that it can write to "C:\Temp\myTempFile.txt". public void DoesLastSettingsExist_SettingsExists_ReturnTrue() { using (ShimsContext.Create()) { ShimFilePath(); IUserContext userContext; Boolean doesLastSettingsExist; AnalysisPortal.MySettings.MySettings mySettings; // Arrange userContext = GetTestUserContext(); mySettings = CreateMySettingsObjectWithTaxonFilter(1, 2, 5); // Act MySettingsManager.SaveLastSettings(userContext, mySettings); doesLastSettingsExist = MySettingsManager.DoesLastSettingsExist(userContext); // Assert Assert.IsTrue(doesLastSettingsExist); } }
/// <summary> /// Gets feature collection based on selected WFS layer in SummaryStatistics. /// </summary> /// <returns>A feature collection or null.</returns> private FeatureCollection GetFeatureCollection() { if (!MySettings.Calculation.SummaryStatistics.WfsSummaryStatisticsLayerId.HasValue) { return(null); } int wfsLayerId = MySettings.Calculation.SummaryStatistics.WfsSummaryStatisticsLayerId.Value; WfsLayerSetting wfsLayer = MySettings.DataProvider.MapLayers.WfsLayers.FirstOrDefault(l => l.Id == wfsLayerId); string featuresUrl; string srsName = MySettings.Presentation.Map.PresentationCoordinateSystemId.EpsgCode(); FeatureCollection featureCollection = null; if (wfsLayer.IsFile) { featureCollection = MySettingsManager.GetMapDataFeatureCollection( UserContext, wfsLayer.GeometryName, MySettings.Presentation.Map.PresentationCoordinateSystemId); } else { if (string.IsNullOrEmpty(wfsLayer.Filter)) { featuresUrl = string.Format("{0}?service=wfs&version=1.1.0&request=GetFeature&typeName={1}&srsName={2}", wfsLayer.ServerUrl, wfsLayer.TypeName, srsName); } else { featuresUrl = string.Format( "{0}?service=wfs&version=1.1.0&request=GetFeature&typeName={1}&filter={2}&srsName={3}", wfsLayer.ServerUrl, wfsLayer.TypeName, wfsLayer.Filter, srsName); } featureCollection = WFSManager.GetWfsFeaturesUsingHttpPost(featuresUrl); } return(featureCollection); }
// This test expects that it can write to "C:\Temp\myTempFile.txt" public void GetLastSettingsSaveTime_LastSettingsExists_ReturnDateTimeNow() { using (ShimsContext.Create()) { ShimFilePath(); IUserContext userContext; AnalysisPortal.MySettings.MySettings mySettings; DateTime?lastSettingsSaveTime; // Arrange userContext = GetTestUserContext(); mySettings = CreateMySettingsObjectWithTaxonFilter(1, 2, 5); // Act MySettingsManager.SaveLastSettings(userContext, mySettings); lastSettingsSaveTime = MySettingsManager.GetLastSettingsSaveTime(userContext); TimeSpan timeSpan = DateTime.Now - lastSettingsSaveTime.Value; // Assert Assert.IsTrue(timeSpan.TotalMilliseconds < 1000); } }
public RedirectResult LoadAutoSavedSettings(string returnUrl, string userName) { if (SessionHandler.UserContext != null) { SessionHandler.MySettings = MySettingsManager.LoadLastSettings(SessionHandler.UserContext); SessionHandler.UserMessages.Add(new UserMessage(Resource.SharedAutosavedSettingsLoaded, UserMessageType.Info)); } else if (userName != null) { HttpCookie httpCookie = Request.Cookies["ASP.NET_SessionId"]; if (httpCookie != null) { string sessionId = httpCookie.Value; if (LastUserSessionIdManager.IsLastUserSessionIdOk(userName, sessionId)) { SessionHandler.MySettings = MySettingsManager.LoadLastSettings(userName); } } } return(Redirect(returnUrl.ToLower())); }
/// <summary> /// Creates a MySettingsButtonGroupViewModel. /// </summary> /// <returns></returns> public MySettingsButtonGroupViewModel CreateMySettingsButtonGroupViewModel() { var model = new MySettingsButtonGroupViewModel(); bool isAnySettingsMade = MySettings.HasSettings; bool isUserLoggedIn = UserContext.IsAuthenticated(); bool doesSettingsFileExistOnDisk = false; if (isUserLoggedIn) { doesSettingsFileExistOnDisk = MySettingsManager.DoesNameExistOnDisk(UserContext, MySettingsManager.SettingsName); } if (isAnySettingsMade && isUserLoggedIn) { model.IsSaveButtonEnabled = true; } if (isUserLoggedIn && doesSettingsFileExistOnDisk) { model.IsLoadButtonEnabled = true; } if (isAnySettingsMade) { model.IsResetButtonEnabled = true; } if (isUserLoggedIn) { model.LastSettingsSaveTime = MySettingsManager.GetLastSettingsSaveTime(UserContext); if (model.LastSettingsSaveTime.HasValue) { model.DoesLastSettingsExists = true; } } return(model); }
public void SerializeAndDeserializeProtectedSettings() { // When this test is run a file called test.dat will be saved to // c:\InetPub\wwwRoot\AnalysisPortalTestRun\temp\settings using (ShimsContext.Create()) { string fullPath = @"C:\InetPub\wwwRoot\AnalysisPortalTestRun\temp\settings\myTempFile.txt"; ShimHostingEnvironment.MapPathString = (path) => { return(fullPath); }; var mySettings = new ArtDatabanken.WebApplication.AnalysisPortal.MySettings.MySettings(); mySettings.Filter.Taxa.TaxonIds.Add(1); mySettings.Filter.Taxa.TaxonIds.Add(2); mySettings.Filter.Taxa.TaxonIds.Add(5); int wfsLayersCount = mySettings.DataProvider.MapLayers.WfsLayers.Count; var layer = mySettings.DataProvider.MapLayers.AddWfsLayer(new WfsLayerSetting() { Name = "Test", GeometryType = GeometryType.Polygon, Color = "#336699", Filter = "", ServerUrl = "http://slwgeo.artdata.slu.se:8080/geoserver/SLW/wfs", TypeName = "SLW:MapOfSwedishCounties" }); MySettingsManager.SaveToDisk("test", mySettings); var mySettings2 = MySettingsManager.LoadFromDisk("test"); Assert.IsNotNull(mySettings2); Assert.IsTrue(mySettings2.Filter.Taxa.TaxonIds.Contains(1)); Assert.IsTrue(mySettings2.Filter.Taxa.TaxonIds.Contains(2)); Assert.IsTrue(mySettings2.Filter.Taxa.TaxonIds.Contains(5)); Assert.AreEqual(wfsLayersCount + 1, mySettings.DataProvider.MapLayers.WfsLayers.Count); } }
// This test expects that it can write to "C:\Temp\myTempFile.txt" public void SaveAndGetLastUsedSettings_CreateMySettingsWithTaxa_LastSettingsSavedToFileAndReturnedOnLoad() { using (ShimsContext.Create()) { ShimFilePath(); IUserContext userContext; AnalysisPortal.MySettings.MySettings mySettings; AnalysisPortal.MySettings.MySettings loadedSettings; // Arrange userContext = GetTestUserContext(); mySettings = CreateMySettingsObjectWithTaxonFilter(1, 2, 5); // Act MySettingsManager.SaveLastSettings(userContext, mySettings); loadedSettings = MySettingsManager.LoadLastSettings(userContext); // Assert CollectionAssert.AreEqual(new List <int> { 1, 2, 5 }, loadedSettings.Filter.Taxa.TaxonIds); } }
// This test expects that it can write to "C:\Temp\myTempFile.txt" public void SaveLastSettings_SaveTwoTimes_LastSavedSettingsIsOverwritten() { using (ShimsContext.Create()) { ShimFilePath(); IUserContext userContext; AnalysisPortal.MySettings.MySettings mySettings; AnalysisPortal.MySettings.MySettings loadedSettings; // Arrange userContext = GetTestUserContext(); mySettings = CreateMySettingsObjectWithTaxonFilter(1, 2, 5); // Act MySettingsManager.SaveLastSettings(userContext, mySettings); loadedSettings = MySettingsManager.LoadLastSettings(userContext); // Assert CollectionAssert.AreEqual(new List <int> { 1, 2, 5 }, loadedSettings.Filter.Taxa.TaxonIds); // Arrange mySettings = CreateMySettingsObjectWithTaxonFilter(10, 12, 22); // Act MySettingsManager.SaveLastSettings(userContext, mySettings); loadedSettings = MySettingsManager.LoadLastSettings(userContext); // Assert CollectionAssert.AreEqual(new List <int> { 10, 12, 22 }, loadedSettings.Filter.Taxa.TaxonIds); } }
public JsonNetResult UploadMapDataFile(int?coordinateSystemId) { JsonModel jsonModel; if (Request.Files.Count == 0) { jsonModel = JsonModel.CreateFailure("No files uploaded."); return(new JsonNetResult(jsonModel)); } if (Request.Files.Count > 1) { jsonModel = JsonModel.CreateFailure("Too many files uploaded."); return(new JsonNetResult(jsonModel)); } var file = Request.Files[0]; if (file == null || file.ContentLength == 0) { jsonModel = JsonModel.CreateFailure("The file has no content."); return(new JsonNetResult(jsonModel)); } const long MAX_FILE_SIZE = 5120000; //5MB if (file.ContentLength > MAX_FILE_SIZE) { jsonModel = JsonModel.CreateFailure(string.Format("Max file size {0} MB", MAX_FILE_SIZE / 1024000)); return(new JsonNetResult(jsonModel)); } //Set file name for uploaded file and remove file suffix for layer name var fileName = file.FileName; try { var jsonString = string.Empty; if (file.ContentType == "application/zip" || file.ContentType == "application/x-zip-compressed" || fileName.ToLower().EndsWith(".zip")) //|| file.ContentType == "application/octet-stream") { jsonString = MySettingsManager.GetGeoJsonFromShapeZip(GetCurrentUser(), file.FileName, file.InputStream); //Change file suffix since we converted shape to geojson fileName = fileName.Replace(".zip", ".geojson"); } else { jsonString = new StreamReader(file.InputStream).ReadToEnd(); } /*if (MySettingsManager.MapDataFileExists(GetCurrentUser(), fileName)) * { * jsonModel = JsonModel.CreateFailure(Resource.SharedFileAlreadyExists); * return new JsonNetResult(jsonModel); * }*/ var featureCollection = JsonConvert.DeserializeObject(jsonString, typeof(FeatureCollection)) as FeatureCollection; if (featureCollection == null) { jsonModel = JsonModel.CreateFailure(Resource.UploadFileJsonSerialaztionFaild); return(new JsonNetResult(jsonModel)); } CoordinateSystem coordinateSystem = null; if (coordinateSystemId.HasValue) { coordinateSystem = new CoordinateSystem((CoordinateSystemId)coordinateSystemId.Value); } else { coordinateSystem = GisTools.GeoJsonUtils.FindCoordinateSystem(featureCollection); if (coordinateSystem.Id == CoordinateSystemId.None) { jsonModel = JsonModel.CreateFailure(Resource.FilterSpatialUnableToDetermineCoordinateSystem); return(new JsonNetResult(jsonModel)); } } //Make sure crs is saved in file if (featureCollection.CRS == null) { featureCollection.CRS = new NamedCRS(coordinateSystem.Id.EpsgCode()); } //create a Json object from string var jsonObject = JObject.FromObject(featureCollection); //Sava json to file using (var fileStream = jsonObject.ToString().ToStream()) { MySettingsManager.SaveMapDataFile(GetCurrentUser(), fileName, fileStream); } if (AddFileWfsLayer(fileName, featureCollection)) { jsonModel = JsonModel.CreateSuccess("Ok"); } else { jsonModel = JsonModel.CreateFailure(Resource.UploafFileLayerAlreadyAdded); } } catch (ImportGisFileException importGisFileException) { jsonModel = JsonModel.CreateFailure(importGisFileException.Message); } catch (Exception ex) { jsonModel = JsonModel.CreateFailure(Resource.FilterSpatialUnableToParseGeoJsonFile); } return(new JsonNetResult(jsonModel)); }
public static string GetLayerGeojson( IUserContext currentUser, int layerId, CoordinateSystemId coordinateSystemId, IDictionary <string, object> parameters, out string layerName, MapExportModel.Extent mapExtent) { string geoJson = null; layerName = null; if (layerId == null) { return(null); } if (layerId >= CustomLayersStartLayerId) { var viewManager = new WfsLayersViewManager(currentUser, SessionHandler.MySettings); var layer = viewManager.GetWfsLayers().FirstOrDefault(l => l.Id == layerId); layerName = layer.Name; if (layer.IsFile) { geoJson = JsonConvert.SerializeObject(MySettingsManager.GetMapDataFeatureCollection(currentUser, layer.GeometryName, coordinateSystemId)); } else { var url = WFSFilterUtils.GetResultingUrl(layer.ServerUrl, layer.TypeName, "1.1.0", layer.Filter, "application%2Fjson", null, string.Format("EPSG%3A{0}", coordinateSystemId.Srid())); var request = WebRequest.Create(url); request.Credentials = CredentialCache.DefaultCredentials; // Get the response. using (var response = request.GetResponse()) { using (var dataStream = response.GetResponseStream()) { using (var reader = new StreamReader(dataStream)) { geoJson = reader.ReadToEnd(); reader.Close(); } } response.Close(); } } } else { switch (layerId) { case SpeciesRichnessGridLayerId: var taxonGridCalculator = new TaxonGridCalculator(currentUser, SessionHandler.MySettings); geoJson = taxonGridCalculator.GetTaxonGridAsGeoJson(); var attribute = (string)(parameters.ContainsKey("attribute") ? parameters["attribute"] : null); layerName = Resource.ResultViewSpeciesRichnessGridMapLayerName; if (attribute != null) { switch (attribute.ToLower().Trim()) { case "speciescount": layerName = Resource.ResultDownloadSpeciesRichnessGridMap; break; case "observationcount": layerName = Resource.ResultDownloadObservationsGridMap; break; } } break; case SpeciesObservationGridMapLayerId: case EooConvexHullLayerId: case EooConcaveHullLayerId: var speciesObservationGridCalculator = new SpeciesObservationGridCalculator(currentUser, SessionHandler.MySettings); if (layerId == SpeciesObservationGridMapLayerId) { geoJson = speciesObservationGridCalculator.GetSpeciesObservationGridAsGeoJson(); layerName = Resource.ResultViewSpeciesObservationGridMap; } else { var alphaValue = (int?)(parameters.ContainsKey("alphaValue") ? parameters["alphaValue"] : null); var useCenterPoint = (bool?)(parameters.ContainsKey("useCenterPoint") ? parameters["useCenterPoint"] : null); geoJson = speciesObservationGridCalculator.GetSpeciesObservationAOOEOOAsGeoJson( layerId == EooConcaveHullLayerId ? alphaValue : 0, useCenterPoint ?? true); layerName = Resource.MapEOOLayer; } break; case ObservationsLayerId: //Observations case SpeciesObservationClusterPointMapLayerId: SpeciesObservationResultCalculator resultCalculator = null; try { var displayCoordinateSystemId = SessionHandler.MySettings.Presentation.Map.PresentationCoordinateSystemId; resultCalculator = new SpeciesObservationResultCalculator(currentUser, SessionHandler.MySettings); geoJson = resultCalculator.GetSpeciesObservationsAsGeoJson(displayCoordinateSystemId); layerName = Resource.MapLayerObservations; } catch (Exception) { } break; } } return(geoJson); }