package data
{
	import events.LoginEvent;
	
	import flash.display.DisplayObject;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.IOErrorEvent;
	import flash.net.URLLoader;
	import flash.net.URLRequest;
	
	import mx.binding.utils.BindingUtils;
	import mx.collections.XMLListCollection;
	import mx.controls.Alert;
	import mx.core.Application;
	import mx.events.CollectionEvent;
	import mx.managers.PopUpManager;
	import mx.rpc.events.FaultEvent;
	import mx.rpc.events.ResultEvent;
	import mx.rpc.http.HTTPService;
	
	import panels.ServerLoginPanel;	
		
	[Event(name="ready")]
	[Event(name="serverCacheDropped")]
	public class DataSource extends EventDispatcher
	{
		[Bindable]
		public var contextTree:XMLList;
		
		[Bindable]
		public var serverProps:XMLList;
		
		[Bindable]
		public var guiTree:XMLList;
		
		
		[Bindable]
		public var guiConfigs:XMLList;
	 
	 	[Bindable]
		public var defaultConfig:XMLList;
		
		private var layerProps:XMLListCollection = new XMLListCollection();
		private var contextProps:XMLListCollection = new XMLListCollection();
		private var mapProps:XMLListCollection = new XMLListCollection();
		private var queryAspectProps:XMLListCollection = new XMLListCollection();
		private var templateProps:XMLListCollection = new XMLListCollection();
		private var reportProps:XMLListCollection = new XMLListCollection();
		private var colorProps:XMLListCollection = new XMLListCollection();
				
		private var lastId:Number = 0;
		
		private var _serverUrl:String;	
		private var _proxyServerUrl:String;
		private var _login:String;	
		private var _configsUrl:String;
		private var _defaultConfigUrl:String;
		
		
		private var getRequestCounter:Number;
		
		namespace wfs = "http://www.opengis.net/wfs";
		namespace xsd = "http://www.w3.org/2001/XMLSchema";
		use namespace wfs;
		use namespace xsd;
		
		private function getRequestCompleted():void
		{
			getRequestCounter--;
			if(getRequestCounter == 0)
			{
				buildGUIDataSource();
				dispatchEvent(new Event("ready"));	
				
			}
			
		}
		
		private function buildGUIDataSource():void{
			var tree:XML = <Configs></Configs>;
			for(var i:Number=0;i<guiConfigs.length();i++){
				var guiConfig:XML = refactorGuiConfig(guiConfigs[i]);
				tree.appendChild(guiConfig);
			}
			guiTree = XMLList(tree);
		} 
		
		
		private function refactorGuiConfig(guiConfig:XML):XML{
			var newConfig:XML = new XML(defaultConfig); 
			newConfig.@name = guiConfig.@name;
			var colorNodes:XMLList = newConfig.Colors.children();
			for(var j:Number=0;j<colorNodes.length();j++){
					var colorName:String = String(colorNodes[j].localName());
					if(guiConfig.Colors.child(colorName).length() > 0){
						colorNodes[j] = guiConfig.Colors.child(colorName)[0];
					}	
			}
			newConfig.ButtonBars = guiConfig.ButtonBars;
			var buttonNodes:XMLList = newConfig.ActionButtons.children();
			buttonNodes += newConfig.PaneButtons.children();
			buttonNodes += newConfig.MapViewerButtons.children();
			var orgButtonNodes:XMLList = guiConfig.ActionButtons.children();
			orgButtonNodes += guiConfig.PaneButtons.children();
			orgButtonNodes += guiConfig.MapViewerButtons.children(); 
			for(var j:Number=0;j<buttonNodes.length();j++){
				var buttonName:String = String(buttonNodes[j].Name);
				var buttonAttributes:XMLList = buttonNodes[j].children();
				for(var k:Number=0;k<buttonAttributes.length();k++){
					var attrName:String = buttonAttributes[k].localName();
					if(attrName!="Name" && attrName!="BaseURL" && 
						attrName!="IconURL" && attrName!="Action"){
						if(orgButtonNodes.child(attrName)[0]!=null){
							buttonAttributes[k] = orgButtonNodes.child(attrName)[0];
						}
					}
				}
			}
			var buttonCollection:XMLListCollection = new XMLListCollection();
			buttonCollection.source = buttonNodes;

			var paneNodes:XMLList =  newConfig.SinglePaneComponents.children();
			paneNodes += newConfig.MultiPaneComponents.children();
			var orgPaneNodes:XMLList = guiConfig.SinglePaneComponents.children();
			orgPaneNodes += guiConfig.MultiPaneComponents.children();
			for(var j:Number=0;j<paneNodes.length();j++){
				var paneName:String = String(paneNodes[j].Name);
				var paneAttributes:XMLList = paneNodes[j].children();
				for(var k:Number=0;k<paneAttributes.length();k++){
					var attrName:String = paneAttributes[k].localName();
					if(attrName!="Name" && attrName!="URL" && 
						attrName!="Scrollable" && attrName!="Resizable" &&
						attrName!="Closeable" && attrName!="InitVisible" &&
						attrName!="PaneButton" && attrName!="Adapters" &&
						attrName!="Buttons"){
						if(orgPaneNodes.child(attrName)[0]!=null){
							paneAttributes[k] = orgPaneNodes[j].child(attrName)[0];
						}
					}
				}
			}
			return newConfig;
		}
             

			
		private var treePutRequestCounter:Number;
		
		private function treePutRequestCompleted():void
		{
			treePutRequestCounter--;
			if(treePutRequestCounter == 0)
			{
				Alert.show("Saved");
			}
		}
		
		private function finishSave():void
		{
			var proxyReload:URLLoader = new URLLoader();
			proxyReload.addEventListener(Event.COMPLETE, function():void {
				var resp:Object = XML(proxyReload.data).localName();	
				
				treePutRequestCounter = 0;
			
				if(contextTree.children().length() > 0) {
					treePutRequestCounter++;
					
					var contextTreePutter:URLLoader = new URLLoader();
					contextTreePutter.addEventListener(Event.COMPLETE, function():void
					{
						var response:XML = XML(contextTreePutter.data);	
						if(response.localName() == "Error")
						{
							Alert.show("Coulnd't store context map tree"
								+ "\n" + response.ErrorMessage);					
						}
						else
						{
							treePutRequestCompleted();
						}
					});
					removeDeleted(contextTree.Context);
					var  contextTreePutRequest:URLRequest
						= new URLRequest(_serverUrl + "request=PutContextsTree");
					contextTreePutRequest.method = "POST";
					contextTreePutRequest.data = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
						contextTree.toString();
					contextTreePutter.load(contextTreePutRequest);
				}
				
				if(treePutRequestCounter == 0) {
					treePutRequestCounter++;
					treePutRequestCompleted();
				}
			});
			
			proxyReload.load(new URLRequest(this._proxyServerUrl + "/?service=reload"));
		}
		
		public function logout(callback:Function):void {
			var logoutLoader:URLLoader = new URLLoader();
			logoutLoader.addEventListener(Event.COMPLETE, function():void
			{
				callback();
			});
			logoutLoader.load(new URLRequest(_serverUrl + "request=Logout"));			
		}
		
		private function loadData():void {
			
			getRequestCounter = 10;
		
			var contextTreeLoader:URLLoader = new URLLoader();
			contextTreeLoader.addEventListener(Event.COMPLETE, function():void
			{
				contextTree = new XMLList(XML(contextTreeLoader.data));
				getRequestCompleted();				
			});
			contextTreeLoader.load(new URLRequest(_serverUrl + "request=GetContextsTree"));
												
			var layerPropsLoader:URLLoader = new URLLoader();
			layerPropsLoader.addEventListener(Event.COMPLETE, function():void
			{
				layerProps.source = new XMLList(XML(layerPropsLoader.data));
				getRequestCompleted();													
			});
			layerPropsLoader.load(new URLRequest(_serverUrl + "request=GetLayers"));
			
			var contextPropsLoader:URLLoader = new URLLoader();
			contextPropsLoader.addEventListener(Event.COMPLETE, function():void
			{
				contextProps.source = new XMLList(XML(contextPropsLoader.data));
				getRequestCompleted();													
			});
			contextPropsLoader.load(new URLRequest(_serverUrl + "request=GetContexts"));

			var mapPropsLoader:URLLoader = new URLLoader();
			mapPropsLoader.addEventListener(Event.COMPLETE, function():void
			{
				mapProps.source = new XMLList(XML(mapPropsLoader.data));
				getRequestCompleted();													
			});
			mapPropsLoader.load(new URLRequest(_serverUrl + "request=GetMaps"));

			var serverPropsLoader:URLLoader = new URLLoader();
			serverPropsLoader.addEventListener(Event.COMPLETE, function():void
			{
				serverProps = new XMLList(XML(serverPropsLoader.data));
				getRequestCompleted();													
			});
			serverPropsLoader.load(new URLRequest(_serverUrl + "request=GetServers"));
			
			var queryAspectsPropsLoader:URLLoader = new URLLoader();
			queryAspectsPropsLoader.addEventListener(Event.COMPLETE, function():void
			{
				queryAspectProps.source = new XMLList(XML(queryAspectsPropsLoader.data));
				getRequestCompleted();													
			});
			queryAspectsPropsLoader.load(new URLRequest(_serverUrl + "request=GetQueryAspects"));
			
			var templatesPropsLoader:URLLoader = new URLLoader();
			templatesPropsLoader.addEventListener(Event.COMPLETE, function():void
			{
				templateProps.source = new XMLList(XML(templatesPropsLoader.data));
				getRequestCompleted();													
			});
			templatesPropsLoader.load(new URLRequest(_serverUrl + "request=GetTemplates"));
			
			var reportsPropsLoader:URLLoader = new URLLoader();
			reportsPropsLoader.addEventListener(Event.COMPLETE, function():void
			{
				reportProps.source = new XMLList(XML(reportsPropsLoader.data));
				getRequestCompleted();													
			});
			reportsPropsLoader.load(new URLRequest(_serverUrl + "request=GetReports"));
			
			var configsLoader:URLLoader = new URLLoader();
			configsLoader.addEventListener(Event.COMPLETE, function():void
			{
				guiConfigs = XMLList(configsLoader.data).children();
				getRequestCompleted();													
			});
			configsLoader.load(new URLRequest(_configsUrl + "?author=" + _login));
			
			var defaultConfigLoader:URLLoader = new URLLoader();
			defaultConfigLoader.addEventListener(Event.COMPLETE, function():void
			{
				defaultConfig =XMLList(defaultConfigLoader.data);
				getRequestCompleted();													
			});
			
			defaultConfigLoader.load(new URLRequest(_defaultConfigUrl));			
		}
		
		public function DataSource(callback:Function)
		{	
			var configLoader:URLLoader = new URLLoader();
			configLoader.addEventListener(Event.COMPLETE, function():void
			{
				_serverUrl = XML(configLoader.data).server.toString();
				_proxyServerUrl = XML(configLoader.data).proxyServer.toString();
				_configsUrl = XML(configLoader.data).guiConfigsUrl.toString();
				_defaultConfigUrl = XML(configLoader.data).defaultGUIConfigUrl.toString();				
				var getAuthorRequest:URLLoader = new URLLoader();
				getAuthorRequest.addEventListener(IOErrorEvent.IO_ERROR, function():void {
					dispatchEvent(new Event("ioError"));
				});
				getAuthorRequest.addEventListener(Event.COMPLETE, function():void
				{
					var response:XML = XML(getAuthorRequest.data);
					_login = response.Name.toString();
					
					callback();						
					loadData();					
				});
				getAuthorRequest.load(new URLRequest(_serverUrl + "request=GetAuthor"));
			});	
			configLoader.load(new URLRequest("config.xml"));
		}
		
		public function getLayers(mapItem:XML):XMLList
		{
			if(mapItem.child("@clientId").length() > 0 && mapItem.@clientId == true) { 
				return contextTree.Context.Maps.Map.(child("@clientId").length() > 0 && @clientId == true && @id == mapItem.@id).Layers
			}
			else {
				return contextTree.Context.Maps.Map.((child("@clientId").length() == 0 || @clientId == false) && @id == mapItem.@id).Layers
			}
		}
		
		private function getMaps(contextItem:XML):XMLList 
		{
			if(contextItem.child("@clientId").length() > 0 && contextItem.@clientId == true) {
				return contextTree.Context.(child("@clientId").length() > 0 && @clientId == true && @id == contextItem.@id).Maps;
			}
			else {
				return contextTree.Context.((child("@clientId").length() == 0 || @clientId == false) && @id == contextItem.@id).Maps;
			}
		}
		
		public function getQueryAspects(mapItem:XML):XMLList 
		{
			if(mapItem.child("@clientId").length() > 0 && mapItem.@clientId == true) { 
				return contextTree.Context.Maps.Map.(child("@clientId").length() > 0 && @clientId == true && @id == mapItem.@id).QueryAspects
			} else {
				return contextTree.Context.Maps.Map.((child("@clientId").length() == 0 || @clientId == false) && @id == mapItem.@id).QueryAspects
			}
		}
		
		public function getTemplates(mapItem:XML):XMLList 
		{
			if(mapItem.child("@clientId").length() > 0 && mapItem.@clientId == true) { 
				return contextTree.Context.Maps.Map.(child("@clientId").length() > 0 && @clientId == true && @id == mapItem.@id).Templates
			} else {
				return contextTree.Context.Maps.Map.((child("@clientId").length() == 0 || @clientId == false) && @id == mapItem.@id).Templates
			}
		}
		
		public function getProps(item:XML):XMLList
		{
			if(item == null) 
				return null;
				
			if(item.localName() == "Featureserver") {
				item = item.copy();
				item.setLocalName("Server");				
			}
				
			var list:XMLList;
			var clientId:Boolean = false;
			if(item.attribute("clientId").length() > 0)
			{
				clientId = item.@clientId.toString().
					toLocaleLowerCase() == "true" ? true : false;
			}
			
			switch(item.localName())
			{
				case "Context":
					list = contextProps.source;
					break;
				case "Map":
					list = mapProps.source;
					break;
				case "Server":
					list = serverProps;
					break;
				case "Layer":
					list = layerProps.source;
					break;
				case "QueryAspect":
					list = queryAspectProps.source;
					break;
				case "Template":
					list = templateProps.source;
					break;	
				case "Report":
					list = reportProps.source;
					break;
				case "Colors":
					list = colorProps.source;
					break;	
			}
			
			if(list == null)
				return null;	
			
			for each(var currentItem:XML in list.child(item.localName()))
			{
				var currentClientId:Boolean = false;
				if(currentItem.attribute("clientId").length() > 0)
				{
					currentClientId = currentItem.@clientId.toString().
						toLocaleLowerCase() == "true" ? true : false;
				}
					
				if(currentClientId == clientId
					&& currentItem.@id == item.@id)
				{
					return new XMLList(currentItem);
				}
			}
			
			return new XMLList();
		}
		
		public function getXMLAsString():String		
		{
			return "\nlayerProps:\n" + layerProps.toString()
				+ "\nmapProps:\n" + mapProps.toString()
				+ "\ncontextTree:\n" + contextTree.toString()
				+ "\ncontextProps:\n" + contextProps.toString()
				+ "\nserverProps:\n" + serverProps.toString()
				+ "\nqueryAspectProps:\n" + queryAspectProps.toString()
				+ "\ntemplateProps:\n" + templateProps.toString();		
							
		}
		
		public function isGroupLayer(layerItem:XML):Boolean
		{
			return getProps(layerItem).Type == "Group";
		}
		
		public function isOwner(item:XML):Boolean
		{
			var props:XML = item.child("Owner").length() == 0 ? getProps(item)[0] : item;
			if(props != null && props.Owner.length() > 0) {
				return props.Owner == _login;
			}
				return false;			
		}
		
		private function isClientId(item:XML):Boolean {
			return item.child("@clientId").length() > 0 && item.@clientId;
		}
		
		public function duplicateItem(item:XML):XML {
			var newItem:XML = item.copy();
			newItem.@clientId = true;
			newItem.@id = lastId++;
			newItem.@status = "new";
			
			if(item.localName() == "Server") {
				newItem.Title = item.Title + "_copy";
			} else {
				newItem.Name = item.Name + "_copy";
			}
			
			addItem(newItem);
						
			//Copy subitem refs
			switch(item.localName()) {
				case 'Map':							
					for each(var map:XML in contextTree.Context.Maps.Map) 
					{	
						if(isClientId(map) == isClientId(item) && map.@id == item.@id) {
							var dupRef:XML = map.copy();
							dupRef.@id = newItem.@id;
							dupRef.@clientId = true;
							XML(map.parent()).appendChild(dupRef);						
						}						
					}
					break;
				case 'Context':
					for each(var context:XML in contextTree.Context) 
					{
						if(isClientId(context) == isClientId(item) && context.@id == item.@id) {
							dupRef = context.copy();
							dupRef.@id = newItem.@id;
							dupRef.@clientId = true;
							XML(context.parent()).appendChild(dupRef);						
						}
					}
			}
			
			return newItem;
		}
		
		public function duplicateItemRef(itemRef:XML):XML
		{
			var item:XMLList = getProps(itemRef);
			var newItem:XML = duplicateItem(item[0]);
			return newRef(newItem);		
		}
		
		private function updateLayerTree(layers:XMLList):void {
			for each(var layer:XML in layers) {
				if(isGroupLayer(layer)) {
					layer.setChildren(getProps(layer).Layers.Layer.copy());
					updateLayerTree(layer.Layer);										
				}
			}
		}
		
		public function newRef(item:XML):XML 
		{
			var itemRef:XML = new XML("<" + item.localName() 
				+ "></" + item.localName() + ">");
			itemRef.@status = item.@status;
			itemRef.@id = item.@id;
			if(item.attribute("clientId").length() > 0)
			{
				itemRef.@clientId = item.@clientId;
			}
			
			if(item.localName() == "Map") {
				itemRef.appendChild(item.Layers.copy());
				updateLayerTree(itemRef.Layers.Layer);
				itemRef.appendChild(item.QueryAspects.copy());
				itemRef.appendChild(item.Templates.copy());
				itemRef.appendChild(item.Reports.copy());
			} else if(item.localName() == "Context") {
				itemRef.appendChild(<Maps/>);
			} else if(item.localName() == "Layer") {
				for each(var layer:XML in item.Layers.Layer) {
					itemRef.appendChild(layer.copy());
				}
			}			
						
			return itemRef;
		}
		
		public function newLayer():XML
		{
			var newItem:XML = 
			<Layer clientId="true" status="new">
				<Type>Layer</Type>
				<Titles>
					<Title>
						<Language>en</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>nl</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>de</Language>
						<Title></Title>
					</Title>
				</Titles>
				<Server/>
			</Layer>;
			newItem.@id = lastId++;	
			newItem.Owner = _login;	
			newItem.Server.@id = serverProps.Server[0].@id;			
			return newItem;
		}
		
		public function newGroupLayer():XML
		{
			var newItem:XML = 
			<Layer clientId="true" status="new">
				<Type>Group</Type>
				<Titles>
					<Title>
						<Language>en</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>nl</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>de</Language>
						<Title></Title>
					</Title>
				</Titles>				
			</Layer>;
			newItem.@id = lastId++;	
			newItem.Owner = _login;
			return newItem;
		}
		
		public function newMap():XML
		{
			var newItem:XML = 
			<Map clientId="true" status="new">
				<Titles>
					<Title>
						<Language>en</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>nl</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>de</Language>
						<Title></Title>
					</Title>
				</Titles>
				<Layers/>
				<QueryAspects/>	
				<Templates/>
				<Reports/>							
			</Map>;
			newItem.@id = lastId++;
			newItem.Owner = _login;
			return newItem;
		}
		
		public function newServer():XML
		{
			var newItem:XML =
			<Server clientId="true" status="new">
			</Server>;
			newItem.@id = lastId++;
			newItem.Owner = _login;						
			return newItem;
		}
		
		public function newQueryAspect():XML
		{
			var newItem:XML =
			<QueryAspect clientId="true" status="new">
				<Titles>
					<Title>
						<Language>en</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>nl</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>de</Language>
						<Title></Title>
					</Title>
				</Titles>
				<Actions/>
				<FeatureTypeProperties/>
			</QueryAspect>;
			newItem.@id = lastId++;
			newItem.Owner = _login;						
			return newItem;
		}
		
		public function newTemplate():XML
		{
			var newItem:XML =
			<Template clientId="true" status="new">
				<Titles>
					<Title>
						<Language>en</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>nl</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>de</Language>
						<Title></Title>
					</Title>
				</Titles>
				<Margin>
					<Top>10</Top>
					<Left>10</Left>
					<Right>10</Right>
					<Bottom>10</Bottom>
				</Margin>
				<Elements>
					<Element>
						<Type>map</Type>
						<X>0</X>
						<Y>0</Y>
						<Width>0</Width>
						<Height>0</Height>
					</Element>
				</Elements>				
			</Template>;
			newItem.@id = lastId++;
			newItem.Owner = _login;						
			return newItem;
		}
		
		public function newReport(mapId:Number):XML
		{
			var newItem:XML =
			<Report clientId="true" status="new">
				
				<Titles>
					<Title>
						<Language>en</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>nl</Language>
						<Title></Title>
					</Title>
					<Title>
						<Language>de</Language>
						<Title></Title>
					</Title>
				</Titles>
				<Map_id>{mapId}</Map_id>
			</Report>
			newItem.@id = lastId++;
			return newItem;
		}
		
		
		public function newContext():XML
		{
			var newItem:XML =
			<Context clientId="true" status="new">
			</Context>
			newItem.@id = lastId++;
			newItem.Owner = _login;
			return newItem;
		}
		
		public function addItem(newItem:XML):void
		{
			switch(newItem.localName())
			{
				case 'Layer':
					XML(layerProps[0]).appendChild(newItem);
					break;
				case 'Map':
					XML(mapProps[0]).appendChild(newItem);					
					break;
				case 'Server':
					XML(serverProps[0]).appendChild(newItem);
					break;
				case 'Context':
					XML(contextProps[0]).appendChild(newItem);					
					break;
				case 'QueryAspect':
					XML(queryAspectProps[0]).appendChild(newItem);
				case 'Template':
					XML(templateProps[0]).appendChild(newItem);	
				case 'Report':
					XML(reportProps[0]).appendChild(newItem);	
			}
		}
		
		private function replaceClientId(clientId:Number, serverId:Number, 
			items:XMLList, recursive:Boolean = true):void
		{
			var newItems:XMLList = items.(@status == "new").(@id == clientId);
			for each(var item:XML in newItems)
			{
				delete item.@clientId;
				item.@id = serverId;
				item.@status = "existing";				
			}
			
			if(recursive)
			{
				for each(item in items)
				{
					replaceClientId(clientId, serverId, item.children());
				}
			}
		}
		
		private function removeDeleted(items:XMLList):void
		{			
			for each(var item:XML in items)
			{	
				if(item.attribute("status").length() > 0)
				{
					if(item.@status == "deleted")
					{
						delete items.(@id == item.@id && @status == "deleted")[0];
						continue;
					}															
				}
				
				removeDeleted(item.children());
			}
		}
		
		private function setLayerId(list:XMLList, clientId:String, serverId:String):void {
			for each(var layerRef:XML in list..Layer.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) {
				layerRef.@id = serverId;
				delete layerRef.@clientId;
				layerRef.@status = "existing";
			}
		}
		
		private function setMapId(list:XMLList, clientId:String, serverId:String):void {
			for each(var mapRef:XML in list..Map.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) {
				mapRef.@id = serverId;
				delete mapRef.@clientId;
				mapRef.@status = "existing";
			}
		}
		
		private function setContextId(list:XMLList, clientId:String, serverId:String):void {
			for each(var contextRef:XML in list..Context.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) {
				contextRef.@id = serverId;
				delete contextRef.@clientId;
				contextRef.@status = "existing";
			}
		}
		
		private function setTemplateId(list:XMLList, clientId:String, templateId:String):void {
			for each(var templateRef:XML in list..Template.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) {
				templateRef.@id = templateId;
				delete templateRef.@clientId;
				templateRef.@status = "existing";
			}
		}
		
		private function setReportId(list:XMLList, clientId:String, reportId:String):void {
			for each(var reportRef:XML in list..Report.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) {
				reportRef.@id = reportId;
				delete reportRef.@clientId;
				reportRef.@status = "existing";
			}
		}
		
		private function setQueryAspectId(list:XMLList, clientId:String, serverId:String):void {
			for each(var queryAspectRef:XML in list..QueryAspect.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) {
				queryAspectRef.@id = serverId;
				delete queryAspectRef.@clientId;
				queryAspectRef.@status = "existing";
			}
		}
		
		private function setServerId(list:XMLList, clientId:String, serverId:String):void {
			for each(var server:XML in list..Server.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) { 
				server.@id = serverId;
				delete server.@clientId;
				server.@status = 'existing';
			}
			
			for each(server in list..Featureserver.
				(attribute("clientId").length() > 0 
					&& @clientId.toString().toLowerCase() == "true"
					&& @id == clientId)) { 
				server.@id = serverId;
				delete server.@clientId;
				server.@status = 'existing';
			}
		}
		
		public function save():void {
			var updateServers:XMLList = serverProps.Server.(@status != "existing");
			if(updateServers.length() > 0)
			{				
				var serverPutter:URLLoader = new URLLoader();
				serverPutter.addEventListener(Event.COMPLETE, function():void
				{
					var response:XML = XML(serverPutter.data);
					if(XML(response).localName() == "Error")
					{
						Alert.show("Couldn't store server properties!"
							+ "\n" + response.ErrorMessage);
					}
					else
					{
						for each(var server:XML in response.Server)
						{
							setServerId(contextProps.source, server.@clientId, server.@Id);
							setServerId(layerProps.source, server.@clientId, server.@Id);
							setServerId(queryAspectProps.source, server.@clientId, server.@Id);
							setServerId(serverProps, server.@clientId, server.@Id);
						}
						
						for each(server in serverProps.child("Server").(@status == 'changed'))
						{	
							server.@status = 'existing';
						}
						
						removeDeleted(serverProps);
						
						saveNewChangedEntities();
					}
				});
				var serverPutRequest:URLRequest = new URLRequest(_serverUrl + "request=PutServers");
				serverPutRequest.method = "POST";
				serverPutRequest.data = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + <Servers></Servers>.appendChild(
					updateServers.copy()).toString();
				serverPutter.load(serverPutRequest);
			} else {			
				saveNewChangedEntities();
			}
		}
		
		private function putMaps(maps:XMLList, callback:Function):void {
			if(maps.length() == 0) {
				callback();
			} else {			
				var mapPutter:URLLoader = new URLLoader();
				mapPutter.addEventListener(Event.COMPLETE, function():void
				{
					var response:XML = XML(mapPutter.data);
					if(XML(response).localName() == "Error")
					{
						Alert.show("Couldn't store map properties!"
							+ "\n" + response.ErrorMessage);
					}
					else
					{
						for each(var map:XML in response.Map)
						{
							setMapId(contextTree, map.@clientId, map.@Id);
							setMapId(mapProps.source, map.@clientId, map.@Id);
						}
						
						for each(map in mapProps.child("Map").(@status == 'changed'))
						{	
							map.@status = 'existing';
						}
						
						callback();
					}
				});
				var mapPutRequest:URLRequest = new URLRequest(_serverUrl + "request=PutMaps");
				mapPutRequest.method = "POST";
				mapPutRequest.data = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + <Maps></Maps>.appendChild(
					maps.copy()).toString();
				mapPutter.load(mapPutRequest);
			}
		}
		
		private function putLayers(layers:XMLList, callback:Function):void {
			if(layers.length() == 0) {
				callback();
			} else {			
				var layerPutter:URLLoader = new URLLoader();
				layerPutter.addEventListener(Event.COMPLETE, function():void
				{
					var response:XML = XML(layerPutter.data);
					if(XML(response).localName() == "Error")
					{
						Alert.show("Coulnd't store layer properties!"
							+ "\n" + response.ErrorMessage);
					}
					else
					{
						for each(var layer:XML in response.Layer)
						{	
							setLayerId(contextTree, layer.@clientId, layer.@Id);
							setLayerId(layerProps.source, layer.@clientId, layer.@Id);
							var properties:XML = XML(layerProps.source.Layer.(@id == layer.@clientId && @status == 'new')[0])
							properties.@id = layer.@Id;
							delete properties.@clientId;							
							properties.@status = 'existing';
						}				
						
						for each(layer in layerProps.child("Layer").(@status == 'changed'))
						{	
							layer.@status = 'existing';
						}			
						
						callback();
					}
				});
						
				var layerPutRequest:URLRequest = new URLRequest(_serverUrl + "request=PutLayers");
				layerPutRequest.method = "POST";
				layerPutRequest.data = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + <Layers></Layers>.appendChild(
					layers.copy()).toString();
				layerPutter.load(layerPutRequest);
			}
		}
		
		private function putContexts(contexts:XMLList, callback:Function):void {
			if(contexts.length() == 0) {
				callback();
			} else {
				var contextPutter:URLLoader = new URLLoader();
				contextPutter.addEventListener(Event.COMPLETE, function():void
				{
					var response:XML = XML(contextPutter.data);
					if(XML(response).localName() == "Error")
					{
						Alert.show("Couldn't store context properties!"
							+ "\n" + response.ErrorMessage);
					}
					else
					{
						for each(var context:XML in response.Context)
						{
							setContextId(contextTree, context.@clientId, context.@Id);
							setContextId(contextProps.source, context.@clientId, context.@Id);
						}
						
						for each(context in contextProps.child("Context").(@status == 'changed'))
						{	
							context.@status = 'existing';
						}
						
						callback();
					}
				});
				var contextPutRequest:URLRequest = new URLRequest(_serverUrl + "request=PutContexts");
				contextPutRequest.method = "POST";
				contextPutRequest.data = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + <Contexts></Contexts>.appendChild(
					contexts.copy()).toString();
				contextPutter.load(contextPutRequest);
			}
		}		
		
		private function putQueryAspects(queryAspects:XMLList, callback:Function):void {
			if(queryAspects.length() == 0) {
				callback();
			} else {
				var queryAspectPutter:URLLoader = new URLLoader();
				queryAspectPutter.addEventListener(Event.COMPLETE, function():void
				{
					var response:XML = XML(queryAspectPutter.data);
					if(XML(response).localName() == "Error")
					{
						Alert.show("Couldn't store query aspect properties!"
							+ "\n" + response.ErrorMessage);
					}
					else
					{
						for each(var queryAspect:XML in response.QueryAspect)
						{
							setQueryAspectId(contextTree, queryAspect.@clientId, queryAspect.@Id);
							setQueryAspectId(queryAspectProps.source, queryAspect.@clientId, queryAspect.@Id);							
						}
						
						for each(queryAspect in queryAspectProps.child("QueryAspect").(@status == 'changed'))
						{	
							queryAspect.@status = 'existing';
						}
						
						callback();
					}
				});
				var queryApsectPutRequest:URLRequest = new URLRequest(_serverUrl + "request=PutQueryAspects");
				queryApsectPutRequest.method = "POST";
				queryApsectPutRequest.data = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + <QueryAspects></QueryAspects>.appendChild(
					queryAspects.copy()).toString();
				queryAspectPutter.load(queryApsectPutRequest);
			}
		}
		
		private function putTemplates(templates:XMLList, callback:Function):void {
			if(templates.length() == 0) {
				callback();
			} else {
				var templatePutter:URLLoader = new URLLoader();
				templatePutter.addEventListener(Event.COMPLETE, function():void
				{
					var response:XML = XML(templatePutter.data);
					if(XML(response).localName() == "Error")
					{
						Alert.show("Couldn't store template properties!"
							+ "\n" + response.ErrorMessage);
					}
					else
					{
						for each(var template:XML in response.Template)
						{
							setTemplateId(templateProps.source, template.@clientId, template.@Id);
							setTemplateId(contextTree, template.@clientId, template.@Id);
							setTemplateId(mapProps.children(), template.@clientId, template.@Id);					
						}
						
						for each(template in templateProps.child("Template").(@status == 'changed'))
						{	
							template.@status = 'existing';
						}
						
						callback();
					}
				});
				var templatePutRequest:URLRequest = new URLRequest(_serverUrl + "request=PutTemplates");
				templatePutRequest.method = "POST";
				templatePutRequest.data = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + <Templates></Templates>.appendChild(
					templates.copy()).toString();
				templatePutter.load(templatePutRequest);
			}
		}
		
		private function putReports(reports:XMLList, callback:Function):void {
			if(reports.length() == 0) {
				callback();
			} else {
				var reportPutter:URLLoader = new URLLoader();
				reportPutter.addEventListener(Event.COMPLETE, function():void
				{
					var response:XML = XML(reportPutter.data);
					if(XML(response).localName() == "Error")
					{
						Alert.show("Couldn't store report properties!"
							+ "\n" + response.ErrorMessage);
					}
					else
					{
						for each(var report:XML in response.Report)
						{
							setReportId(reportProps.source, report.@clientId, report.@Id);
							setReportId(contextTree, report.@clientId, report.@Id);					
						}
						
						for each(report in reportProps.child("Report").(@status == 'changed'))
						{	
							report.@status = 'existing';
						}
						
						callback();
					}
				});
				var reportPutRequest:URLRequest = new URLRequest(_serverUrl + "request=PutReports");
				reportPutRequest.method = "POST";
				reportPutRequest.data = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + <Reports></Reports>.appendChild(
					reports.copy()).toString();
				reportPutter.load(reportPutRequest);
			}
		}
		
		
		public function saveNewChangedEntities():void
		{
			var updateTemplates:XMLList = templateProps.source.Template.(@status != "existing");
			putTemplates(updateTemplates, function():void {			
				var updateQueryAspects:XMLList = queryAspectProps.source.QueryAspect.(@status != "existing");
				putQueryAspects(updateQueryAspects, function():void {								
					var updateLayers:XMLList = layerProps.source.Layer.(@status != "existing");
					putLayers(updateLayers, function():void {								
						var updateReports:XMLList = reportProps.source.Report;
						putReports(updateReports, function():void {
							var updateMaps:XMLList = mapProps.source.Map.(@status != "existing");
							putMaps(updateMaps, function():void {						
								var updateContexts:XMLList = contextProps.source.Context.(@status != "existing");
								putContexts(updateContexts, function():void {
									finishSave();								
								});
							});
						});
					});
				});
			});			
		}
		
		public function hasChanges():Boolean {
			return (XMLList(contextProps.source.Context.(@status != "existing"))
				.length() > 0 || 
				XMLList(serverProps.source.Server.(@status != "existing"))
				.length() > 0 ||
				XMLList(layerProps.source.Layer.(@status != "existing"))
				.length() > 0 ||
				XMLList(mapProps.source.Map.(@status != "existing"))
				.length() > 0);
		}
		
		public function addCollectionsEventListener(listener:Function):void
		{
			layerProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, listener);
			contextProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, listener);
			mapProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, listener);
			queryAspectProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, listener);
			templateProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, listener);
			reportProps.addEventListener(CollectionEvent.COLLECTION_CHANGE, listener);			
		}
		
		private var clientCapabilities:Object = new Object();
		private var serverCapabilities:Object = new Object();
		
		private function doGetCapabilitiesRequest(server:XML, retServer:Server):void {
			var serverProps:XML = getProps(server)[0];
			
			var service:HTTPService = new HTTPService();
			service.url = getCapabilitiesUrl(serverProps, retServer); 
			service.resultFormat = "e4x";		
			service.addEventListener(FaultEvent.FAULT, function(event:FaultEvent):void {
				Alert.show(event.toString());
			});
			service.addEventListener(ResultEvent.RESULT, function():void {
				var result:XMLList = XMLList(service.lastResult);
				var serviceType:String = serverProps.Service.toString();
				
				retServer.capabilities.source = result;
				retServer.layers.source = getServerLayersFromResponse(
					result, serviceType);
				if(serviceType == "OGC:WFS") {
					retServer.featureTypes.source = result.FeatureTypeList.FeatureType.copy();					
					for each(var type:XML in result.FeatureTypeList.FeatureType) {
						var name:String = type.Name;
						var uri:String = null;
						if(name.indexOf(":") != -1) {
							var prefix:String = name.split(":")[0];
							name = name.split(":")[1];
							uri = type.namespace(prefix);
						}					
						
						var list:XMLListCollection = 
							retServer.getFeatureTypeAttributes(new QName(uri, name));
						doDescribeFeatureRequest(serverProps, uri, name, list);
					}				
				} else if(serviceType == "GI") {
					retServer.featureTypes.source = result.FeatureTypesLocalWFSClient.FeatureType.copy();
					for each(type in result.FeatureTypesLocalWFSClient.FeatureType) {
						name = type.toString();
						uri = null;
						if(name.indexOf(":") != -1) {
							prefix = name.split(":")[0];
							name = name.split(":")[1];
							uri = type.namespace(prefix);
						}					
						
						list = 
							retServer.getFeatureTypeAttributes(new QName(uri, name));
						doDescribeFeatureRequest(serverProps, uri, name, list);
					}
				}
				
				retServer.featureTypesEmptyItem.source = 
					<FeatureType><Name/></FeatureType> + retServer.featureTypes.source.copy();								
				
				if(serviceType == "GI") {
					for each(var layer:XML in retServer.capabilities.source.Layer) {
						name = layer.FeatureType;
						uri = null;
						if(name.indexOf(":") != -1) {
							prefix = name.split(":")[0];
							name = name.split(":")[1];
							uri = layer.FeatureType.namespace(prefix);
						}
						list = retServer.getLayerFeatureTypeAttributes(layer.Name.toString());
						doDescribeFeatureRequest(serverProps, uri, name, list);
						
						retServer.layerFeatureTypes[layer.Name] = layer.FeatureType[0];
					}
				}
			});
			service.send();		
		}
		
		private function getCapabilities(server:XML, forceLoad:Boolean = false):Server {
			var clientId:Boolean = false;
			if(server.child("@clientId").length() > 0) {
				clientId = server.@clientId == "true";
			} 
			
			var retServer:Server;
			if(!forceLoad) {
				 retServer = clientId ? 
					clientCapabilities["" + server.@id] :
					serverCapabilities["" + server.@id];
					
				if(retServer != null) {
					return retServer;
				}
			}
			
			retServer = new Server();
			if(clientId) {
				clientCapabilities["" + server.@id] = retServer;
			} else {
				serverCapabilities["" + server.@id] = retServer;
			}
			
			var serverProps:XML = getProps(server)[0];
			
			if(serverProps.child("Security").length() > 0
				&& serverProps.Security != "none" 
					&& XML(serverProps.Security[0]).children().length() != 0) {
					
				var serverLoginPanel:ServerLoginPanel = new ServerLoginPanel();				
				PopUpManager.addPopUp(serverLoginPanel, DisplayObject(Application.application), true);
				BindingUtils.bindProperty(serverLoginPanel, "maxHeight", Application.application, "height");
				BindingUtils.bindProperty(serverLoginPanel, "maxWidth", Application.application, "width");							
				BindingUtils.bindSetter(function():void {
					PopUpManager.centerPopUp(serverLoginPanel);
				}, mx.core.Application.application, "height");
				BindingUtils.bindSetter(function():void {
					PopUpManager.centerPopUp(serverLoginPanel);
				}, mx.core.Application.application, "width");
				PopUpManager.centerPopUp(serverLoginPanel);
				serverLoginPanel.loginHeading = serverProps.Title;
				serverLoginPanel.addEventListener(LoginEvent.LOGIN, 
				function(event:LoginEvent):void {
					PopUpManager.removePopUp(serverLoginPanel);
					retServer.user = event.login;
					retServer.password = event.password;
					doGetCapabilitiesRequest(serverProps, retServer);				
				});
			} else {
				doGetCapabilitiesRequest(serverProps, retServer);
			}
			
			return retServer;
		}
		
		public function getServerLayers(server:XML, forceLoad:Boolean = false):XMLListCollection {
			return getCapabilities(server, forceLoad).layers;
		}
		
		public function getFeatureTypes(server:XML, forceLoad:Boolean = false, emptyItem:Boolean = true):XMLListCollection {
			if(emptyItem) {
				return getCapabilities(server, forceLoad).featureTypesEmptyItem;				
			} else {
				return getCapabilities(server, forceLoad).featureTypes;
			}			
		}
		
		public function getFeatureTypeAttributes(server:XML, featureType:XML, forceLoad:Boolean = false):XMLListCollection {
			if(featureType == null || server == null) {
				return null;
			}
			
			var serverProps:XML = getProps(server)[0];									
			var name:String = null; 
			if(serverProps.Service == "OGC:WFS") {
				name = featureType.Name;
			} else if(serverProps.Service == "GI") {
				name = featureType.children()[0];
			}
			var uri:String = null;
			if(name.indexOf(":") != -1) {
				uri = featureType.namespace(name.split(":")[0]);
				name = name.split(":")[1];
			}			
			
			var serverObj:Server = getCapabilities(server, forceLoad);
			return serverObj.getFeatureTypeAttributes(new QName(uri, name), forceLoad);
		}
		
		private function getCapabilitiesUrl(server:XML, retServer:Server):String {
			var url:String = "";
			
			switch(server.Service.toString()) {
				case "GI":			
					url = server.Onlineresource.toString() + "request=GetCapabilities";
					break;
				case "OGC:WMS":
					url = server.Onlineresource.toString() + "service=WMS&request=GetCapabilities&version=" + server.Version.toString();
					break;
				case "OGC:WFS":
					url = server.Onlineresource.toString() + "service=WFS&request=GetCapabilities&version=" + server.Version.toString();
			}
			
			if(server.child("Proxy").length() > 0
				&& server.Proxy.toString() == "t") {
				
				url = this._proxyServerUrl + "/" 
					+ url.split("//")[1];
			}
			
			if(server.child("Security").length() > 0) {
				switch(server.Security.toString()) {
					case "ows":
						url += "&user=" + retServer.user + "&password=" + retServer.password;				
				}	
			}		
			
			return url;
		}
		
		private function removeNameless(layers:XMLList):XMLList {
			return layers.(child("Name").length() > 0);
		}
		
		private function flattenLayerList(rootLayer:XML):XMLList {
			var list:XMLList = new XMLList(<Root/>);
			XML(list[0]).appendChild(rootLayer.copy()[0]);
			var subLayers:XMLList =  rootLayer.Layer.copy();
			delete list.Layer.Layer;
			for each(var layer:XML in subLayers) {
				for each(var subLayer:XML in flattenLayerList(layer)) {
					XML(list[0]).appendChild(subLayer);
				}					
			}
			return list.children();
		}
		
		private function getServerLayersFromResponse(serverResponse:XMLList, service:String):XMLList {
			switch(service) {
				case "GI":
					return serverResponse.Layer;
				case "OGC:WMS":
					return removeNameless(
						flattenLayerList(serverResponse.Capability.Layer[0]));
			}
			
			return null;
		}
		
		private function getFeatureTypeNamesFromResponse(serverResponse:XMLList, server:XML):Array {
			var names:Array = new Array();
			var serviceType:String = server.Service;
			if(serviceType == "OGC:WFS") {
				for each(var type:XML in serverResponse.FeatureTypeList.FeatureType) {
					var name:String = type.Name;
					var uri:String = null;
					if(name.indexOf(":") != -1) {
						var prefix:String = name.split(":")[0];
						name = name.split(":")[1];
						uri = type.namespace(prefix);
					}					
					
					var list:XMLListCollection = new XMLListCollection();
					doDescribeFeatureRequest(server, uri, name, list);			
					
					names.push([new QName(uri, name), list]);
				}
			} else if(serviceType == "GI") {
				
			}
			return names;
		}
		
		private function doDescribeFeatureRequest(server:XML, uri:String, name:String, list:XMLListCollection):void {
			var service:HTTPService = new HTTPService();
			service.url = server.Onlineresource.toString() + "service=WFS&version=1.1.0&request=DescribeFeatureType"
				+ "&typeName=" + (uri ? "pref:" : "") + name;
			if(uri != null) { 
				service.url += "&namespace=xmlns(" +
					"pref=" + uri + ")";
			}
			service.resultFormat = "e4x";
			service.addEventListener(ResultEvent.RESULT, function(event:ResultEvent):void
			{				
				var result:XMLList = XMLList(service.lastResult);				
				var typeName:String = result.element.(@name == name).@type;
				var prefix:String = "";
				var nspace:String = "";
				if(typeName.indexOf(":") != -1) {
					var parts:Array = typeName.split(":");
					if(result.namespace(parts[0]) == result.@targetNamespace) {
						typeName = parts[1];
					}
					prefix = parts[0];
					nspace = parts[1];
				}
				var complexType:XMLList = result.complexType.(@name == typeName);
				var elements:XMLList = new XMLList(<elements/>);
				elements.elements += complexType..element;
				elements.@prefix = prefix;
				elements.@nspace = nspace;
				list.source = elements.element;
			});
			service.send();	
		}
		
		public function getLayerFeatureTypeAttributes(server:XML, layer:String, forceLoad:Boolean = false):XMLListCollection {
			return getCapabilities(server, forceLoad).getLayerFeatureTypeAttributes(layer);			
		}
		
		public function getFeatureTypeForQueryLayer(layer:XML, server:XML, forceLoad:Boolean = false):XML {
			var serverProps:XML = getProps(server)[0];
			
			if(serverProps.Service == "OGC:WFS") {
				return layer;
			} else if(serverProps.Service == "GI") {
				return getCapabilities(server, forceLoad).layerFeatureTypes[layer.Name];				
			}
			
			return null;
		}
		
		public function getQueryLayers(server:XML, forceLoad:Boolean = false):XMLListCollection {
			if(server == null) {
				return null;
			}
			
			var serverProps:XML = getProps(server)[0];
			if(serverProps.Service == "GI") {
				return getServerLayers(server, forceLoad);
			} else if(serverProps.Service == "OGC:WFS") {
				return getFeatureTypes(server, forceLoad, false);
			}
			
			return null;
		}
		
		private function getServerVersion(version:XMLList, position:Number):Number {
			var str:String = version.toString();
			var index:Number = -1;
			for(var i:Number = 0; i < position; i++) {
				index = str.indexOf(".", index + 1);				
			}

			var end:Number = str.indexOf(".", index + 1);
			if(end == -1) {
				str = str.substr(index + 1);
			} else {
				str = str.substring(index + 1, end);
			}
			
			return Number(str);
		}
		
		public function getTransformationServers():XMLList {			
			return serverProps.Server.(Service == "GI")
				.(getServerVersion(Version, 0) == 3);						
		}
		
		public function getMapServers():XMLList {			
			return serverProps.Server
				.(Service == "GI" 
				|| Service == "OGC:WMS");			
		}
		
		public function getQueryServers(omitWfs:Boolean = false):XMLList {			
			return serverProps.Server
				.(Service == "GI" 
				|| (Service == "OGC:WFS" && !omitWfs));
		}
		
		public function getFeatureServers():XMLList {
			return serverProps.Server
				.(Service == "OGC:WFS");
		}
		
		public function supportsFormats(server:XML):Boolean {
			return getProps(server).Service == "OGC:WMS";
		}
		
		public function supportsSelections(server:XML):Boolean {
			return getProps(server).Service == "GI";
		}
		
		public function isUnique(type:String, name:String, newElement:Boolean = false):Boolean {
			var count:Number = newElement ? 0 : 1;
			
			switch(type) 
			{
				case 'Context':
					return XMLList(contextProps.source.Context.(Name == name)).length() == count;
					break;
				case 'Layer':
					return XMLList(layerProps.source.Layer.(Name == name)).length() == count;
					break;
				case 'QueryAspect':
					return XMLList(queryAspectProps.source.QueryAspect.(Name == name)).length() == count;
					break;
				case 'Template':
					return XMLList(templateProps.source.Template.(Name == name)).length() == count;
					break	
				case 'Map':
					return XMLList(mapProps.source.Map.(Name == name)).length() == count;
			}
			
			return true;
		}
		
		public function updateSameItem(item:XML):void {
			if(item.localName() == "Layers" 
				|| item.localName() == "QueryAspects"
				|| item.localName() == "Templates") { //Map item
				for each(var map:XML in contextTree.Context.Maps.Map.(@id == Object(item).parent().@id)) {
					if(map != item.parent()) {
						map.setChildren(item.parent().children().copy());
					}
				}
			} else if(item.localName() == "Layer") { //Grouplayer item
				item = item.copy();
				delete item..Layer.@name;
			
				for each(var layer:XML in contextTree.Context.Maps.Map.Layers..Layer.(@id == item.@id)) {
					if(layer != item) {												
						layer.setChildren(item.children().copy());
					}
				}
				var props:XML = getProps(item)[0];
				if(props.child("Layers").length() == 0) {
					props.appendChild(<Layers/>);
				}
				
				props.Layers.setChildren(item.Layer.copy());
				props.@status = "changed";
			}
			
			if(item.localName() == "Templates") {
				var parent:XML = getProps(item.parent())[0];
				parent.Templates.setChildren(item.children().copy());
				parent.@status = "changed";
			}

		}
		
		public function getUnusedLayers(map:XML):XMLList {
			var list:XMLList = layerProps.source.Layer.copy();
			var usedLayers:XMLList = this.getLayers(map).copy();
			
			for(var i:Number = 0; i < list.length(); i++) {
				var clientId:Boolean = false;
				if(XML(list[i]).attribute("clientId").length() > 0) {					
					clientId = list[i].@clientId;
				}
				
				for each(var currentLayer:XML in 
					(clientId ? (
						usedLayers..Layer.(attribute("clientId").length() > 0 && @clientId == true)) 
						: (
						usedLayers..Layer.(attribute("clientId").length() == 0 || @clientId == false )) ) ) {
					if(currentLayer.@id == list[i].@id) {
						delete list[i];
						i--;
					}
				}
			} 
			return list;
		}
		
		public function getUnusedMaps(context:XML):XMLList {
			var list:XMLList = mapProps.source.Map.copy();
			var usedMaps:XMLList = this.getMaps(context).copy();
			
			for(var i:Number = 0; i < list.length(); i++) {
				var clientId:Boolean = false;
				if(XML(list[i]).attribute("clientId").length() > 0) {					
					clientId = list[i].@clientId;
				}
				
				for each(var currentMap:XML in 
					(clientId ? (
						usedMaps..Map.(attribute("clientId").length() > 0 && @clientId == true))
						: (
						usedMaps..Map.(attribute("clientId").length() == 0 || @clientId == false )) ) ) {					
					if(currentMap.@id == list[i].@id) {
						delete list[i];
						i--;						
					}
				}
			}
			
			return list;
		}
		
		public function getUnusedQueryAspects(map:XML):XMLList {
			var list:XMLList = queryAspectProps.source.QueryAspect.copy();			
			var usedQueryAspects:XMLList = this.getQueryAspects(map).copy();
			
			for(var i:Number = 0; i < list.length(); i++) {
				var clientId:Boolean = false;
				if(XML(list[i]).attribute("clientId").length() > 0) {					
					clientId = list[i].@clientId;
				}
				
				for each(var currentQueryAspect:XML in 
					(clientId ? (
						usedQueryAspects..QueryAspect.(attribute("clientId").length() > 0 && @clientId == true)) 
						: (
						usedQueryAspects..QueryAspect.(attribute("clientId").length() == 0 || @clientId == false )) ) ) {
					if(currentQueryAspect.@id == list[i].@id) {
						delete list[i];
						i--;
					}
				}
			}
			
			return list;
		}
		
		public function getUnusedTemplates(map:XML):XMLList {
			var list:XMLList = templateProps.source.Template.copy();			
			var usedTemplates:XMLList = this.getTemplates(map).copy();
			
			for(var i:Number = 0; i < list.length(); i++) {
				var clientId:Boolean = false;
				if(XML(list[i]).attribute("clientId").length() > 0) {					
					clientId = list[i].@clientId;
				}
				
				for each(var currentTemplate:XML in 
					(clientId ? (
						usedTemplates..Template.(attribute("clientId").length() > 0 && @clientId == true)) 
						: (
						usedTemplates..Template.(attribute("clientId").length() == 0 || @clientId == false )) ) ) {
					if(currentTemplate.@id == list[i].@id) {
						delete list[i];
						i--;
					}
				}
			}
			
			return list;
		}
		
		
		public function dropServerCache(server:XML):void {
			var clientId:Boolean = false;
			if(server.child("@clientId").length() > 0) {
				clientId = server.@clientId == "true";
			} 	
			
			if(clientId) {
				clientCapabilities["" + server.@id] = null;
			} else {
				serverCapabilities["" + server.@id] = null;
			}
			
			//dispatchEvent(new Event("serverCacheDropped"));
		}
		
		public function isServerUsed(server:XML):Boolean {
			if(server.localName() != "Server") {
				return false;
			}
			
			var clientId:Boolean = false;
			if(server.attribute("clientId").length() > 0) {
				clientId = server.@clientId.toString().toLowerCase() == "true";
			}						
			
			for each(var currentServer:XML in layerProps.source..Server) {
				var currentClientId:Boolean = false;
				if(currentServer.attribute("clientId").length() > 0) {
					currentClientId = currentServer.@clientId.toString().toLowerCase() == "true";
				}
				
				if(currentClientId == clientId 
					&& currentServer.@id == server.@id) {
					return true;		
				} 
			}
			
			for each(currentServer in layerProps.source..Featureserver) {
				currentClientId = false;
				if(currentServer.attribute("clientId").length() > 0) {
					currentClientId = currentServer.@clientId.toString().toLowerCase() == "true";
				}
				
				if(currentClientId == clientId 
					&& currentServer.@id == server.@id) {
					return true;		
				} 
			}
			
			for each(currentServer in queryAspectProps.source..Server) {
				currentClientId = false;
				if(currentServer.attribute("clientId").length() > 0) {
					currentClientId = currentServer.@clientId.toString().toLowerCase() == "true";
				}
				
				if(currentClientId == clientId 
					&& currentServer.@id == server.@id) {
					return true;		
				} 
			}
			
			for each(currentServer in contextProps.source..Server) {
				currentClientId = false;
				if(currentServer.attribute("clientId").length() > 0) {
					currentClientId = currentServer.@clientId.toString().toLowerCase() == "true";
				}
				
				if(currentClientId == clientId 
					&& currentServer.@id == server.@id) {
					return true;		
				} 
			}
			
			return false;
		}
	}
}