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);
}
