private void _InitServers() { if (_userServicesInfo.ServersInfo == null) { _userServicesInfo.ServersInfo = new UserServersInfo(); } ServersInfoWrap wrap = new ServersInfoWrap( _servicesInfo.ServersInfo, _userServicesInfo.ServersInfo); var servers = wrap.Servers.ToArray(); _servers = servers.Select(_ => default(AgsServer)).ToList(); _taskRunner.For(0, servers.Length, index => { var serverInfo = servers[index]; var server = new AgsServer( serverInfo, Licenser.LicenseAccount); _servers[index] = server; }); }
/////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// public AgsCachedLayer(AgsServer server, MapLayer layer) : base(layer) { Debug.Assert(layer.MapServiceInfo != null); LayerType = AgsLayerType.Cached; Server = server; if (String.IsNullOrEmpty(layer.MapServiceInfo.Url)) throw new SettingsException((string)App.Current.FindResource("InvalidMapLayerURL")); // format REST URL string restUrl = FormatRestUrl(layer.MapServiceInfo.Url); if (restUrl == null) throw new SettingsException((string)App.Current.FindResource("FailedFormatRESTURL")); // create ArcGIS layer ArcGISTiledMapServiceLayer arcGISTiledMapServiceLayer = new ArcGISTiledMapServiceLayer(); arcGISTiledMapServiceLayer.ID = "map"; arcGISTiledMapServiceLayer.Url = restUrl; arcGISTiledMapServiceLayer.Visible = layer.MapServiceInfo.IsVisible; arcGISTiledMapServiceLayer.Opacity = layer.MapServiceInfo.Opacity; ArcGISLayer = arcGISTiledMapServiceLayer; UpdateTokenIfNeeded(); }
/// <summary> /// Creates AuthenticationException object. /// </summary> /// <param name="server">The server authentication failed to.</param> /// <param name="inner">Exception instance which caused this one /// to be thrown.</param> /// <returns>AuthenticationException object containing the specified /// server name and inner exception.</returns> public static AuthenticationException CreateAuthException( AgsServer server, Exception inner) { Debug.Assert(server != null); return(CreateAuthException(server.Title, inner)); }
/// <summary> /// Creates CommunicationException object. /// </summary> public static CommunicationException CreateCommException( AgsServer server, Exception ex) { Debug.Assert(server != null); return(CreateCommException(server.Title, ex)); }
/////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// internal MapLayer(MapServiceInfoWrap serviceInfo, AgsServer server, Map map) { Debug.Assert(serviceInfo != null); _id = Guid.NewGuid(); _serviceInfo = serviceInfo; _map = map; }
/// <summary> /// Initializes a new instance of the RestRouteService class with /// the specified Routing service url, Routing layer name and ArcGIS /// server hosting routing service. /// </summary> /// <param name="serviceUrl">The Routing service url.</param> /// <param name="layerName">The name of the Routing layer.</param> /// <param name="server">ArcGIS server instance hosting routing service.</param> public RestRouteService( string serviceUrl, string layerName, AgsServer server) { Debug.Assert(server != null); _server = server; _baseUrl = UriHelper.Concat(serviceUrl, layerName); _baseUrl = UriHelper.Concat(_baseUrl, QUERY_OBJ_SOLVE); _restService = new RestService(); }
/// <summary> /// Initializes a new instance of the RestServiceContextProvider class /// with the specified REST service url, VRP tool name and ArcGIS server /// instance. /// </summary> /// <param name="serviceUrl">Url of the VRP REST service.</param> /// <param name="toolName">VRP service tool name.</param> /// <param name="server">ArcGIS server instance the VRP service is located /// at.</param> public RestServiceContextProvider( string serviceUrl, string toolName, AgsServer server) { Debug.Assert(!string.IsNullOrEmpty(serviceUrl)); Debug.Assert(!string.IsNullOrEmpty(toolName)); Debug.Assert(server != null); _baseUrl = UriHelper.Concat(serviceUrl, toolName); _server = server; }
/// <summary> /// Validates server state. /// </summary> /// <exception cref="ESRI.ArcLogistics.AuthenticationException"> /// Is thrown if server state is unauthorized.</exception> public static void ValidateServerState(AgsServer server) { Debug.Assert(server != null); if (server.State == AgsServerState.Unauthorized) { // server is not authorized throw CreateAuthException(server); } else if (server.State == AgsServerState.Unavailable) { // try to reconnect server server.Reconnect(); } }
/// <summary> /// Initializes a new instance of the AgsServerConnection class /// with the specified authenticator instance, connection parameters /// and ArcGIS server to connect to. /// </summary> /// <param name="authenticator">Authenticator instance to be used /// for accessing ArcGIS server.</param> /// <param name="parameters">Connection parameters instance.</param> /// <param name="server">ArcGIS server instance to connect to.</param> public AgsServerConnection( IAgsServerAuthenticator authenticator, AgsServerConnectionParameters parameters, AgsServer server) { Debug.Assert(authenticator != null); Debug.Assert(parameters != null); Debug.Assert(server != null); _authenticator = authenticator; _parameters = parameters; _server = server; this.RequiresHttpAuthentication = _server.RequiresHttpAuthentication; }
/////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// public static AgsLayer CreateLayer(AgsServer server, MapLayer layer) { if (layer.MapServiceInfo.Type == null) throw new SettingsException((string)App.Current.FindResource("InvalidMapLayerType")); AgsLayer agsLayer = null; if (layer.MapServiceInfo.Type.Equals(DYNAMIC_SERVICE, StringComparison.OrdinalIgnoreCase)) { agsLayer = new AgsDynamicLayer(server, layer); } else if (layer.MapServiceInfo.Type.Equals(CACHED_SERVICE, StringComparison.OrdinalIgnoreCase)) { agsLayer = new AgsCachedLayer(server, layer); } else throw new SettingsException((string)App.Current.FindResource("UnknownMapLayerType")); return agsLayer; }
/////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Finds server by name. /// </summary> public static AgsServer FindServerByName(string name, ICollection <AgsServer> servers) { Debug.Assert(name != null); Debug.Assert(servers != null); AgsServer res = null; foreach (AgsServer server in servers) { if (server.Name != null && server.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)) { res = server; break; } } return(res); }
private AgsServer _GetCurrentGcServer(GeocodingServiceInfo geocodingServiceInfo) { AgsServer currentServer = null; foreach (AgsServer server in _servers) { if (server.Name.Equals(geocodingServiceInfo.serverName, StringComparison.OrdinalIgnoreCase)) { Debug.Assert(currentServer == null); currentServer = server; } } if (currentServer == null) { string message = Properties.Resources.ServerNameNotFound; throw new SettingsException(message); } return(currentServer); }
/// <summary> /// Constructor. /// </summary> /// <param name="Server">AgsServer.</param> /// <param name="ArcGISLayer">Layer, which token must be updated.</param> /// <param name="LayerType">Type of the layer.</param> public TokenUpdater(AgsServer Server, Layer ArcGISLayer, AgsLayerType LayerType) { Debug.Assert(Server != null); Debug.Assert(ArcGISLayer != null); Debug.Assert(LayerType != null); _server = Server; _arcGISLayer = ArcGISLayer; _layerType = LayerType; // Set layer token. _SetNewToken(Server.LastToken); _InitTimer(); // If server is in authorized state - start timer. if (_server.State == AgsServerState.Authorized) _RestartTimer(); // Subscribe to server state changed event. _server.StateChanged += new EventHandler(_ServerStateChanged); }
/// <summary> /// Constructor. /// </summary> /// <param name="geocodingServiceInfo">Geocoding service info.</param> /// <param name="geocodeServer">Geocode server.</param> /// <param name="exceptionHandler">Exception handler.</param> internal Geocoder(GeocodingServiceInfo geocodingServiceInfo, AgsServer geocodeServer, IServiceExceptionHandler exceptionHandler) { Debug.Assert(exceptionHandler != null); _exceptionHandler = exceptionHandler; // Init geocoding properties. _propMods = new PropertySet(); _propMods.PropertyArray = new PropertySetProperty[2]; _propMods.PropertyArray[0] = _CreateProp("WritePercentAlongField", "TRUE"); _propMods.PropertyArray[1] = _CreateProp("MatchIfScoresTie", "TRUE"); _geocodingServiceInfo = geocodingServiceInfo; if (_geocodingServiceInfo == null) { throw new SettingsException(Properties.Resources.DefaultGeocodingInfoIsNotSet); } _geocodingServer = geocodeServer; // Create address fields. _CreateAddressFields(); _actualGeocodingInfo = new GeocodingInfo(geocodingServiceInfo); _locatorsInfos = new ReadOnlyCollection<LocatorInfo>( _actualGeocodingInfo.Locators ?? new LocatorInfo[] { }); foreach (var locator in _locatorsInfos) { if (!_locators.ContainsKey(locator.Name)) { _locators.Add(locator.Name, locator); } } var fields = _geocodingServiceInfo.FieldMappings.FieldMapping.Select(mapping => (AddressPart)Enum.Parse( typeof(AddressPart), mapping.AddressField, true)); _defaultLocator = new LocatorInfo( string.Empty, string.Empty, true, true, SublocatorType.Streets, fields); // Geocoder should be initialized later. _inited = false; }
/// <summary> /// Converts given exception to CommunicationException if it's related /// to communication problems. /// </summary> public static Exception ConvertCommException(AgsServer server, Exception ex) { return(IsCommunicationError(ex) ? CreateCommException(server, ex) : ex); }
/// <summary> /// Initializes a new instance of the ArcGisServerLoginViewModel class. /// </summary> /// <param name="server">The server to provide authentication for.</param> /// <param name="messenger">The messenger object to be used for /// notifications.</param> /// <param name="workingStatusController">The object to be used for /// managing application working status.</param> public ArcGisServerLoginViewModel( AgsServer server, IMessenger messenger, IWorkingStatusController workingStatusController) { Debug.Assert(server != null); Debug.Assert(messenger != null); Debug.Assert(workingStatusController != null); _server = server; _server.StateChanged += _ServerStateChanged; this.LicenseState = server.State; this.RegisterHeader( AgsServerState.Unauthorized, App.Current.GetString("LoginToServerString", _server.Title)); _messenger = messenger; _workingStatusController = workingStatusController; var licensePageCommands = new LicensePageCommands() { CreateAccount = null, RecoverCredentials = null, UpgradeLicense = null, }; this.LoginState = new LoginStateViewModel( licensePageCommands, _ExecuteLogin); var licenseInfoText = EnumerableEx.Return(ApplyStyle(new FlowDocument( new Paragraph() { Inlines = { new Run(App.Current.GetString("LoggedToServerString", _server.Title)), new Run(NEW_LINE), new Run(_server.Description) }, } ))); this.ConnectedState = new ConnectedStateViewModel( licensePageCommands, licenseInfoText) { SwitchUserCommand = new DelegateCommand( _ => this.LicenseState = AgsServerState.Unauthorized), }; var connectionFailureInfo = ApplyStyle(new FlowDocument( new Paragraph( new Run(App.Current.GetString( "ServerIsUnavailableString", _server.Title) ) ) )); this.NotConnectedState = new NotConnectedStateViewModel() { ConnectionFailureInfo = connectionFailureInfo, }; }
/////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Constructor. /// </summary> /// <param name="serviceUrl">Service url.</param> /// <param name="layerName">Layer name.</param> /// <param name="server">Server.</param> internal NetworkDescription(string serviceUrl, string layerName, AgsServer server) { Debug.Assert(serviceUrl != null); // Create connection. var connection = server.OpenConnection(); NAServiceClient client = new NAServiceClient(serviceUrl, connection); try { NAServerNetworkDescription desc = client.GetNetworkDescription(layerName); NAServerSolverParams solverParams = client.GetSolverParameters(layerName); var parameterValues = solverParams.AttributeParameterValues.ToLookup( value => value.AttributeName, StringComparer.OrdinalIgnoreCase); // Create attributes. foreach (NAServerNetworkAttribute attr in desc.NetworkAttributes) { var routingAttributeName = attr.Name; var attributeParameter = parameterValues[attr.Name].FirstOrDefault(); if (attributeParameter != null) { routingAttributeName = attributeParameter.AttributeName; } var usageType = _ConvertUsageType(attr.UsageType); var usageParameter = _GetRestrictionUsageParameter(attr.RestrictionUsageParameterName, parameterValues[attr.Name], usageType); var attribute = new NetworkAttribute(attr.Name, routingAttributeName, _ConvertUnits(attr.Units), usageType, _GetAttrParams(attr, parameterValues[attr.Name]), usageParameter); _attributes.Add(attribute); } // Enabled restriction names. _enabledRestrictionNames = solverParams.RestrictionAttributeNames; if (_enabledRestrictionNames == null) _enabledRestrictionNames = new string[0]; // Get impedance attribute name. _impedanceAttrName = solverParams.ImpedanceAttributeName; } finally { client.Close(); } }
/// <summary> /// Initialize map spatial reference and map scalebar units from server /// </summary> /// <param name="isInitializationInProgress">True if initialization is in progress, /// otherwise false..</param> private void _GetMapLayerProperties(bool isInitializationInProgress) { if (_layers.Count > 0) { // TODO: check spatial references from other layers and remove hardcode // Create client MapLayer mapLayer = _layers[0]; _mapServer = ((AgsMapLayer)mapLayer).Server; if (_mapServer.State == AgsServerState.Authorized) { MapServiceClient mapservice = new MapServiceClient( mapLayer.Url, _mapServer.OpenConnection()); // Get map service info ESRI.ArcLogistics.MapService.MapServerInfo serverInfo = mapservice.GetServerInfo(mapservice.GetDefaultMapName()); // Get spatial reference ID _spatialReferenceId = serverInfo.SpatialReference.WKID; _scaleBarUnits = _ConvertScalebarUnits(serverInfo.Units); // Now map is initialized. _inited = true; } else { // Subscribe on server state changed in case of Map is not inited if (isInitializationInProgress) { _mapServer.StateChanged += new EventHandler(_Server_StateChanged); } } } }
/////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Constructor. /// </summary> /// <param name="mapInfo">Map information.</param> /// <param name="servers">Servers collection.</param> /// <param name="exceptionHandler">Exceptions handler.</param> internal Map(MapInfoWrap mapInfo, ICollection<AgsServer> servers, IServiceExceptionHandler exceptionHandler) { Debug.Assert(mapInfo != null); Debug.Assert(exceptionHandler != null); _exceptionHandler = exceptionHandler; // create layers _CreateLayers(mapInfo.Services, servers); // set selected basemap layer _SetSelectedBaseMap(); _mapInfo = mapInfo; // Set current map server. _mapServer = _GetMapServer(_layers); // Map should be initialized later. _inited = false; }
internal AgsMapLayer(MapServiceInfoWrap serviceInfo, AgsServer server, Map map) : base(serviceInfo, server, map) { Server = server; }
private void _CreateGeocoder() { GeocodingServiceInfo currentGeocodingServiceInfo = null; for (int index = 0; index < _servicesInfo.GeocodingInfo.GeocodingServiceInfo.Length; index++) { GeocodingServiceInfo geocodingServiceInfo = _servicesInfo.GeocodingInfo.GeocodingServiceInfo[index]; if (geocodingServiceInfo.current) { if (currentGeocodingServiceInfo != null) { throw new ApplicationException(Properties.Resources.DefaultGeocodingInfoIsNotUnique); } currentGeocodingServiceInfo = geocodingServiceInfo; } var isStreetsGeocoder = string.Equals( geocodingServiceInfo.type, STREETS_GEOCODER_TYPE, StringComparison.OrdinalIgnoreCase); if (isStreetsGeocoder && this.StreetsGeocoder == null) { var streetsGeocoderServer = _GetCurrentGcServer(geocodingServiceInfo); var streetsGeocoder = new Geocoder(geocodingServiceInfo, streetsGeocoderServer, _exceptionHandler); this.StreetsGeocoder = streetsGeocoder; } } // Detect that geocoder type is ArcGisGeocoder. var isArcGisGeocoder = string.Equals( currentGeocodingServiceInfo.type, ARCGIS_GEOCODER_TYPE, StringComparison.OrdinalIgnoreCase); var isWorldGeocoder = string.Equals( currentGeocodingServiceInfo.type, "WorldGeocoder", StringComparison.OrdinalIgnoreCase); // If it is arcgis geocoder - create it and use as default. if (isArcGisGeocoder) { AgsServer geocodeServer = _GetCurrentGcServer(currentGeocodingServiceInfo); _geocoder = new ArcGiscomGeocoder(currentGeocodingServiceInfo, geocodeServer, _exceptionHandler); this.StreetsGeocoder = _geocoder; } else if (isWorldGeocoder) { var worldGeocoder = WorldGeocoder.CreateWorldGeocoder( currentGeocodingServiceInfo, _exceptionHandler); _geocoder = worldGeocoder; this.StreetsGeocoder = worldGeocoder; } else { AgsServer geocodeServer = _GetCurrentGcServer(currentGeocodingServiceInfo); _geocoder = new Geocoder(currentGeocodingServiceInfo, geocodeServer, _exceptionHandler); } if (this.StreetsGeocoder == null) { this.StreetsGeocoder = _geocoder; } }