public void TestMapDefinitionNestedGroupDelete()
{
var conn = new Mock <IServerConnection>();
var caps = new Mock <IConnectionCapabilities>();
foreach (var rt in Enum.GetValues(typeof(ResourceTypes)))
{
caps.Setup(c => c.GetMaxSupportedResourceVersion(rt.ToString())).Returns(new Version(1, 0, 0));
}
conn.Setup(c => c.Capabilities).Returns(caps.Object);
IMapDefinition mdf = Utility.CreateMapDefinition(conn.Object, "Test");
/*
*
* [G] Group1
* [L] Layer1
* [G] Group2
* [L] Layer2
* [G] Group3
* [L] Layer3
* [G] Group4
* [L] Layer4
*
*/
var grp1 = mdf.AddGroup("Group1");
var grp2 = mdf.AddGroup("Group2");
var grp3 = mdf.AddGroup("Group3");
var grp4 = mdf.AddGroup("Group4");
grp3.Group = "Group2";
grp2.Group = "Group1";
var lyr1 = mdf.AddLayer("Group1", "Layer1", "Library://Test.LayerDefinition");
var lyr2 = mdf.AddLayer("Group2", "Layer2", "Library://Test.LayerDefinition");
var lyr3 = mdf.AddLayer("Group3", "Layer3", "Library://Test.LayerDefinition");
var lyr4 = mdf.AddLayer("Group4", "Layer4", "Library://Test.LayerDefinition");
//Delete group 1. Expect the following structure
/*
* [G] Group4
* [L] Layer4
*/
mdf.RemoveLayerGroupAndChildLayers("Group1");
Assert.Equal(1, mdf.GetGroupCount());
Assert.Equal(1, mdf.GetDynamicLayerCount());
Assert.Null(mdf.GetLayerByName("Layer1"));
Assert.Null(mdf.GetLayerByName("Layer2"));
Assert.Null(mdf.GetLayerByName("Layer3"));
Assert.NotNull(mdf.GetLayerByName("Layer4"));
Assert.Null(mdf.GetGroupByName("Group1"));
Assert.Null(mdf.GetGroupByName("Group2"));
Assert.Null(mdf.GetGroupByName("Group3"));
Assert.NotNull(mdf.GetGroupByName("Group4"));
}
protected bool Matches(RuntimeMap map, IMapDefinition mdf)
{
if (map.MapDefinition != mdf.ResourceID) return false;
if (map.Groups.Count != mdf.GetGroupCount()) return false;
if (map.Layers.Count != mdf.GetLayerCount()) return false;
foreach (var layer in map.Layers)
{
var ldfr = mdf.GetLayerByName(layer.Name);
if (ldfr == null) return false;
if (layer.LayerDefinitionID != ldfr.ResourceId) return false;
if (layer.LegendLabel != ldfr.LegendLabel) return false;
if (layer.Visible != ldfr.Visible) return false;
if (layer.Selectable != ldfr.Selectable) return false;
if (layer.ShowInLegend != ldfr.ShowInLegend) return false;
if (layer.ExpandInLegend != ldfr.ExpandInLegend) return false;
}
foreach (var group in map.Groups)
{
var grp = mdf.GetGroupByName(group.Name);
if (grp == null) return false;
if (group.ExpandInLegend != grp.ExpandInLegend) return false;
if (group.Group != grp.Group) return false;
if (group.LegendLabel != grp.LegendLabel) return false;
if (group.Name != grp.Name) return false;
if (group.ShowInLegend != grp.ShowInLegend) return false;
if (group.Visible != grp.Visible) return false;
}
return true;
}
/// <summary>
/// Performs base resource validation
/// </summary>
/// <param name="context"></param>
/// <param name="resource"></param>
/// <param name="recurse"></param>
/// <returns></returns>
protected ValidationIssue[] ValidateBase(ResourceValidationContext context, IResource resource, bool recurse)
{
Check.ArgumentNotNull(context, nameof(context));
if (context.IsAlreadyValidated(resource.ResourceID))
{
return(null);
}
if (resource.ResourceType != ResourceTypes.MapDefinition.ToString())
{
return(null);
}
List <ValidationIssue> issues = new List <ValidationIssue>();
IMapDefinition mdef = resource as IMapDefinition;
if (string.IsNullOrEmpty(mdef.CoordinateSystem))
{
issues.Add(new ValidationIssue(mdef, ValidationStatus.Warning, ValidationStatusCode.Warning_MapDefinition_MissingCoordinateSystem, Strings.MDF_NoCoordinateSystem));
}
foreach (IMapLayerGroup g in mdef.MapLayerGroup)
{
if (g.ShowInLegend && (g.LegendLabel == null || g.LegendLabel.Trim().Length == 0))
{
issues.Add(new ValidationIssue(mdef, ValidationStatus.Information, ValidationStatusCode.Info_MapDefinition_GroupMissingLabelInformation, string.Format(Strings.MDF_GroupMissingLabelInformation, g.Name)));
}
else if (g.ShowInLegend && g.LegendLabel.Trim().ToLower() == "layer group") //NOXLATE
{
issues.Add(new ValidationIssue(mdef, ValidationStatus.Information, ValidationStatusCode.Info_MapDefinition_GroupHasDefaultLabel, string.Format(Strings.MDF_GroupHasDefaultLabelInformation, g.Name)));
}
if (!string.IsNullOrEmpty(g.Group))
{
var grp = mdef.GetGroupByName(g.Group);
if (grp == null)
{
issues.Add(new ValidationIssue(mdef, ValidationStatus.Error, ValidationStatusCode.Error_MapDefinition_GroupWithNonExistentGroup, string.Format(Strings.MDF_GroupWithNonExistentGroup, g.Name, g.Group)));
}
}
}
List <IBaseMapLayer> layers = new List <IBaseMapLayer>();
foreach (IBaseMapLayer l in mdef.MapLayer)
{
layers.Add(l);
}
if (mdef.BaseMap != null && mdef.BaseMap.HasGroups())
{
if (mdef.BaseMap.ScaleCount == 0)
{
issues.Add(new ValidationIssue(mdef, ValidationStatus.Error, ValidationStatusCode.Error_MapDefinition_NoFiniteDisplayScales, Strings.MDF_NoFiniteDisplayScalesSpecified));
}
foreach (IBaseMapGroup g in mdef.BaseMap.BaseMapLayerGroups)
{
foreach (IBaseMapLayer l in g.BaseMapLayer)
{
layers.Add(l);
}
}
}
Dictionary <string, IBaseMapLayer> nameCounter = new Dictionary <string, IBaseMapLayer>();
foreach (IBaseMapLayer l in layers)
{
if (nameCounter.ContainsKey(l.Name))
{
issues.Add(new ValidationIssue(mdef, ValidationStatus.Warning, ValidationStatusCode.Error_MapDefinition_DuplicateLayerName, string.Format(Strings.MDF_LayerNameDuplicateWarning, l.Name, l.ResourceId, nameCounter[l.Name].ResourceId)));
}
else
{
nameCounter.Add(l.Name, l);
}
var ml = l as IMapLayer;
if (ml != null && !string.IsNullOrEmpty(ml.Group))
{
var grp = mdef.GetGroupByName(ml.Group);
if (grp == null)
{
issues.Add(new ValidationIssue(mdef, ValidationStatus.Error, ValidationStatusCode.Error_MapDefinition_LayerWithNonExistentGroup, string.Format(Strings.MDF_LayerWithNonExistentGroup, ml.Name, ml.Group)));
}
}
if (l.ShowInLegend && (string.IsNullOrEmpty(l.LegendLabel) || l.LegendLabel.Trim().Length == 0))
{
issues.Add(new ValidationIssue(mdef, ValidationStatus.Information, ValidationStatusCode.Warning_MapDefinition_LayerMissingLegendLabel, string.Format(Strings.MDF_LayerMissingLabelInformation, l.Name)));
}
var mapEnv = ObjectFactory.CreateEnvelope(mdef.Extents.MinX, mdef.Extents.MinY, mdef.Extents.MaxX, mdef.Extents.MaxY);
try
{
ILayerDefinition layer = null;
IResource res = context.GetResource(l.ResourceId);
if (!ResourceValidatorSet.HasValidator(res.ResourceType, res.ResourceVersion))
{
//Need to trap the no registered validator message
issues.AddRange(ResourceValidatorSet.Validate(context, res, true));
continue;
}
layer = (ILayerDefinition)res;
if (recurse)
{
issues.AddRange(ResourceValidatorSet.Validate(context, layer, recurse));
}
IVectorLayerDefinition vl = null;
if (layer.SubLayer.LayerType == LayerType.Vector)
{
vl = (IVectorLayerDefinition)layer.SubLayer;
}
if (vl != null)
{
try
{
IFeatureSource fs = (IFeatureSource)context.GetResource(vl.ResourceId);
if (l.Selectable)
{
//Test selectability requirement
string[] idProps = fs.GetIdentityProperties(this.Connection, vl.FeatureName);
if (idProps == null || idProps.Length == 0)
{
issues.Add(new ValidationIssue(resource, ValidationStatus.Warning, ValidationStatusCode.Warning_MapDefinition_UnselectableLayer, string.Format(Strings.MDF_UnselectableLayer, l.Name, vl.FeatureName, fs.ResourceID)));
}
}
try
{
FdoSpatialContextList scList = context.GetSpatialContexts(fs.ResourceID);
if (scList.SpatialContext == null || scList.SpatialContext.Count == 0)
{
issues.Add(new ValidationIssue(resource, ValidationStatus.Warning, ValidationStatusCode.Warning_MapDefinition_MissingSpatialContext, string.Format(Strings.MDF_MissingSpatialContextWarning, fs.ResourceID)));
}
else
{
if (scList.SpatialContext.Count > 1)
{
issues.Add(new ValidationIssue(resource, ValidationStatus.Information, ValidationStatusCode.Info_MapDefinition_MultipleSpatialContexts, string.Format(Strings.MDF_MultipleSpatialContextsInformation, fs.ResourceID)));
}
bool skipGeomCheck = false;
//TODO: Switch to the correct version (2.1), once released
if (scList.SpatialContext[0].CoordinateSystemWkt != mdef.CoordinateSystem)
{
if (layer.SubLayer.LayerType == LayerType.Raster && this.Connection.SiteVersion <= SiteVersions.GetVersion(OSGeo.MapGuide.MaestroAPI.KnownSiteVersions.MapGuideOS2_0_2))
{
issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_MapDefinition_RasterReprojection, string.Format(Strings.MDF_RasterReprojectionError, fs.ResourceID)));
}
else
{
issues.Add(new ValidationIssue(resource, ValidationStatus.Warning, ValidationStatusCode.Warning_MapDefinition_LayerReprojection, string.Format(Strings.MDF_DataReprojectionWarning, fs.ResourceID)));
}
skipGeomCheck = true;
}
if (vl.Geometry != null && !skipGeomCheck)
{
var env = this.Connection.FeatureService.GetSpatialExtent(fs.ResourceID, vl.FeatureName, vl.Geometry);
if (!env.Intersects(mapEnv))
{
issues.Add(new ValidationIssue(resource, ValidationStatus.Warning, ValidationStatusCode.Warning_MapDefinition_DataOutsideMapBounds, string.Format(Strings.MDF_DataOutsideMapWarning, fs.ResourceID)));
}
}
}
}
catch (Exception ex)
{
var nex = ex as NullExtentException;
if (nex != null)
{
issues.Add(new ValidationIssue(resource, ValidationStatus.Warning, ValidationStatusCode.Warning_MapDefinition_FeatureSourceWithNullExtent, string.Format(Strings.MDF_LayerWithNullExtent, fs.ResourceID)));
}
else
{
string msg = NestedExceptionMessageProcessor.GetFullMessage(ex);
issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_MapDefinition_ResourceRead, string.Format(Strings.MDF_ResourceReadError, fs.ResourceID, msg)));
}
}
}
catch (Exception ex)
{
string msg = NestedExceptionMessageProcessor.GetFullMessage(ex);
issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_MapDefinition_FeatureSourceRead, string.Format(Strings.MDF_FeatureSourceReadError, l.ResourceId, msg)));
}
}
}
catch (Exception ex)
{
string msg = NestedExceptionMessageProcessor.GetFullMessage(ex);
issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_MapDefinition_LayerRead, string.Format(Strings.MDF_LayerReadError, l.ResourceId, msg)));
}
}
context.MarkValidated(resource.ResourceID);
return(issues.ToArray());
}
