/// <summary> /// Perform base validation logic /// </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); } var ldef = resource as ILayerDefinition; var vldef = ldef.SubLayer as IVectorLayerDefinition; var gldef = ldef.SubLayer as IRasterLayerDefinition; var dldef = ldef.SubLayer as IDrawingLayerDefinition; List <ValidationIssue> issues = new List <ValidationIssue>(); if (ldef.SubLayer == null) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_LayerNull, Strings.LDF_LayerNullError)); } ClassDefinition cls = null; if (vldef != null || gldef != null) { //Load referenced feature source IFeatureSource fs = null; try { fs = (IFeatureSource)context.GetResource(ldef.SubLayer.ResourceId); } catch (Exception) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_FeatureSourceLoadError, string.Format(Strings.LDF_FeatureSourceLoadError))); } if (fs != null) { //Verify specified feature class and geometry check out try { string qualClassName = vldef == null ? gldef.FeatureName : vldef.FeatureName; string geometry = vldef == null ? gldef.Geometry : vldef.Geometry; bool foundSchema = false; bool foundGeometry = false; cls = this.Connection.FeatureService.GetClassDefinition(fs.ResourceID, qualClassName); if (cls != null) { foundSchema = true; foreach (PropertyDefinition col in cls.Properties) { if (col.Name == geometry) { foundGeometry = true; break; } } if (vldef != null && vldef.PropertyMapping != null) { foreach (INameStringPair s in vldef.PropertyMapping) { bool found = false; foreach (PropertyDefinition col in cls.Properties) { if (col.Name == s.Name) { found = true; break; } } if (!found) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_InvalidPropertyMapping, string.Format(Strings.LDF_InvalidPropertyMapping, s.Name, qualClassName))); } } } } if (!foundSchema) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_ClassNotFound, string.Format(Strings.LDF_SchemaMissingError, qualClassName, fs.ResourceID))); } else if (!foundGeometry) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_GeometryNotFound, string.Format(Strings.LDF_GeometryMissingError, geometry, qualClassName, fs.ResourceID))); } } catch (Exception ex) { issues.Add(new ValidationIssue(fs, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_Generic, string.Format(Strings.LDF_SchemaAndColumnReadFailedError, ex.ToString()))); } if (recurse) { issues.AddRange(ResourceValidatorSet.Validate(context, fs, recurse)); } } } if (vldef != null) { if (string.IsNullOrEmpty(vldef.FeatureName)) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_MissingFeatureName, Strings.LDF_MissingFeatureSourceError)); } if (string.IsNullOrEmpty(vldef.Geometry)) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_MissingGeometry, Strings.LDF_MissingGeometryError)); } if (vldef.VectorScaleRange == null || !vldef.HasVectorScaleRanges()) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_MissingScaleRanges, Strings.LDF_MissingScaleRangesError)); } else { //Test for overlapping scale ranges List <KeyValuePair <double, double> > ranges = new List <KeyValuePair <double, double> >(); foreach (IVectorScaleRange vsr in vldef.VectorScaleRange) { IVectorScaleRange2 vsr2 = vsr as IVectorScaleRange2; if (vsr2 != null) { var area = vsr2.AreaStyle; var line = vsr2.LineStyle; var point = vsr2.PointStyle; if (vsr2.CompositeStyleCount > 0 && (area != null || line != null || point != null)) { issues.Add(new ValidationIssue(resource, ValidationStatus.Warning, ValidationStatusCode.Warning_LayerDefinition_CompositeStyleDefinedAlongsideBasicStyle, string.Format( Strings.LDF_CompositeStyleDefinedAlongsideBasicStyle, vsr2.MinScale.HasValue ? vsr2.MinScale.Value : 0, vsr2.MaxScale.HasValue ? vsr2.MaxScale.Value.ToString() : Strings.Infinity))); } if (vsr2.CompositeStyleCount > 0) { foreach (var cs in vsr2.CompositeStyle) { foreach (var cr in cs.CompositeRule) { if (cr.CompositeSymbolization != null) { foreach (var si in cr.CompositeSymbolization.SymbolInstance) { //verify that symbol references point to valid symbol definitions if (si.Reference.Type == SymbolInstanceType.Reference) { var symRef = (ISymbolInstanceReferenceLibrary)si.Reference; if (!context.ResourceExists(symRef.ResourceId)) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_SymbolDefintionReferenceNotFound, string.Format( Strings.LDF_SymbolDefintionReferenceNotFound, symRef.ResourceId))); } if (cls != null) { //warn if the symbol definition has usage contexts that are irrelevant against the layer's feature source var prop = cls.FindProperty(vldef.Geometry) as GeometricPropertyDefinition; if (prop != null) { var gtypes = new List <FeatureGeometricType>(prop.GetIndividualGeometricTypes()); var sym = context.GetResource(symRef.ResourceId) as ISimpleSymbolDefinition; if (sym != null) { if (sym.LineUsage != null && !gtypes.Contains(FeatureGeometricType.Curve)) { issues.Add(new ValidationIssue(resource, ValidationStatus.Information, ValidationStatusCode.Info_LayerDefinition_IrrelevantUsageContext, string.Format( Strings.LDF_IrrelevantUsageContext, symRef.ResourceId, FeatureGeometricType.Curve.ToString()))); } if (sym.AreaUsage != null && !gtypes.Contains(FeatureGeometricType.Surface)) { issues.Add(new ValidationIssue(resource, ValidationStatus.Information, ValidationStatusCode.Info_LayerDefinition_IrrelevantUsageContext, string.Format( Strings.LDF_IrrelevantUsageContext, symRef.ResourceId, FeatureGeometricType.Surface.ToString()))); } if (sym.PointUsage != null && !gtypes.Contains(FeatureGeometricType.Point)) { issues.Add(new ValidationIssue(resource, ValidationStatus.Information, ValidationStatusCode.Info_LayerDefinition_IrrelevantUsageContext, string.Format( Strings.LDF_IrrelevantUsageContext, symRef.ResourceId, FeatureGeometricType.Point.ToString()))); } } } } } //verify that the overrides specified are for symbol parameters that actually exist if (si.ParameterOverrides.Count > 0) { if (si.Reference.Type == SymbolInstanceType.Reference) { var symRef = (ISymbolInstanceReferenceLibrary)si.Reference; var sym = (ISymbolDefinitionBase)context.GetResource(symRef.ResourceId); var paramList = new Dictionary <string, IParameter>(); foreach (var p in sym.GetParameters()) { paramList[p.Identifier] = p; } foreach (var ov in si.ParameterOverrides.Override) { if (!paramList.ContainsKey(ov.ParameterIdentifier)) { issues.Add(new ValidationIssue(resource, ValidationStatus.Warning, ValidationStatusCode.Warning_LayerDefinition_SymbolParameterOverrideToNonExistentParameter, string.Format( Strings.LDF_SymbolParameterOverrideToNonExistentParameter, symRef.ResourceId, ov.ParameterIdentifier))); } } } } } } } } } } ranges.Add(new KeyValuePair <double, double>( vsr.MaxScale.HasValue ? vsr.MaxScale.Value : double.PositiveInfinity, vsr.MinScale.HasValue ? vsr.MinScale.Value : double.NegativeInfinity)); } double min = double.PositiveInfinity; double max = double.NegativeInfinity; foreach (KeyValuePair <double, double> sr in ranges) { min = Math.Min(min, sr.Value); max = Math.Max(max, sr.Key); if (sr.Key < sr.Value) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_MinMaxScaleSwapped, string.Format(Strings.LDF_MinAndMaxScaleSwappedError, sr.Value, sr.Key))); } } ranges.Sort(CompareScales); //TODO: Detect gaps in scale ranges for (int i = 0; i < ranges.Count; i++) { for (int j = i + 1; j < ranges.Count; j++) { if (ranges[i].Key > ranges[j].Value || ranges[i].Value > ranges[j].Value) { issues.Add(new ValidationIssue(resource, ValidationStatus.Information, ValidationStatusCode.Info_LayerDefinition_ScaleRangeOverlap, string.Format(Strings.LDF_ScaleRangesOverlapInformation, ranges[i].Value, ranges[i].Key, ranges[j].Value, ranges[j].Key))); } } } } } else if (gldef != null) { if (string.IsNullOrEmpty(gldef.FeatureName)) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_MissingFeatureName, Strings.LDF_MissingFeatureSourceError)); } if (string.IsNullOrEmpty(gldef.Geometry)) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_MissingGeometry, Strings.LDF_MissingGeometryError)); } if (gldef.GridScaleRange == null || gldef.GridScaleRangeCount == 0) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_NoGridScaleRanges, Strings.LDF_MissingScaleRangesError)); } else if (gldef.GridScaleRangeCount != 1) { issues.Add(new ValidationIssue(resource, ValidationStatus.Warning, ValidationStatusCode.Warning_LayerDefinition_MultipleGridScaleRanges, Strings.LDF_MultipleScaleRangesWarning)); } } else if (dldef != null) { IDrawingSource dws = null; try { dws = (IDrawingSource)context.GetResource(dldef.ResourceId); } catch (Exception) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_DrawingSourceError, Strings.LDF_DrawingSourceError)); } if (dws != null) { if (Array.IndexOf(this.Connection.Capabilities.SupportedServices, (int)ServiceType.Drawing) >= 0) { var dwSvc = (IDrawingService)this.Connection.GetService((int)ServiceType.Drawing); //Check if specified section exists var shtList = dwSvc.EnumerateDrawingSections(dws.ResourceID); DrawingSectionListSection sheet = null; foreach (var sht in shtList.Section) { if (sht.Name.Equals(dldef.Sheet)) { sheet = sht; break; } } if (sheet == null) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_DrawingSourceSheetNotFound, string.Format(Strings.LDF_SheetNotFound, dldef.Sheet))); } else { //null or empty filter means all layers, in that case do nothing if (!string.IsNullOrEmpty(dldef.LayerFilter)) { //Check if specified layers all exist in specified section var specifiedLayers = dldef.LayerFilter.Split(','); //NOXLATE var dwLayers = new Dictionary <string, string>(); var shtLayers = dwSvc.EnumerateDrawingLayers(dws.ResourceID, sheet.Name); foreach (var sl in shtLayers) { dwLayers.Add(sl, sl); } foreach (var sl in specifiedLayers) { if (!dwLayers.ContainsKey(sl.Trim())) { issues.Add(new ValidationIssue(resource, ValidationStatus.Error, ValidationStatusCode.Error_LayerDefinition_DrawingSourceSheetLayerNotFound, string.Format(Strings.LDF_SheetLayerNotFound, sl.Trim(), sheet.Name))); } } } } } if (recurse) { issues.AddRange(ResourceValidatorSet.Validate(context, dws, recurse)); } } } else { issues.Add(new ValidationIssue(resource, ValidationStatus.Warning, ValidationStatusCode.Warning_LayerDefinition_UnsupportedLayerType, Strings.LDF_UnsupportedLayerTypeWarning)); } context.MarkValidated(resource.ResourceID); return(issues.ToArray()); }
/// <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()); }
/// <summary> /// Performs base validation logic /// </summary> /// <param name="context"></param> /// <param name="resource"></param> /// <param name="recurse"></param> /// <returns></returns> protected static ValidationIssue[] ValidateBase(ResourceValidationContext context, IResource resource, bool recurse) { Check.ArgumentNotNull(context, nameof(context)); if (context.IsAlreadyValidated(resource.ResourceID)) { return(null); } if (resource.ResourceType != ResourceTypes.WebLayout.ToString()) { return(null); } List <ValidationIssue> issues = new List <ValidationIssue>(); IWebLayout layout = resource as IWebLayout; if (layout.Map == null || layout.Map.ResourceId == null) { issues.Add(new ValidationIssue(layout, ValidationStatus.Error, ValidationStatusCode.Error_WebLayout_MissingMap, string.Format(Strings.WL_MissingMapError))); } else { //Check for duplicate command names var cmdSet = layout.CommandSet; Dictionary <string, ICommand> cmds = new Dictionary <string, ICommand>(); foreach (ICommand cmd in cmdSet.Commands) { if (cmds.ContainsKey(cmd.Name)) { issues.Add(new ValidationIssue(layout, ValidationStatus.Error, ValidationStatusCode.Error_WebLayout_DuplicateCommandName, string.Format(Strings.WL_DuplicateCommandName, cmd.Name))); } else { cmds[cmd.Name] = cmd; } } //Check for duplicate property references in search commands foreach (ISearchCommand search in cmdSet.Commands.OfType <ISearchCommand>()) { Dictionary <string, string> resColProps = new Dictionary <string, string>(); foreach (IResultColumn resCol in search.ResultColumns.Column) { if (resColProps.ContainsKey(resCol.Property)) { issues.Add(new ValidationIssue(layout, ValidationStatus.Error, ValidationStatusCode.Error_WebLayout_DuplicateSearchCommandResultColumn, string.Format(Strings.WL_DuplicateSearchResultColumn, search.Name, resCol.Property))); } else { resColProps.Add(resCol.Property, resCol.Property); } } } //Check for command references to non-existent commands foreach (IUIItem item in layout.ContextMenu.Items) { if (item.Function == UIItemFunctionType.Command) { ICommandItem cmdRef = (ICommandItem)item; if (!cmds.ContainsKey(cmdRef.Command)) { issues.Add(new ValidationIssue(layout, ValidationStatus.Error, ValidationStatusCode.Error_WebLayout_NonExistentContextMenuCommandReference, string.Format(Strings.WL_NonExistentMenuCommandReference, cmdRef.Command))); } } } foreach (IUIItem item in layout.TaskPane.TaskBar.Items) { if (item.Function == UIItemFunctionType.Command) { ICommandItem cmdRef = (ICommandItem)item; if (!cmds.ContainsKey(cmdRef.Command)) { issues.Add(new ValidationIssue(layout, ValidationStatus.Error, ValidationStatusCode.Error_WebLayout_NonExistentTaskPaneCommandReference, string.Format(Strings.WL_NonExistentTaskPaneCommandReference, cmdRef.Command))); } } } foreach (IUIItem item in layout.ToolBar.Items) { if (item.Function == UIItemFunctionType.Command) { ICommandItem cmdRef = (ICommandItem)item; if (!cmds.ContainsKey(cmdRef.Command)) { issues.Add(new ValidationIssue(layout, ValidationStatus.Error, ValidationStatusCode.Error_WebLayout_NonExistentToolbarCommandReference, string.Format(Strings.WL_NonExistentToolbarCommandReference, cmdRef.Command))); } } } try { IMapDefinition mdef = (IMapDefinition)context.GetResource(layout.Map.ResourceId); if (layout.Map.InitialView != null) { var mapEnv = ObjectFactory.CreateEnvelope(mdef.Extents.MinX, mdef.Extents.MinY, mdef.Extents.MaxX, mdef.Extents.MaxY); if (!mapEnv.Contains(layout.Map.InitialView.CenterX, layout.Map.InitialView.CenterY)) { issues.Add(new ValidationIssue(mdef, ValidationStatus.Warning, ValidationStatusCode.Warning_WebLayout_InitialViewOutsideMapExtents, string.Format(Strings.WL_StartViewOutsideExtentsWarning))); } } if (recurse) { issues.AddRange(ResourceValidatorSet.Validate(context, mdef, true)); } } catch (Exception ex) { string msg = NestedExceptionMessageProcessor.GetFullMessage(ex); issues.Add(new ValidationIssue(layout, ValidationStatus.Error, ValidationStatusCode.Error_WebLayout_Generic, string.Format(Strings.WL_MapValidationError, layout.Map.ResourceId, msg))); } } context.MarkValidated(resource.ResourceID); return(issues.ToArray()); }
/// <summary> /// Validats the specified resources for common issues associated with this /// resource type /// </summary> /// <param name="context"></param> /// <param name="resource"></param> /// <param name="recurse"></param> /// <returns></returns> public ValidationIssue[] Validate(ResourceValidationContext context, IResource resource, bool recurse) { if (resource.ResourceType != ResourceTypes.ApplicationDefinition.ToString()) { return(null); } //TODO: Other items to check for // // - References to non-existent widgets // - MapWidget checks // - Ensure map id checks out // - Ensure context menu id checks out // - Verify containers of template are all referenced within this flexible layout // - Check required parameters of widgets are satisfied List <ValidationIssue> issues = new List <ValidationIssue>(); IApplicationDefinition fusionApp = resource as IApplicationDefinition; if (fusionApp.MapSet == null || fusionApp.MapSet.MapGroupCount == 0) { issues.Add(new ValidationIssue(fusionApp, ValidationStatus.Error, ValidationStatusCode.Error_Fusion_MissingMap, string.Format(Strings.ADF_MapMissingError))); } else { foreach (IMapGroup mapGroup in fusionApp.MapSet.MapGroups) { bool checkCmsProjection = false; List <IMapDefinition> mapDefsInGroup = new List <IMapDefinition>(); foreach (IMap map in mapGroup.Map) { if (IsCommercialOverlay(map)) { checkCmsProjection = true; } if (map.Type.ToLower() == "virtualearth") { //As of July 1, 2017 we need an API key on Bing Maps var bingMapsKey = fusionApp.GetValue("BingMapKey"); if (string.IsNullOrEmpty(bingMapsKey)) { issues.Add(new ValidationIssue(fusionApp, ValidationStatus.Error, ValidationStatusCode.Error_Fusion_BingMapsMissingApiKey, Strings.ADF_BingMapsMissingApiKey)); } //If this is still referencing the "Hybrid" base layer type, that no longer exists in the v8 API if (map.CmsMapOptions.Type == "Hybrid") { issues.Add(new ValidationIssue(fusionApp, ValidationStatus.Error, ValidationStatusCode.Error_Fusion_BingMapsHybridBaseLayerNoLongerAvailable, Strings.ADF_BingMapsHybridLayerNoLongerAvailable)); } } try { if (map.Type.ToLower() == "mapguide") //NOXLATE { var mdfId = map.GetMapDefinition(); if (string.IsNullOrEmpty(mdfId) || !this.Connection.ResourceService.ResourceExists(mdfId)) { issues.Add(new ValidationIssue(fusionApp, ValidationStatus.Error, ValidationStatusCode.Error_Fusion_InvalidMap, string.Format(Strings.ADF_MapInvalidError, mapGroup.id))); } else { IMapDefinition mdef = (IMapDefinition)context.GetResource(mdfId); mapDefsInGroup.Add(mdef); IEnvelope mapEnv = ObjectFactory.CreateEnvelope(mdef.Extents.MinX, mdef.Extents.MinY, mdef.Extents.MaxX, mdef.Extents.MaxY); if (mapGroup.InitialView != null) { if (!mapEnv.Contains(mapGroup.InitialView.CenterX, mapGroup.InitialView.CenterY)) { issues.Add(new ValidationIssue(mdef, ValidationStatus.Warning, ValidationStatusCode.Warning_Fusion_InitialViewOutsideMapExtents, string.Format(Strings.ADF_ViewOutsideMapExtents))); } } if (recurse) { issues.AddRange(ResourceValidatorSet.Validate(context, mdef, recurse)); } } } } catch (Exception ex) { string msg = NestedExceptionMessageProcessor.GetFullMessage(ex); issues.Add(new ValidationIssue(fusionApp, ValidationStatus.Error, ValidationStatusCode.Error_Fusion_MapValidationError, string.Format(Strings.ADF_MapValidationError, mapGroup.id, msg))); } } if (checkCmsProjection) { foreach (var mdf in mapDefsInGroup) { var wkt = mdf.CoordinateSystem; var csCode = this.Connection.CoordinateSystemCatalog.ConvertWktToCoordinateSystemCode(wkt); if (csCode.ToUpper() != "WGS84.PSEUDOMERCATOR") //NOXLATE { issues.Add(new ValidationIssue(resource, ValidationStatus.Warning, ValidationStatusCode.Warning_Fusion_MapCoordSysIncompatibleWithCommericalLayers, string.Format(Strings.ADF_MapWithIncompatibleCommericalCs, mdf.ResourceID))); } } } } } //Check labels of referenced widgets foreach (var wset in fusionApp.WidgetSets) { foreach (var cnt in wset.Containers) { var menu = cnt as IMenu; if (menu != null) { ValidateWidgetReferencesForMenu(fusionApp, menu, issues, context, resource); } } } context.MarkValidated(resource.ResourceID); return(issues.ToArray()); }