Ticket #696: ticket696.patch

File ticket696.patch, 9.9 KB (added by MartinBudden, 4 years ago)

  • js/Story.js

     
    153153//#   tiddlerElem - reference to the element that will contain the tiddler 
    154154Story.prototype.loadMissingTiddler = function(title,fields,tiddlerElem) 
    155155{ 
     156        var getTiddlerCallback = function(context) 
     157        { 
     158                var tiddler = context.tiddler; 
     159                if(tiddler && tiddler.text) { 
     160                        if(!tiddler.created) 
     161                                tiddler.created = new Date(); 
     162                        if(!tiddler.modified) 
     163                                tiddler.modified = tiddler.created; 
     164                        store.saveTiddler(tiddler.title,tiddler.title,tiddler.text,tiddler.modifier,tiddler.modified,tiddler.tags,tiddler.fields,true,tiddler.created); 
     165                        autoSaveChanges(); 
     166                } 
     167                context.adaptor.close(); 
     168                delete context.adpator; 
     169        }; 
     170 
    156171        var tiddler = new Tiddler(title); 
    157         tiddler.fields = typeof fields == "string" ? fields.decodeHashMap() : (fields || {}); 
    158         var serverType = tiddler.getServerType(); 
    159         var host = tiddler.fields['server.host']; 
    160         var workspace = tiddler.fields['server.workspace']; 
    161         if(!serverType || !host) 
    162                 return null; 
    163         var sm = new SyncMachine(serverType,{ 
    164                         start: function() { 
    165                                 return this.openHost(host,"openWorkspace"); 
    166                         }, 
    167                         openWorkspace: function() { 
    168                                 return this.openWorkspace(workspace,"getTiddler"); 
    169                         }, 
    170                         getTiddler: function() { 
    171                                 return this.getTiddler(title,"onGetTiddler"); 
    172                         }, 
    173                         onGetTiddler: function(context) { 
    174                                 var tiddler = context.tiddler; 
    175                                 if(tiddler && tiddler.text) { 
    176                                         var downloaded = new Date(); 
    177                                         if(!tiddler.created) 
    178                                                 tiddler.created = downloaded; 
    179                                         if(!tiddler.modified) 
    180                                                 tiddler.modified = tiddler.created; 
    181                                         store.saveTiddler(tiddler.title,tiddler.title,tiddler.text,tiddler.modifier,tiddler.modified,tiddler.tags,tiddler.fields,true,tiddler.created); 
    182                                         autoSaveChanges(); 
    183                                 } 
    184                                 delete this; 
    185                                 return true; 
    186                         }, 
    187                         error: function(message) { 
    188                                 displayMessage("Error loading missing tiddler from %0: %1".format([host,message])); 
    189                         } 
    190                 }); 
    191         sm.go(); 
    192         return config.messages.loadingMissingTiddler.format([title,serverType,host,workspace]); 
     172        tiddler.fields = typeof fields == "string" ?  fields.decodeHashMap() : (fields ? fields : {}); 
     173        context = {}; 
     174        context.serverType = tiddler.getServerType(); 
     175        if(!context.serverType) 
     176                return; 
     177        context.host = tiddler.fields['server.host']; 
     178        context.workspace = tiddler.fields['server.workspace']; 
     179        var adaptor = new config.adaptors[context.serverType]; 
     180        adaptor.getTiddler(title,context,null,getTiddlerCallback); 
     181        return config.messages.loadingMissingTiddler.format([title,context.serverType,context.host,context.workspace]); 
    193182}; 
    194183 
    195184//# Overridable for choosing the name of the template to apply for a tiddler 

  • js/Sync.js

     
    5252                syncItem.serverType = tiddler.getServerType(); 
    5353                syncItem.serverHost = tiddler.fields['server.host']; 
    5454                if(syncItem.serverType && syncItem.serverHost) { 
     55                        syncItem.adaptor = new config.adaptors[syncItem.serverType]; 
    5556                        syncItem.serverWorkspace = tiddler.fields['server.workspace']; 
    5657                        syncItem.tiddler = tiddler; 
    5758                        syncItem.title = tiddler.title; 
    … …  
    7071{ 
    7172        for(var i=0; i<syncList.length; i++) { 
    7273                var si = syncList[i]; 
    73                 si.serverUrl = si.syncTask.syncMachine.generateTiddlerInfo(si.tiddler).uri; 
     74                si.serverUrl = si.adaptor.generateTiddlerInfo(si.tiddler).uri; 
    7475        } 
    7576}; 
    7677 
    … …  
    112113        st.serverHost = syncItem.serverHost; 
    113114        st.serverWorkspace = syncItem.serverWorkspace; 
    114115        st.syncItems = [syncItem]; 
    115         st.syncMachine = new SyncMachine(st.serverType,{ 
    116                 start: function() { 
    117                         return this.openHost(st.serverHost,"openWorkspace"); 
    118                 }, 
    119                 openWorkspace: function() { 
    120                         return this.openWorkspace(st.serverWorkspace,"getTiddlerList"); 
    121                 }, 
    122                 getTiddlerList: function() { 
    123                         return this.getTiddlerList("onGetTiddlerList"); 
    124                 }, 
    125                 onGetTiddlerList: function(context) { 
    126                         var tiddlers = context.tiddlers; 
    127                         for(var i=0; i<st.syncItems.length; i++) { 
    128                                 var si = st.syncItems[i]; 
    129                                 var f = tiddlers.findByField("title",si.title); 
    130                                 if(f !== null) { 
    131                                         if(tiddlers[f].fields['server.page.revision'] > si.tiddler.fields['server.page.revision']) { 
    132                                                 si.syncStatus = config.macros.sync.syncStatusList[si.isTouched ? 'changedBoth' : 'changedServer']; 
    133                                         } 
    134                                 } else { 
    135                                         si.syncStatus = config.macros.sync.syncStatusList.notFound; 
     116 
     117        var openWorkspaceCallback = function(context,syncItems) { 
     118                if(context.status) { 
     119                        context.adaptor.getTiddlerList(context,syncItems,getTiddlerListCallback); 
     120                        return true; 
     121                } 
     122                displayMessage(context.statusText); 
     123                return false; 
     124        }; 
     125 
     126        var getTiddlerListCallback = function(context,sycnItems) { 
     127                if(!context.status) { 
     128                        displayMessage(context.statusText); 
     129                        return false; 
     130                } 
     131                syncItems = context.userParams; 
     132                var tiddlers = context.tiddlers; 
     133                for(var i=0; i<syncItems.length; i++) { 
     134                        var si = syncItems[i]; 
     135                        var f = tiddlers.findByField("title",si.title); 
     136                        if(f !== null) { 
     137                                if(tiddlers[f].fields['server.page.revision'] > si.tiddler.fields['server.page.revision']) { 
     138                                        si.syncStatus = config.macros.sync.syncStatusList[si.isTouched ? 'changedBoth' : 'changedServer']; 
    136139                                } 
    137                                 config.macros.sync.updateSyncStatus(si); 
     140                        } else { 
     141                                si.syncStatus = config.macros.sync.syncStatusList.notFound; 
    138142                        } 
    139                 }, 
    140                 getTiddler: function(title) { 
    141                         return this.getTiddler(title,"onGetTiddler"); 
    142                 }, 
    143                 onGetTiddler: function(context) { 
    144                         var tiddler = context.tiddler; 
    145                         var syncItem = st.syncItems.findByField("title",tiddler.title); 
    146                         if(syncItem !== null) { 
    147                                 syncItem = st.syncItems[syncItem]; 
    148                                 store.saveTiddler(tiddler.title, tiddler.title, tiddler.text, tiddler.modifier, tiddler.modified, tiddler.tags, tiddler.fields, true, tiddler.created); 
    149                                 syncItem.syncStatus = config.macros.sync.syncStatusList.gotFromServer; 
    150                                 config.macros.sync.updateSyncStatus(syncItem); 
    151                         } 
    152                 }, 
    153                 putTiddler: function(tiddler) { 
    154                         return this.putTiddler(tiddler,"onPutTiddler"); 
    155                 }, 
    156                 onPutTiddler: function(context) { 
    157                         var title = context.title; 
    158                         var syncItem = st.syncItems.findByField("title",title); 
    159                         if(syncItem !== null) { 
    160                                 syncItem = st.syncItems[syncItem]; 
    161                                 store.resetTiddler(title); 
    162                                 if(context.status) { 
    163                                         syncItem.syncStatus = config.macros.sync.syncStatusList.putToServer; 
    164                                         config.macros.sync.updateSyncStatus(syncItem); 
    165                                 } 
    166                         } 
     143                        config.macros.sync.updateSyncStatus(si); 
    167144                } 
    168         }); 
    169         st.syncMachine.go(); 
     145        }; 
     146        var context = {host:st.serverHost,workspace:st.serverWorkspace}; 
     147        syncItem.adaptor.openHost(st.serverHost); 
     148        syncItem.adaptor.openWorkspace(st.serverWorkspace,context,st.syncItems,openWorkspaceCallback); 
    170149        return st; 
    171150}; 
    172151 
    … …  
    181160 
    182161config.macros.sync.doSync = function(e) 
    183162{ 
     163        var getTiddlerCallback = function(context,syncItem) { 
     164                if(syncItem) { 
     165                        var tiddler = context.tiddler; 
     166                        store.saveTiddler(tiddler.title,tiddler.title,tiddler.text,tiddler.modifier,tiddler.modified,tiddler.tags,tiddler.fields,true,tiddler.created); 
     167                        syncItem.syncStatus = config.macros.sync.syncStatusList.gotFromServer; 
     168                        config.macros.sync.updateSyncStatus(syncItem); 
     169                } 
     170        }; 
     171        var putTiddlerCallback = function(context,syncItem) { 
     172                if(syncItem) { 
     173                        store.resetTiddler(context.title); 
     174                        syncItem.syncStatus = config.macros.sync.syncStatusList.putToServer; 
     175                        config.macros.sync.updateSyncStatus(syncItem); 
     176                } 
     177        }; 
     178 
    184179        var rowNames = ListView.getSelectedRows(currSync.listView); 
    185180        var sl = config.macros.sync.syncStatusList; 
    186181        for(var i=0; i<currSync.syncList.length; i++) { 
    … …  
    189184                        var r = true; 
    190185                        switch(si.syncStatus) { 
    191186                        case sl.changedServer: 
    192                                 r = si.syncTask.syncMachine.go("getTiddler",si.title); 
     187                                r = si.adaptor.getTiddler(syncItem.title,null,si,getTiddlerCallback); 
    193188                                break; 
    194189                        case sl.notFound: 
    195190                        case sl.changedLocally: 
    196191                        case sl.changedBoth: 
    197                                 r = si.syncTask.syncMachine.go("putTiddler",si.tiddler); 
     192                                r = si.adaptor.putTiddler(si.tiddler,null,si,putTiddlerCallback); 
    198193                                break; 
    199194                        default: 
    200195                                break; 
    … …  
    205200        } 
    206201        return false; 
    207202}; 
    208  
    209 function SyncMachine(serverType,steps) 
    210 { 
    211         this.serverType = serverType; 
    212         this.adaptor = new config.adaptors[serverType](); 
    213         this.steps = steps; 
    214 } 
    215  
    216 SyncMachine.prototype.go = function(step,context) 
    217 { 
    218         var r = context ? context.status : null; 
    219         if(typeof r == "string") { 
    220                 this.invokeError(r); 
    221                 return r; 
    222         } 
    223         var h = this.steps[step ? step : "start"]; 
    224         if(!h) 
    225                 return null; 
    226         r = h.call(this,context); 
    227         if(typeof r == "string") 
    228                 this.invokeError(r); 
    229         return r; 
    230 }; 
    231  
    232 SyncMachine.prototype.invokeError = function(message) 
    233 { 
    234         if(this.steps.error) 
    235                 this.steps.error(message); 
    236 }; 
    237  
    238 SyncMachine.prototype.openHost = function(host,nextStep) 
    239 { 
    240         var me = this; 
    241         return me.adaptor.openHost(host,null,null,function(context) {me.go(nextStep,context);}); 
    242 }; 
    243  
    244 SyncMachine.prototype.getWorkspaceList = function(nextStep) 
    245 { 
    246         var me = this; 
    247         return me.adaptor.getWorkspaceList(null,null,function(context) {me.go(nextStep,context);}); 
    248 }; 
    249  
    250 SyncMachine.prototype.openWorkspace = function(workspace,nextStep) 
    251 { 
    252         var me = this; 
    253         return me.adaptor.openWorkspace(workspace,null,null,function(context) {me.go(nextStep,context);}); 
    254 }; 
    255  
    256 SyncMachine.prototype.getTiddlerList = function(nextStep) 
    257 { 
    258         var me = this; 
    259         return me.adaptor.getTiddlerList(null,null,function(context) {me.go(nextStep,context);}); 
    260 }; 
    261  
    262 SyncMachine.prototype.generateTiddlerInfo = function(tiddler) 
    263 { 
    264         return this.adaptor.generateTiddlerInfo(tiddler); 
    265 }; 
    266  
    267 SyncMachine.prototype.getTiddler = function(title,nextStep) 
    268 { 
    269         var me = this; 
    270         return me.adaptor.getTiddler(title,null,null,function(context) {me.go(nextStep,context);}); 
    271 }; 
    272  
    273 SyncMachine.prototype.putTiddler = function(tiddler,nextStep) 
    274 { 
    275         var me = this; 
    276         return me.adaptor.putTiddler(tiddler,null,null,function(context) {me.go(nextStep,context);}); 
    277 }; 
    278