net/systemeD/halcyon/connection/XMLConnection.as

   1 package net.systemeD.halcyon.connection {
   2
   3     import flash.events.*;
   4         import mx.rpc.http.HTTPService;
   5         import mx.rpc.events.*;
   6         import flash.system.Security;
   7         import flash.net.*;
   8     import org.iotashan.oauth.*;
   9
  10         import net.systemeD.halcyon.AttentionEvent;
  11         import net.systemeD.halcyon.MapEvent;
  12
  13     /**
  14     * XMLConnection provides all the methods required to connect to a live
  15     * OSM server. See OSMConnection for connecting to a read-only .osm file
  16     */
  17         public class XMLConnection extends XMLBaseConnection {
  18
  19                 public function XMLConnection(name:String,api:String,policy:String,initparams:Object) {
  20
  21                         super(name,api,policy,initparams);
  22                         if (policyURL != "") Security.loadPolicyFile(policyURL);
  23
  24             var oauthPolicy:String = getParam("oauth_policy", "");
  25             if (oauthPolicy != "") Security.loadPolicyFile(oauthPolicy);
  26                 }
  27
  28                 override public function loadBbox(left:Number,right:Number,
  29                                                                 top:Number,bottom:Number):void {
  30             purgeIfFull(left,right,top,bottom);
  31             if (isBboxLoaded(left,right,top,bottom)) return;
  32
  33             // enlarge bbox by 20% on each edge
  34             var xmargin:Number=(right-left)/5;
  35             var ymargin:Number=(top-bottom)/5;
  36             left-=xmargin; right+=xmargin;
  37             bottom-=ymargin; top+=ymargin;
  38
  39             var mapVars:URLVariables = new URLVariables();
  40             mapVars.bbox= left+","+bottom+","+right+","+top;
  41
  42             var mapRequest:URLRequest = new URLRequest(apiBaseURL+"map");
  43             mapRequest.data = mapVars;
  44
  45             sendLoadRequest(mapRequest);
  46                 }
  47
  48                 override public function loadEntityByID(type:String, id:Number):void {
  49                         var url:String=apiBaseURL + type + "/" + id;
  50                         if (type=='way') url+="/full";
  51                         sendLoadRequest(new URLRequest(url));
  52                 }
  53
  54                 private function sendLoadRequest(request:URLRequest):void {
  55                         var mapLoader:URLLoader = new URLLoader();
  56                         mapLoader.addEventListener(Event.COMPLETE, loadedMap);
  57                         mapLoader.addEventListener(IOErrorEvent.IO_ERROR, errorOnMapLoad);
  58                         mapLoader.addEventListener(HTTPStatusEvent.HTTP_STATUS, mapLoadStatus);
  59                         mapLoader.load(request);
  60                         dispatchEvent(new Event(LOAD_STARTED));
  61                 }
  62
  63         private function errorOnMapLoad(event:Event):void {
  64                         dispatchEvent(new MapEvent(MapEvent.ERROR, { message: "Couldn't load the map" } ));
  65                         dispatchEvent(new Event(LOAD_COMPLETED));
  66         }
  67         private function mapLoadStatus(event:HTTPStatusEvent):void {
  68             trace("loading map status = "+event.status);
  69         }
  70
  71         protected var appID:OAuthConsumer;
  72         protected var authToken:OAuthToken;
  73
  74             override public function setAuthToken(id:Object):void {
  75                 authToken = OAuthToken(id);
  76             }
  77
  78         override public function hasAccessToken():Boolean {
  79             return !(getAccessToken() == null);
  80         }
  81
  82         override public function setAccessToken(key:String, secret:String):void {
  83             if (key && secret) {
  84               authToken = new OAuthToken(key, secret);
  85             }
  86         }
  87
  88         /* Get the stored access token, or try setting it up from loader params */
  89         private function getAccessToken():OAuthToken {
  90             if (authToken == null) {
  91               var key:String = getParam("oauth_token", null);
  92               var secret:String = getParam("oauth_token_secret", null);
  93
  94               if ( key != null && secret != null ) {
  95                   authToken = new OAuthToken(key, secret);
  96               }
  97             }
  98             return authToken;
  99         }
 100
 101         private function getConsumer():OAuthConsumer {
 102             if (appID == null) {
 103               var key:String = getParam("oauth_consumer_key", null);
 104               var secret:String = getParam("oauth_consumer_secret", null);
 105
 106               if ( key != null && secret != null ) {
 107                   appID = new OAuthConsumer(key, secret);
 108               }
 109             }
 110             return appID;
 111         }
 112
 113         private var httpStatus:int = 0;
 114
 115         private function recordStatus(event:HTTPStatusEvent):void {
 116             httpStatus = event.status;
 117         }
 118
 119         private var lastUploadedChangesetTags:Object;
 120
 121         override public function createChangeset(tags:Object):void {
 122             lastUploadedChangesetTags = tags;
 123
 124                 var changesetXML:XML = <osm version="0.6"><changeset /></osm>;
 125                 var changeset:XML = <changeset />;
 126                 for (var tagKey:Object in tags) {
 127               var tagXML:XML = <tag/>;
 128               tagXML.@k = tagKey;
 129               tagXML.@v = tags[tagKey];
 130               changesetXML.changeset.appendChild(tagXML);
 131             }
 132
 133                         sendOAuthPut(apiBaseURL+"changeset/create",
 134                                                  changesetXML,
 135                                                  changesetCreateComplete, changesetCreateError, recordStatus);
 136             }
 137
 138         private function changesetCreateComplete(event:Event):void {
 139             // response should be a Number changeset id
 140             var id:Number = Number(URLLoader(event.target).data);
 141
 142             // which means we now have a new changeset!
 143             setActiveChangeset(new Changeset(this, id, lastUploadedChangesetTags));
 144         }
 145
 146         private function changesetCreateError(event:IOErrorEvent):void {
 147             dispatchEvent(new Event(NEW_CHANGESET_ERROR));
 148         }
 149
 150                 override public function closeChangeset():void {
 151             var cs:Changeset = getActiveChangeset();
 152                         if (!cs) return;
 153
 154                         sendOAuthPut(apiBaseURL+"changeset/"+cs.id+"/close",
 155                                                  null,
 156                                                  changesetCloseComplete, changesetCloseError, recordStatus);
 157                         closeActiveChangeset();
 158                 }
 159
 160                 private function changesetCloseComplete(event:Event):void {
 161                         dispatchEvent(new AttentionEvent(AttentionEvent.ALERT, null, "Changeset closed"));
 162                 }
 163                 private function changesetCloseError(event:Event):void {
 164                         dispatchEvent(new AttentionEvent(AttentionEvent.ALERT, null, "Couldn't close changeset", 1));
 165                 }
 166
 167         private function signedOAuthURL(url:String, method:String):String {
 168             // method should be PUT, GET, POST or DELETE
 169             var sig:IOAuthSignatureMethod = new OAuthSignatureMethod_HMAC_SHA1();
 170             var oauthRequest:OAuthRequest = new OAuthRequest(method, url, null, getConsumer(), authToken);
 171             var urlStr:Object = oauthRequest.buildRequest(sig, OAuthRequest.RESULT_TYPE_URL_STRING);
 172             return String(urlStr);
 173         }
 174
 175                 private function sendOAuthPut(url:String, xml:XML, onComplete:Function, onError:Function, onStatus:Function):void {
 176             // build the request
 177             var urlReq:URLRequest = new URLRequest(signedOAuthURL(url, "PUT"));
 178             urlReq.method = "POST";
 179                         if (xml) { urlReq.data = xml.toXMLString(); } else { urlReq.data = true; }
 180             urlReq.contentType = "application/xml";
 181             urlReq.requestHeaders = [ new URLRequestHeader("X_HTTP_METHOD_OVERRIDE", "PUT"),
 182                                                   new URLRequestHeader("X-Error-Format", "XML") ];
 183             var loader:URLLoader = new URLLoader();
 184             loader.addEventListener(Event.COMPLETE, onComplete);
 185             loader.addEventListener(IOErrorEvent.IO_ERROR, onError);
 186             loader.addEventListener(HTTPStatusEvent.HTTP_STATUS, onStatus);
 187                 loader.load(urlReq);
 188                 }
 189
 190         private function sendOAuthGet(url:String, onComplete:Function, onError:Function, onStatus:Function):void {
 191             var urlReq:URLRequest = new URLRequest(signedOAuthURL(url, "GET"));
 192             urlReq.method = "GET";
 193             var loader:URLLoader = new URLLoader();
 194             loader.addEventListener(Event.COMPLETE, onComplete);
 195             loader.addEventListener(IOErrorEvent.IO_ERROR, onError);
 196             loader.addEventListener(HTTPStatusEvent.HTTP_STATUS, onStatus);
 197             loader.load(urlReq);
 198         }
 199
 200         override public function uploadChanges():void {
 201             var changeset:Changeset = getActiveChangeset();
 202             var upload:XML = <osmChange version="0.6"/>
 203             upload.appendChild(addCreated(changeset, getAllNodeIDs, getNode, serialiseNode));
 204             upload.appendChild(addCreated(changeset, getAllWayIDs, getWay, serialiseWay));
 205             upload.appendChild(addCreated(changeset, getAllRelationIDs, getRelation, serialiseRelation));
 206             upload.appendChild(addModified(changeset, getAllNodeIDs, getNode, serialiseNode));
 207             upload.appendChild(addModified(changeset, getAllWayIDs, getWay, serialiseWay));
 208             upload.appendChild(addModified(changeset, getAllRelationIDs, getRelation, serialiseRelation));
 209             upload.appendChild(addDeleted(changeset, getAllRelationIDs, getRelation, serialiseEntityRoot, false));
 210             upload.appendChild(addDeleted(changeset, getAllRelationIDs, getRelation, serialiseEntityRoot, true));
 211             upload.appendChild(addDeleted(changeset, getAllWayIDs, getWay, serialiseEntityRoot, false));
 212             upload.appendChild(addDeleted(changeset, getAllWayIDs, getWay, serialiseEntityRoot, true));
 213             upload.appendChild(addDeleted(changeset, getAllNodeIDs, getNode, serialiseEntityRoot, false));
 214             upload.appendChild(addDeleted(changeset, getAllNodeIDs, getNode, serialiseEntityRoot, true));
 215
 216             // now actually upload them
 217             // make an OAuth query
 218             var url:String = apiBaseURL+"changeset/" + changeset.id + "/upload";
 219
 220             // build the actual request
 221                         var serv:HTTPService=new HTTPService();
 222                         serv.method="POST";
 223                         serv.url=signedOAuthURL(url, "POST");
 224                         serv.contentType = "text/xml";
 225                         serv.headers={'X-Error-Format':'xml'};
 226                         serv.request=" ";
 227                         serv.resultFormat="e4x";
 228                         serv.requestTimeout=0;
 229                         serv.addEventListener(ResultEvent.RESULT, diffUploadComplete);
 230                         serv.addEventListener(FaultEvent.FAULT, diffUploadIOError);
 231                         serv.send(upload);
 232
 233                 dispatchEvent(new Event(SAVE_STARTED));
 234         }
 235
 236         private function diffUploadComplete(event:ResultEvent):void {
 237                         var results:XML = XML(event.result);
 238
 239                         // was it an error document?
 240                         if (results.name().localName=='osmError') {
 241                         dispatchEvent(new SaveCompleteEvent(SAVE_COMPLETED, false));
 242                                 diffUploadAPIError(results.status, results.message);
 243                                 return;
 244                         }
 245
 246             // response should be XML describing the progress
 247
 248             for each( var update:XML in results.child("*") ) {
 249                 var oldID:Number = Number(update.@old_id);
 250                 var newID:Number = Number(update.@new_id);
 251                 var version:uint = uint(update.@new_version);
 252                 var type:String = update.name();
 253
 254                                 if (newID==0) {
 255                                         // delete
 256                         if      (type == "node"    ) { killNode(oldID); }
 257                         else if (type == "way"     ) { killWay(oldID); }
 258                         else if (type == "relation") { killRelation(oldID); }
 259
 260                                 } else {
 261                                         // create/update
 262                         if      (type == "node"    ) { renumberNode(oldID, newID, version); getNode(newID).markClean(); }
 263                         else if (type == "way"     ) { renumberWay(oldID, newID, version); getWay(newID).markClean(); }
 264                         else if (type == "relation") { renumberRelation(oldID, newID, version); getRelation(newID).markClean(); }
 265                                 }
 266             }
 267
 268             dispatchEvent(new SaveCompleteEvent(SAVE_COMPLETED, true));
 269                         freshenActiveChangeset();
 270             markClean(); // marks the connection clean. Pressing undo from this point on leads to unexpected results
 271             MainUndoStack.getGlobalStack().breakUndo(); // so, for now, break the undo stack
 272         }
 273
 274                 private function diffUploadIOError(event:FaultEvent):void {
 275                         trace(event.fault);
 276                         dispatchEvent(new MapEvent(MapEvent.ERROR, { message: "Couldn't upload data: "+event.fault.faultString } ));
 277                         dispatchEvent(new SaveCompleteEvent(SAVE_COMPLETED, false));
 278                 }
 279
 280                 private function diffUploadAPIError(status:String, message:String):void {
 281                         var matches:Array;
 282                         switch (status) {
 283
 284                                 case '409 Conflict':
 285                                         if (message.match(/changeset/i)) { throwChangesetError(message); return; }
 286                                         matches=message.match(/mismatch.+had: (\d+) of (\w+) (\d+)/i);
 287                                         if (matches) { throwConflictError(findEntity(matches[2],matches[3]), Number(matches[1]), message); return; }
 288                                         break;
 289
 290                                 case '410 Gone':
 291                                         matches=message.match(/The (\w+) with the id (\d+)/i);
 292                                         if (matches) { throwAlreadyDeletedError(findEntity(matches[1],matches[2]), message); return; }
 293                                         break;
 294
 295                                 case '412 Precondition Failed':
 296                                         matches=message.match(/Node (\d+) is still used/i);
 297                                         if (matches) { throwInUseError(findEntity('Node',matches[1]), message); return; }
 298                                         matches=message.match(/relation (\d+) is used/i);
 299                                         if (matches) { throwInUseError(findEntity('Relation',matches[1]), message); return; }
 300                                         matches=message.match(/Way (\d+) still used/i);
 301                                         if (matches) { throwInUseError(findEntity('Way',matches[1]), message); return; }
 302                                         matches=message.match(/Cannot update (\w+) (\d+)/i);
 303                                         if (matches) { throwEntityError(findEntity(matches[1],matches[2]), message); return; }
 304                                         matches=message.match(/Relation with id (\d+)/i);
 305                                         if (matches) { throwEntityError(findEntity('Relation',matches[1]), message); return; }
 306                                         matches=message.match(/Way (\d+) requires the nodes/i);
 307                                         if (matches) { throwEntityError(findEntity('Way',matches[1]), message); return; }
 308                                         throwBugError(message); return;
 309
 310                                 case '404 Not Found':
 311                                         throwBugError(message); return;
 312
 313                                 case '400 Bad Request':
 314                                         matches=message.match(/Element (\w+)\/(\d+)/i);
 315                                         if (matches) { throwEntityError(findEntity(matches[1],matches[2]), message); return; }
 316                                         matches=message.match(/You tried to add \d+ nodes to way (\d+)/i);
 317                                         if (matches) { throwEntityError(findEntity('Way',matches[1]), message); return; }
 318                                         throwBugError(message); return;
 319                         }
 320
 321                         // Not caught, so just throw a generic server error
 322                         throwServerError(message);
 323                 }
 324
 325         private function addCreated(changeset:Changeset, getIDs:Function, get:Function, serialise:Function):XML {
 326             var create:XML = <create version="0.6"/>
 327             for each( var id:Number in getIDs() ) {
 328                 var entity:Entity = get(id);
 329                 if ( id >= 0 || entity.deleted )
 330                     continue;
 331
 332                 var xml:XML = serialise(entity);
 333                 xml.@changeset = changeset.id;
 334                 create.appendChild(xml);
 335             }
 336             return create.hasComplexContent() ? create : <!-- blank create section -->;
 337         }
 338
 339                 private function addDeleted(changeset:Changeset, getIDs:Function, get:Function, serialise:Function, ifUnused:Boolean):XML {
 340             var del:XML = <delete version="0.6"/>
 341             if (ifUnused) del.@["if-unused"] = "true";
 342             for each( var id:Number in getIDs() ) {
 343                 var entity:Entity = get(id);
 344                 // creates are already included
 345                 if ( id < 0 || !entity.deleted || entity.parentsLoaded==ifUnused)
 346                     continue;
 347
 348                 var xml:XML = serialise(entity);
 349                 xml.@changeset = changeset.id;
 350                 del.appendChild(xml);
 351             }
 352             return del.hasComplexContent() ? del : <!-- blank delete section -->;
 353                 }
 354
 355         private function addModified(changeset:Changeset, getIDs:Function, get:Function, serialise:Function):XML {
 356             var modify:XML = <modify version="0.6"/>
 357             for each( var id:Number in getIDs() ) {
 358                 var entity:Entity = get(id);
 359                 // creates and deletes are already included
 360                 if ( id < 0 || entity.deleted || !entity.isDirty )
 361                     continue;
 362
 363                 var xml:XML = serialise(entity);
 364                 xml.@changeset = changeset.id;
 365                 modify.appendChild(xml);
 366             }
 367             return modify.hasComplexContent() ? modify : <!-- blank modify section -->;
 368         }
 369
 370         private function serialiseNode(node:Node):XML {
 371             var xml:XML = serialiseEntityRoot(node); //<node/>
 372             serialiseEntityTags(node, xml);
 373             xml.@lat = node.lat;
 374             xml.@lon = node.lon;
 375             return xml;
 376         }
 377
 378         private function serialiseWay(way:Way):XML {
 379             var xml:XML = serialiseEntityRoot(way); //<node/>
 380             serialiseEntityTags(way, xml);
 381             for ( var i:uint = 0; i < way.length; i++ ) {
 382                 var nd:XML = <nd/>
 383                 nd.@ref = way.getNode(i).id;
 384                 xml.appendChild(nd);
 385             }
 386             return xml;
 387         }
 388
 389         private function serialiseRelation(relation:Relation):XML {
 390             var xml:XML = serialiseEntityRoot(relation); //<node/>
 391             serialiseEntityTags(relation, xml);
 392             for ( var i:uint = 0; i < relation.length; i++ ) {
 393                 var relMember:RelationMember = relation.getMember(i);
 394                 var member:XML = <member/>
 395                 member.@ref = relMember.entity.id;
 396                 member.@type = relMember.entity.getType();
 397                 member.@role = relMember.role;
 398                 xml.appendChild(member);
 399             }
 400             return xml;
 401         }
 402
 403                 private function serialiseEntityRoot(entity:Object):XML {
 404                         var xml:XML;
 405                         if      (entity is Way     ) { xml = <way/> }
 406                         else if (entity is Node    ) { xml = <node/> }
 407                         else if (entity is Relation) { xml = <relation/> }
 408                         xml.@id = entity.id;
 409                         xml.@version = entity.version;
 410                         return xml;
 411                 }
 412
 413         private function serialiseEntityTags(entity:Entity, xml:XML):void {
 414             xml.@id = entity.id;
 415             xml.@version = entity.version;
 416             for each( var tag:Tag in entity.getTagArray() ) {
 417               if (tag.key == 'created_by') {
 418                 entity.setTag('created_by', null, MainUndoStack.getGlobalStack().addAction);
 419                 continue;
 420               }
 421               var tagXML:XML = <tag/>
 422               tagXML.@k = tag.key;
 423               tagXML.@v = tag.value;
 424               xml.appendChild(tagXML);
 425             }
 426         }
 427
 428         override public function fetchUserTraces(refresh:Boolean=false):void {
 429             if (traces_loaded && !refresh) {
 430               dispatchEvent(new Event(TRACES_LOADED));
 431             } else {
 432               sendOAuthGet(apiBaseURL+"user/gpx_files", tracesLoadComplete, errorOnMapLoad, mapLoadStatus); //needs error handlers
 433               dispatchEvent(new Event(LOAD_STARTED)); //specific to map or reusable?
 434             }
 435         }
 436
 437         private function tracesLoadComplete(event:Event):void {
 438             clearTraces();
 439             var files:XML = new XML(URLLoader(event.target).data);
 440             for each(var traceData:XML in files.gpx_file) {
 441               var t:Trace = new Trace(this).fromXML(traceData);
 442               addTrace(t);
 443             }
 444             traces_loaded = true;
 445             dispatchEvent(new Event(LOAD_COMPLETED));
 446             dispatchEvent(new Event(TRACES_LOADED));
 447         }
 448
 449         override public function fetchTrace(id:Number, callback:Function):void {
 450             sendOAuthGet(apiBaseURL+"gpx/"+id+"/data.xml",
 451                                 function(e:Event):void {
 452                         dispatchEvent(new Event(LOAD_COMPLETED));
 453                                         callback(e);
 454                                 }, errorOnMapLoad, mapLoadStatus); // needs error handlers
 455             dispatchEvent(new Event(LOAD_STARTED)); //specifc to map or reusable?
 456         }
 457         }
 458 }