This is just some static backup of the original site, don't expect every link to work!

source: modules/vI_rdfDatasource.js @ 3aa877

ng_0.9
Last change on this file since 3aa877 was 3aa877, checked in by rene <rene@…>, 9 years ago

fix for ​https://hg.mozilla.org/comm-central/rev/fab9e5145cd4
  • Property mode set to 100644
File size: 56.7 KB
Line 
1/* ***** BEGIN LICENSE BLOCK *****
2    This program is free software; you can redistribute it and/or modify
3    it under the terms of the GNU General Public License as published by
4    the Free Software Foundation; either version 2 of the License, or
5    (at your option) any later version.
6
7    This program is distributed in the hope that it will be useful,
8    but WITHOUT ANY WARRANTY; without even the implied warranty of
9    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10    GNU General Public License for more details.
11
12    You should have received a copy of the GNU General Public License
13    along with this program; if not, write to the Free Software
14    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
15
16    The Original Code is the Virtual Identity Extension.
17
18    The Initial Developer of the Original Code is Rene Ejury.
19    Portions created by the Initial Developer are Copyright (C) 2007
20    the Initial Developer. All Rights Reserved.
21
22    Contributor(s):
23 * ***** END LICENSE BLOCK ***** */
24
25var EXPORTED_SYMBOLS = ["rdfDatasource", "rdfDatasourceAccess", "rdfDatasourceImporter"]
26
27Components.utils.import("resource://v_identity/vI_log.js");
28let Log = setupLogging("virtualIdentity.rdfDatasource");
29
30Components.utils.import("resource://v_identity/vI_accountUtils.js");
31Components.utils.import("resource://v_identity/vI_prefs.js");
32Components.utils.import("resource://v_identity/vI_identityData.js");
33Components.utils.import("resource://gre/modules/Services.jsm");
34
35// if no 3pane-window found, return current window
36function get3PaneWindow() {
37  var windowMediator = Components.classes['@mozilla.org/appshell/window-mediator;1']
38    .getService(Components.interfaces.nsIWindowMediator);
39  var mail3paneWindow = windowMediator.getMostRecentWindow("mail:3pane");
40  if (!mail3paneWindow) return windowMediator.getMostRecentWindow(null);
41  return mail3paneWindow;
42};
43
44function rdfDatasource(rdfFileName, dontRegisterObserver) {
45    this._rdfFileName = rdfFileName;
46    if (this._rdfFileName) this.init();
47    if (!dontRegisterObserver) this.AccountManagerObserver.register();
48    try {
49      this._extVersion = get3PaneWindow().virtualIdentityExtension.extensionVersion;
50    } catch (e) { }
51}
52
53rdfDatasource.prototype = {
54    _extVersion :       null,
55    _rdfVersion :       "0.0.5",
56    _rdfService :       Components.classes["@mozilla.org/rdf/rdf-service;1"]
57                            .getService(Components.interfaces.nsIRDFService),
58    _rdfDataSource :    null,
59    _rdfFileName :      null,
60    _rdfNS :            "http://virtual-id.absorb.it/",
61    _rdfNSStorage :     "vIStorage",
62    _rdfNSEmail :       "vIStorage/email",
63    _rdfNSMaillist :    "vIStorage/maillist",
64    _rdfNSNewsgroup :   "vIStorage/newsgroup",
65    _rdfNSFilter :      "vIStorage/filter",
66    _rdfNSAccounts :    "vIAccounts",
67    _rdfNSIdentities :  "vIAccounts/id",
68    _rdfNSSMTPservers : "vIAccounts/smtp",
69   
70    _virtualIdentityID : "{dddd428e-5ac8-4a81-9f78-276c734f75b8}",
71   
72    _emailContainer : Components.classes["@mozilla.org/rdf/container;1"]
73            .createInstance(Components.interfaces.nsIRDFContainer),
74
75    _maillistContainer : Components.classes["@mozilla.org/rdf/container;1"]
76            .createInstance(Components.interfaces.nsIRDFContainer),
77
78    _newsgroupContainer : Components.classes["@mozilla.org/rdf/container;1"]
79            .createInstance(Components.interfaces.nsIRDFContainer),
80
81    _filterContainer : Components.classes["@mozilla.org/rdf/container;1"]
82            .createInstance(Components.interfaces.nsIRDFContainer),
83
84    _identityContainer : Components.classes["@mozilla.org/rdf/container;1"]
85            .createInstance(Components.interfaces.nsIRDFContainer),
86
87    _smtpContainer : Components.classes["@mozilla.org/rdf/container;1"]
88            .createInstance(Components.interfaces.nsIRDFContainer),
89   
90    getContainer : function (type) {
91        switch (type) {
92            case "email": return this._emailContainer;
93            case "maillist": return this._maillistContainer;
94            case "newsgroup": return this._newsgroupContainer;
95            case "filter": return this._filterContainer;
96            case "identity": return this._identityContainer;
97            case "smtp": return this._smtpContainer;
98        }
99        return null;
100    },
101
102    init: function() {
103//         Log.debug("init.");
104
105        this._openRdfDataSource();
106        if (!this._rdfDataSource) return;
107        this._initContainers();
108        if (this.rdfUpgradeRequired()) this.rdfUpgrade();
109       
110        // store version everytime to recognize downgrades later
111        this.storeRDFVersion();
112           
113//         this.refreshAccountInfo();
114//         Log.debug("init done.");
115    },
116   
117    _openRdfDataSource: function() {
118//         if (!this._rdfFileName || this._rdfDataSource);
119        var protoHandler = Components.classes["@mozilla.org/network/protocol;1?name=file"]
120            .getService(Components.interfaces.nsIFileProtocolHandler)
121        var newFile = Components.classes["@mozilla.org/file/local;1"]
122                    .createInstance(Components.interfaces.nsILocalFile);
123       
124        var file = Components.classes["@mozilla.org/file/directory_service;1"]
125            .getService(Components.interfaces.nsIProperties)
126            .get("ProfD", Components.interfaces.nsIFile);
127        var delimiter = (file.path.match(/\\/))?"\\":"/";
128
129        newFile.initWithPath(file.path + delimiter + this._rdfFileName);
130        var fileURI = protoHandler.newFileURI(newFile);
131
132        Log.debug("init: read rdf from '" + fileURI.spec + "'");
133
134        this._rdfDataSource =
135            this._rdfService.GetDataSourceBlocking(fileURI.spec);
136           
137//         Log.debug("read rdf from '" + fileURI.spec + "' done." + this._rdfService);
138    },
139   
140    _initContainers: function() {
141        try {   // will possibly fail before upgrade
142            var storageRes = this._rdfService
143                .GetResource(this._rdfNS + this._rdfNSEmail);
144            this._emailContainer.Init(this._rdfDataSource, storageRes);
145            storageRes = this._rdfService
146                .GetResource(this._rdfNS + this._rdfNSMaillist);
147            this._maillistContainer.Init(this._rdfDataSource, storageRes);
148            storageRes = this._rdfService
149                .GetResource(this._rdfNS + this._rdfNSNewsgroup);
150            this._newsgroupContainer.Init(this._rdfDataSource, storageRes);
151            storageRes = this._rdfService
152                .GetResource(this._rdfNS + this._rdfNSFilter);
153            this._filterContainer.Init(this._rdfDataSource, storageRes);
154            storageRes = this._rdfService
155                .GetResource(this._rdfNS + this._rdfNSIdentities);
156            this._identityContainer.Init(this._rdfDataSource, storageRes);
157            storageRes = this._rdfService
158                .GetResource(this._rdfNS + this._rdfNSSMTPservers);
159            this._smtpContainer.Init(this._rdfDataSource, storageRes);
160        } catch (e) { };
161    },
162
163    // ******************************************************************************************
164    // **************    BEGIN RDF UPGRADE CODE    **********************************************
165    rdfUpgradeRequired: function() {
166        var oldRdfVersion = this.getCurrentRDFFileVersion();
167        var versionChecker = Components.classes["@mozilla.org/xpcom/version-comparator;1"]
168            .getService(Components.interfaces.nsIVersionComparator);
169        return (!oldRdfVersion || versionChecker.compare(oldRdfVersion, this._rdfVersion) < 0)
170    },
171    // **************    RDF UPGRADE CODE    ****************************************************
172    extUpgradeRequired: function() {
173        if (!this._extVersion) return false;
174        var oldExtVersion = this.getCurrentExtFileVersion()
175        var versionChecker = Components.classes["@mozilla.org/xpcom/version-comparator;1"]
176            .getService(Components.interfaces.nsIVersionComparator);
177        return (!oldExtVersion || versionChecker.compare(oldExtVersion, this._extVersion) < 0) 
178    },
179    // **************    RDF UPGRADE CODE    ****************************************************
180    rdfUpgrade : function() {
181        var currentVersion = this.getCurrentRDFFileVersion();
182        Log.debug("checking for previous version of rdf, found " + 
183            currentVersion + " - rdf-upgrade required.")
184        switch (currentVersion) {
185            case null:
186            case "0.0.1":
187            case "0.0.2":
188                this._createRDFContainers(); // no break
189            case "0.0.3":
190                this._tagDefaultSMTP();
191            case "0.0.4":
192            default:
193                this._createAccountInfoContainers();
194        }
195        this.storeRDFVersion();
196        Log.debug("rdf-upgrade to " + this.getCurrentRDFFileVersion() + " done.");
197    },
198    // **************    RDF UPGRADE CODE    ****************************************************
199    // only used for upgrade to 0.0.3 - loop through all ressources.
200    _transferAllResources : function () {
201        Log.debug("upgrade: transferAllResources");
202        var enumerator = this._rdfDataSource.GetAllResources();
203        while (enumerator && enumerator.hasMoreElements()) {
204            var resource = enumerator.getNext();
205            resource.QueryInterface(Components.interfaces.nsIRDFResource);
206           
207            var type; var name;
208            if (resource.ValueUTF8.match(new RegExp(this._rdfNS + this._rdfNSEmail + "/", "i")))
209                { type = "email"; name = RegExp.rightContext }
210            else if (resource.ValueUTF8.match(new RegExp(this._rdfNS + this._rdfNSNewsgroup + "/", "i")))
211                { type = "newsgroup"; name = RegExp.rightContext }
212            else if (resource.ValueUTF8.match(new RegExp(this._rdfNS + this._rdfNSMaillist + "/", "i")))
213                { type = "maillist"; name = RegExp.rightContext }
214            else continue;
215           
216            var container = this.getContainer(type);
217            this._setRDFValue(resource, "name", name);
218           
219            if (container.IndexOf(resource) == -1) container.AppendElement(resource);
220        }
221    },
222    // **************    RDF UPGRADE CODE    ****************************************************
223    _tagDefaultSMTP: function() {
224        Log.debug("upgrade: tagDefaultSMTP");
225        for each (let treeType in Array("email", "maillist", "newsgroup", "filter")) {
226            var enumerator = this.getContainer(treeType).GetElements();
227            while (enumerator && enumerator.hasMoreElements()) {
228                var resource = enumerator.getNext();
229                resource.QueryInterface(Components.interfaces.nsIRDFResource);
230                var smtp = this._getRDFValue(resource, "smtp")
231                if (!smtp || smtp == "") this._setRDFValue(resource, "smtp", DEFAULT_SMTP_TAG);
232            }
233        }
234    },
235    // **************    RDF UPGRADE CODE    ****************************************************
236    _createAccountInfoContainers: function() {
237        Log.debug("upgrade: createAccountInfoContainers");
238        var rdfContainerUtils = Components.classes["@mozilla.org/rdf/container-utils;1"].
239            getService(Components.interfaces.nsIRDFContainerUtils);
240       
241        var accountRes = this._rdfService
242            .GetResource(this._rdfNS + this._rdfNSAccounts);
243        var identityRes = this._rdfService
244            .GetResource(this._rdfNS + this._rdfNSIdentities);
245        var smtpRes = this._rdfService
246            .GetResource(this._rdfNS + this._rdfNSSMTPservers);
247        this._setRDFValue(accountRes, "name", "Accounts");
248        this._setRDFValue(identityRes, "name", "Identities");
249        this._setRDFValue(smtpRes, "name", "SMTP-Server");
250       
251        rdfContainerUtils.MakeBag(this._rdfDataSource, accountRes);
252        rdfContainerUtils.MakeBag(this._rdfDataSource, identityRes);
253        rdfContainerUtils.MakeBag(this._rdfDataSource, smtpRes);
254
255        var accountContainer = Components.classes["@mozilla.org/rdf/container;1"].
256            createInstance(Components.interfaces.nsIRDFContainer);
257       
258        // initialize container with accountRes
259        accountContainer.Init(this._rdfDataSource, accountRes);
260        // append all new containers to accountRes
261        if (accountContainer.IndexOf(identityRes) == -1) accountContainer.AppendElement(identityRes);
262        if (accountContainer.IndexOf(smtpRes) == -1) accountContainer.AppendElement(smtpRes);
263       
264        this._initContainers();
265        this.refreshAccountInfo();
266    },
267    // **************    RDF UPGRADE CODE    ****************************************************
268    _createRDFContainers: function() {
269        Log.debug("upgrade: createRDFContainers");
270        var rdfContainerUtils = Components.classes["@mozilla.org/rdf/container-utils;1"].
271            getService(Components.interfaces.nsIRDFContainerUtils);
272
273        var storageRes = this._rdfService
274            .GetResource(this._rdfNS + this._rdfNSStorage);
275        var emailRes = this._rdfService
276            .GetResource(this._rdfNS + this._rdfNSEmail);
277        var maillistRes = this._rdfService
278            .GetResource(this._rdfNS + this._rdfNSMaillist);
279        var newsgroupRes = this._rdfService
280            .GetResource(this._rdfNS + this._rdfNSNewsgroup);
281        var filterRes = this._rdfService
282            .GetResource(this._rdfNS + this._rdfNSFilter);
283        this._setRDFValue(emailRes, "name", "E-Mail");
284        this._setRDFValue(maillistRes, "name", "Mailing-List");
285        this._setRDFValue(newsgroupRes, "name", "Newsgroup");
286        this._setRDFValue(filterRes, "name", "Filter");
287
288        rdfContainerUtils.MakeBag(this._rdfDataSource, storageRes);
289        rdfContainerUtils.MakeBag(this._rdfDataSource, emailRes);
290        rdfContainerUtils.MakeBag(this._rdfDataSource, maillistRes);
291        rdfContainerUtils.MakeBag(this._rdfDataSource, newsgroupRes);
292        // use a sequence for the filters, order does matter
293        rdfContainerUtils.MakeSeq(this._rdfDataSource, filterRes);
294       
295        var container = Components.classes["@mozilla.org/rdf/container;1"].
296            createInstance(Components.interfaces.nsIRDFContainer);
297       
298        // initialize container with storageRes
299        container.Init(this._rdfDataSource, storageRes);
300        // append all new containers to storageRes
301        if (container.IndexOf(emailRes) == -1) container.AppendElement(emailRes);
302        if (container.IndexOf(maillistRes) == -1) container.AppendElement(maillistRes);
303        if (container.IndexOf(newsgroupRes) == -1) container.AppendElement(newsgroupRes);
304        if (container.IndexOf(filterRes) == -1) container.AppendElement(filterRes);
305       
306        this._initContainers();
307       
308        this._transferAllResources();
309    },
310    // **************    END RDF UPGRADE CODE    ************************************************
311    // ******************************************************************************************
312       
313    getCurrentRDFFileVersion: function() {
314        return this._getRDFValue(
315            this._rdfService.GetResource(this._rdfNS + "virtualIdentity"), "rdfVersion");
316    },
317   
318    getCurrentExtFileVersion: function() {
319        return this._getRDFValue(
320            this._rdfService.GetResource(this._rdfNS + "virtualIdentity"), "version");
321    },
322   
323    storeRDFVersion: function() {
324        this._setRDFValue(
325            this._rdfService.GetResource(this._rdfNS + "virtualIdentity"), "rdfVersion",
326            this._rdfVersion);
327        this._flush();
328    },
329   
330    storeExtVersion: function() {
331        this._setRDFValue(
332            this._rdfService.GetResource(this._rdfNS + "virtualIdentity"), "version", this._extVersion)
333        this._flush();
334    },
335
336    clean : function() {
337        this.AccountManagerObserver.unregister();
338        this._flush();
339    },
340
341    _flush : function() {
342        this._rdfDataSource.QueryInterface(Components.interfaces.nsIRDFRemoteDataSource);
343        this._rdfDataSource.Flush();
344    },
345   
346    refreshAccountInfo : function() {
347        try {   // will possibly fail before upgrade
348            this.cleanAccountInfo(); this.storeAccountInfo();
349        } catch (e) {};
350    },
351   
352    cleanAccountInfo : function() {
353        Log.debug("cleanAccountInfo");
354       
355        var enumerator = this._identityContainer.GetElements();
356        while (enumerator && enumerator.hasMoreElements()) {
357            var resource = enumerator.getNext();
358            resource.QueryInterface(Components.interfaces.nsIRDFResource);
359            this._unsetRDFValue(resource, "identityName", this._getRDFValue(resource, "identityName"))
360            this._unsetRDFValue(resource, "fullName", this._getRDFValue(resource, "fullName"))
361            this._unsetRDFValue(resource, "email", this._getRDFValue(resource, "email"))
362            this._identityContainer.RemoveElement(resource, false);
363        }
364
365        enumerator = this._smtpContainer.GetElements();
366        while (enumerator && enumerator.hasMoreElements()) {
367            var resource = enumerator.getNext();
368            resource.QueryInterface(Components.interfaces.nsIRDFResource);
369            this._unsetRDFValue(resource, "label", this._getRDFValue(resource, "label"))
370            this._unsetRDFValue(resource, "hostname", this._getRDFValue(resource, "hostname"))
371            this._unsetRDFValue(resource, "username", this._getRDFValue(resource, "username"))
372            this._smtpContainer.RemoveElement(resource, false);
373        }   
374    },
375   
376    getRelevantIDs : function() {
377        var relevantIDs = new Object();
378        // search relevant Identities
379        for each (let treeType in Array("email", "maillist", "newsgroup", "filter")) {
380            var enumerator = this.getContainer(treeType).GetElements();
381            while (enumerator && enumerator.hasMoreElements()) {
382                var resource = enumerator.getNext();
383                resource.QueryInterface(Components.interfaces.nsIRDFResource);
384                var id = this._getRDFValue(resource, "id")
385                if (id) {
386                    if (!relevantIDs[id]) relevantIDs[id] = 1; else relevantIDs[id] += 1;
387                }
388            }
389        }
390        return relevantIDs;
391    },
392   
393    searchIdentityMismatch : function() {
394        Log.debug("searchIdentityMismatch");
395
396        var relevantIDs = this.getRelevantIDs();
397        var mismatchIDs = [];
398       
399        for (var id in relevantIDs) {
400            var found = false;
401            var accounts = getAccountsArray();
402            for (let acc = 0; acc < accounts.length; acc++) {
403                let account = accounts[acc];
404                let identities = getIdentitiesArray(account);
405                for (let i = 0; i < identities.length; i++) {
406                    let identity = identities[i];
407                    if (id == identity.key) { found = true; break; }
408                }
409                if (found) break;
410            }
411            var resource = this._rdfService.GetResource(this._rdfNS + this._rdfNSIdentities + "/" + id);
412            var rdfIdentityName = this._getRDFValue(resource, "identityName");
413            var rdfEmail = this._getRDFValue(resource, "email");
414            var rdfFullName = this._getRDFValue(resource, "fullName")
415           
416            if ( !found || rdfIdentityName != identity.identityName && rdfEmail != identity.email)
417            mismatchIDs.push( { oldkey: id, label : rdfIdentityName, ext1: rdfEmail, ext2: rdfFullName, count: relevantIDs[id], key: "" } )
418        }
419        if (mismatchIDs.length > 0) {
420            Log.debug(" found mismatches on id(s).");
421            get3PaneWindow().openDialog("chrome://v_identity/content/vI_rdfAccountMismatchDialog.xul",0,
422                    "chrome, dialog, modal, alwaysRaised, resizable=yes", "identity", mismatchIDs,
423                    /* callback chance: */ this).focus();
424            return true;
425        }
426        else {
427            Log.debug(" found no mismatch");
428            return false;
429        }
430    },
431   
432    repairAccountMismatch : function(type, mismatchItems) {
433        var keyField = (type == "identity")?"id":"smtp" // field to change is 'id' or 'smtp' dependent on type
434        for (var i = 0; i < mismatchItems.length; i++) {
435            Log.debug("repairAccountMismatch change " + mismatchItems[i].oldkey + " into " + mismatchItems[i].key);
436            // search relevant Identities
437            for each (let treeType in Array("email", "maillist", "newsgroup", "filter")) {
438                var enumerator = this.getContainer(treeType).GetElements();
439                while (enumerator && enumerator.hasMoreElements()) {
440                    var resource = enumerator.getNext();
441                    resource.QueryInterface(Components.interfaces.nsIRDFResource);
442                    if (this._getRDFValue(resource, keyField) == mismatchItems[i].oldkey) {
443                        if (mismatchItems[i].key == "") this._unsetRDFValue(resource, keyField, mismatchItems[i].oldkey)
444                        else this._setRDFValue(resource, keyField, mismatchItems[i].key)
445                    }
446                }
447            }
448        }
449    },
450   
451    getRelevantSMTPs : function() {
452        var relevantSMTPs = new Object();
453        // search relevant SMTPs
454        for each (let treeType in Array("email", "maillist", "newsgroup", "filter")) {
455            var enumerator = this.getContainer(treeType).GetElements();
456            while (enumerator && enumerator.hasMoreElements()) {
457                var resource = enumerator.getNext();
458                resource.QueryInterface(Components.interfaces.nsIRDFResource);
459                var smtp = this._getRDFValue(resource, "smtp")
460                if (smtp && smtp != DEFAULT_SMTP_TAG) {
461                    if (!relevantSMTPs[smtp]) relevantSMTPs[smtp] = 1; else relevantSMTPs[smtp] += 1;
462                }
463            }
464        }
465        return relevantSMTPs;
466    },
467   
468    searchSmtpMismatch : function() {
469        Log.debug("searchSmtpMismatch");
470
471        var relevantSMTPs = this.getRelevantSMTPs();
472        var mismatchSMTPs = [];
473       
474        for (var smtp in relevantSMTPs) {
475            var servers, smtpService = Components.classes["@mozilla.org/messengercompose/smtp;1"]
476                .getService(Components.interfaces.nsISmtpService);
477            // check for new https://hg.mozilla.org/comm-central/rev/fab9e5145cd4 smtpService
478            if (typeof(smtpService.servers) == "object") servers = smtpService.servers;
479            else servers = smtpService.smtpServers;
480
481            var found = false;
482            while (servers && servers.hasMoreElements()) {
483                var server = servers.getNext();
484                if (server instanceof Components.interfaces.nsISmtpServer && 
485                    !server.redirectorType && smtp == server.key) {
486                    found = true; break;
487                }
488            }
489            var resource = this._rdfService.GetResource(this._rdfNS + this._rdfNSSMTPservers + "/" + smtp);
490            var rdfSMTPlabel = this._getRDFValue(resource, "label");
491            var rdfHostname = this._getRDFValue(resource, "hostname");
492            var rdfUsername = this._getRDFValue(resource, "username")
493            if (!found || rdfSMTPlabel != (server.description?server.description:server.hostname) && rdfHostname != server.hostname)
494                    mismatchSMTPs.push( { oldkey: smtp, label : rdfSMTPlabel, ext1: rdfHostname, ext2: rdfUsername, count: relevantSMTPs[smtp], key: "" } )
495        }
496        if (mismatchSMTPs.length > 0) {
497            Log.debug(" found mismatches on smtp(s).");
498            get3PaneWindow().openDialog("chrome://v_identity/content/vI_rdfAccountMismatchDialog.xul",0,
499                    "chrome, dialog, modal, alwaysRaised, resizable=yes", "smtp", mismatchSMTPs,
500                    /* callback: */ this).focus();
501            return true;
502        }
503        else {
504            Log.debug(" found no mismatch");
505            return false;
506        }
507    },
508
509    storeAccountInfo : function() {
510        Log.debug("storeAccounts");
511        var accounts = getAccountsArray();
512        for (let acc = 0; acc < accounts.length; acc++) {
513            let account = accounts[acc];
514            let identities = getIdentitiesArray(account);
515            for (let i = 0; i < identities.length; i++) {
516                let identity = identities[i];
517//                 Log.debug("storeAccounts identity store id " + identity.key);
518
519                var resource = this._rdfService.GetResource(this._rdfNS + this._rdfNSIdentities + "/" + identity.key);
520                this._setRDFValue(resource, "identityName", identity.identityName);
521                this._setRDFValue(resource, "fullName", identity.fullName);
522                this._setRDFValue(resource, "email", identity.email);
523               
524                var position = this._identityContainer.IndexOf(resource); // check for index in new recType
525                if (position != -1) this._identityContainer.InsertElementAt(resource, position, false);
526                else this._identityContainer.AppendElement(resource);
527            }
528        }
529       
530        function storeSmtp(server, parent) {
531//             Log.debug("storeAccounts smtp store id " + server.key);
532            var resource = parent._rdfService.GetResource(parent._rdfNS + parent._rdfNSSMTPservers + "/" + server.key);
533            parent._setRDFValue(resource, "label", (server.description?server.description:server.hostname));
534            parent._setRDFValue(resource, "hostname", server.hostname);
535            parent._setRDFValue(resource, "username", server.username);
536            var position = parent._smtpContainer.IndexOf(resource); // check for index in new recType
537            if (position != -1) parent._smtpContainer.InsertElementAt(resource, position, false);
538            else parent._smtpContainer.AppendElement(resource);
539        }
540       
541        var servers, smtpService = Components.classes["@mozilla.org/messengercompose/smtp;1"]
542            .getService(Components.interfaces.nsISmtpService);
543        // check for new https://hg.mozilla.org/comm-central/rev/fab9e5145cd4 smtpService
544        if (typeof(smtpService.servers) == "object") servers = smtpService.servers;
545        else servers = smtpService.smtpServers;
546
547        while (servers && servers.hasMoreElements()) {
548            var server = servers.getNext(); 
549            if (server instanceof Components.interfaces.nsISmtpServer && !server.redirectorType) storeSmtp(server, this);
550        }
551
552//         Log.debug("storeAccounts done");
553    },
554
555    export : function(rdfFileName) {
556        var filePicker = Components.classes["@mozilla.org/filepicker;1"]
557            .createInstance(Components.interfaces.nsIFilePicker);
558        filePicker.init(get3PaneWindow(), "", Components.interfaces.nsIFilePicker.modeSave);
559        filePicker.appendFilters(Components.interfaces.nsIFilePicker.filterAll | Components.interfaces.nsIFilePicker.filterText );
560        filePicker.appendFilter("RDF Files","*.rdf");
561       
562        if (filePicker.show() != Components.interfaces.nsIFilePicker.returnCancel) {
563            var rdfDataFile = Components.classes["@mozilla.org/file/local;1"]
564                .createInstance(Components.interfaces.nsILocalFile);
565            var file = Components.classes["@mozilla.org/file/directory_service;1"]
566                .getService(Components.interfaces.nsIProperties).get("ProfD", Components.interfaces.nsIFile);
567            var delimiter = (file.path.match(/\\/))?"\\":"/";
568            rdfDataFile.initWithPath(file.path + delimiter + rdfFileName);
569
570            rdfDataFile.copyTo(filePicker.file.parent,filePicker.file.leafName);
571        }
572    },
573   
574    _getRDFResourceForVIdentity : function (recDescription, recType) {
575        if (!this._rdfDataSource) return null;
576        if (!recDescription) {
577            Log.debug("_getRDFResourceForVIdentity: no Recipient given.");
578            return null;
579        }
580        var _rdfNSRecType = null
581        switch (recType) {
582            case "email": _rdfNSRecType = this._rdfNSEmail; break;
583            case "newsgroup" : _rdfNSRecType = this._rdfNSNewsgroup; break;
584            case "maillist" : _rdfNSRecType = this._rdfNSMaillist; break;
585            case "filter" : _rdfNSRecType = this._rdfNSFilter; break;
586        }
587        return this._rdfService.GetResource(this._rdfNS + _rdfNSRecType + "/" + recDescription);
588       
589       
590    },
591   
592    removeVIdentityFromRDF : function (resource, recType) {
593//      Log.debug("removeVIdentityFromRDF " + resource.ValueUTF8);
594        this._unsetRDFValue(resource, "email", this._getRDFValue(resource, "email"))
595        this._unsetRDFValue(resource, "fullName", this._getRDFValue(resource, "fullName"))
596        this._unsetRDFValue(resource, "id", this._getRDFValue(resource, "id"))
597        this._unsetRDFValue(resource, "smtp", this._getRDFValue(resource, "smtp"))
598        this._unsetRDFValue(resource, "name", this._getRDFValue(resource, "name"))
599       
600        let self = this;
601        var extras = new identityDataExtras(self, resource)
602        extras.loopThroughExtras(
603          function (extra) {
604            extra.value = self._unsetRDFValue(resource, extra.field, extra.value) });
605       
606        this.getContainer(recType).RemoveElement(resource, true);
607    },
608   
609    _unsetRDFValue : function (resource, field, value) {
610//      Log.debug("_unsetRDFValue " + this._rdfService  + " " + this._rdfDataSource);
611        var predicate = this._rdfService.GetResource(this._rdfNS + "rdf#" + field);
612        var name = this._rdfService.GetLiteral(value?value:"");
613        var target = this._rdfDataSource.GetTarget(resource, predicate, true);
614        if (target instanceof Components.interfaces.nsIRDFLiteral) {
615            this._rdfDataSource.Unassert(resource, predicate, name, true);
616            return null;
617        }
618        else return value;
619    },
620   
621    // this will be used from rdfDataTree to get all RDF values, callFunction is vI.rdfDataTreeCollection.__addNewDatum
622    readAllEntriesFromRDF : function (addNewDatum, treeType, idData) {
623//      Log.debug("readAllEntriesFromRDF " + this._rdfService  + " " + this._rdfDataSource + " " + this);
624        var enumerator = this.getContainer(treeType).GetElements();
625        while (enumerator && enumerator.hasMoreElements()) {
626            var resource = enumerator.getNext();
627            resource.QueryInterface(Components.interfaces.nsIRDFResource);
628            var name = this._getRDFValue(resource, "name")
629            var email = this._getRDFValue(resource, "email")
630            var fullName = this._getRDFValue(resource, "fullName")
631            var id = this._getRDFValue(resource, "id")
632            var smtp = this._getRDFValue(resource, "smtp")
633            var used = this._getRDFValue(resource, "timeUsed")
634            var changed = this._getRDFValue(resource, "timeChanged")
635            if (!smtp) smtp = NO_SMTP_TAG;
636            let self = this;
637            var localIdentityData = new identityData(email, fullName, id, smtp, new identityDataExtras(self, resource))
638            addNewDatum (resource, name, localIdentityData, idData, used, changed)
639        }
640    },
641   
642    __getDescriptionAndType : function (recipient, recipientType) {
643        if (recipientType == "addr_newsgroups") return { recDesc : recipient, recType : "newsgroup" }
644        else if (this.__isMailingList(recipient)) {
645            Log.debug("__getDescriptionAndType: '" + recipient + "' is MailList");
646            return { recDesc : this.__getMailListName(recipient), recType : "maillist" }
647        }
648        else {
649            Log.debug("__getDescriptionAndType: '" + recipient + "' is no MailList");
650            var localIdentityData = new identityData(recipient, null, null, null, null, null, null);
651            return { recDesc : localIdentityData.combinedName, recType : "email" }
652        }
653    },
654   
655    // --------------------------------------------------------------------
656    // check if recipient is a mailing list.
657    // Similiar to Thunderbird, if there are muliple cards with the same displayName the mailinglist is preferred
658    // see also https://bugzilla.mozilla.org/show_bug.cgi?id=408575
659    __isMailingList: function(recipient) {
660        let abManager = Components.classes["@mozilla.org/abmanager;1"]
661            .getService(Components.interfaces.nsIAbManager);
662        let allAddressBooks = abManager.directories;
663        while (allAddressBooks.hasMoreElements()) {
664            let ab = allAddressBooks.getNext();
665            if (ab instanceof Components.interfaces.nsIAbDirectory && !ab.isRemote) {
666                let abdirectory = abManager.getDirectory(ab.URI + 
667                    "?(and(DisplayName,=," + encodeURIComponent(this.__getMailListName(recipient)) + ")(IsMailList,=,TRUE))");
668                if (abdirectory) {
669                    try {   // just try, sometimes there are no childCards at all...
670                        let cards = abdirectory.childCards;
671                        if (cards.hasMoreElements()) return true;   // only interested if there is at least one element...
672                    } catch(e) { }
673                }
674            }
675        }
676        return false;
677    }, 
678   
679    // --------------------------------------------------------------------
680   
681    __getMailListName : function(recipient) {
682        if (recipient.match(/<[^>]*>/) || recipient.match(/$/)) {
683            var mailListName = RegExp.leftContext + RegExp.rightContext
684            mailListName = mailListName.replace(/^\s+|\s+$/g,"")
685        }
686        return mailListName;
687    },
688
689    findMatchingFilter : function (recipient, recipientType) {
690        var recDescription = this.__getDescriptionAndType(recipient, recipientType).recDesc;
691        Log.debug("findMatchingFilter for " + recDescription);
692        var enumerator = this._filterContainer.GetElements();
693        while (enumerator && enumerator.hasMoreElements()) {
694            var resource = enumerator.getNext();
695            resource.QueryInterface(Components.interfaces.nsIRDFResource);
696            var filter = this._getRDFValue(resource, "name");
697           
698            const filterType = { None : 0, RegExp : 1, StrCmp : 2 }
699            var recentfilterType;
700
701            if (filter == "") continue;
702            if (/^\/(.*)\/$/.exec(filter)) {
703              Log.debug("findMatchingFilter with RegExp '" + filter.replace(/\\/g,"\\\\") + "'");
704              recentfilterType = filterType.RegExp;
705            }
706            else {
707              Log.debug("findMatchingFilter, compare with '" + filter + "'");
708              recentfilterType = filterType.StrCmp;
709            }
710           
711            switch (recentfilterType) {
712                case filterType.RegExp:
713                    try {   /^\/(.*)\/$/.exec(filter);
714                        if (recDescription.match(new RegExp(RegExp.$1,"i"))) {
715                            Log.debug("findMatchingFilter found stored data.");
716                            return this._readVIdentityFromRDF(resource);
717                        }
718                    }
719                    catch(vErr) { }; break;
720                case filterType.StrCmp:
721                    if (recDescription.toLowerCase().indexOf(filter.toLowerCase()) != -1) {
722                        Log.debug("findMatchingFilter found stored data.");
723                        return this._readVIdentityFromRDF(resource);
724                    }
725                    break;
726            }
727        }
728        Log.debug("findMatchingFilter no match found.");
729        return null;
730    },
731   
732    readVIdentityFromRDF : function (recipient, recipientType) {
733        var storedRecipient = this.__getDescriptionAndType(recipient, recipientType);
734        var email = this._rdfService.GetResource(this._rdfNS + "rdf#email");
735        var resource = this._getRDFResourceForVIdentity(storedRecipient.recDesc, storedRecipient.recType);
736        if (!resource) return null;
737        if (!this._rdfDataSource.hasArcOut(resource, email)) {
738            // no data available --> give up.
739            Log.debug("readVIdentityFromRDF no data found.");
740            return null;
741        }
742        Log.debug("readVIdentityFromRDF found stored data.");
743       
744        return this._readVIdentityFromRDF(resource);
745    },
746   
747    _readVIdentityFromRDF : function (resource) {
748        var email = this._getRDFValue(resource, "email")
749        var fullName = this._getRDFValue(resource, "fullName")
750        var id = this._getRDFValue(resource, "id")
751        var smtp = this._getRDFValue(resource, "smtp")
752        if (!smtp) smtp = NO_SMTP_TAG;
753       
754        let _date = new Date();
755        this._setRDFValue(resource, "timeUsed", _date.getTime());
756       
757        Log.debug("email='" + email + 
758            "' fullName='" + fullName + "' id='" + id + "' smtp='" + smtp + "'");
759       
760        let self = this;
761        var localIdentityData = new identityData(email, fullName, id, smtp, new identityDataExtras(self, resource))
762        return localIdentityData;
763    },
764
765    _getRDFValue : function (resource, field) {
766//         Log.debug("_getRDFValue " + this._rdfService  + " " + this._rdfDataSource + " " + this);
767        var predicate = this._rdfService.GetResource(this._rdfNS + "rdf#" + field);
768        var target = this._rdfDataSource.GetTarget(resource, predicate, true);
769        if (target instanceof Components.interfaces.nsIRDFLiteral) return target.Value
770        else return null;
771    },
772   
773    updateRDFFromVIdentity : function(identityData, recipientName, recipientType) {
774        var recipient = this.__getDescriptionAndType(recipientName, recipientType)
775        this.updateRDF(recipient.recDesc, recipient.recType, identityData,
776            vIprefs.get("storage_store_base_id"),
777            vIprefs.get("storage_store_SMTP"),
778            null, null, false);
779    },
780   
781    removeRDF : function (recDescription, recType) {
782        var resource = this._getRDFResourceForVIdentity(recDescription, recType);
783        if (!resource) return null;
784        this.removeVIdentityFromRDF(resource, recType);
785        return resource;
786    },
787
788    updateRDF : function (recDescription, recType, localIdentityData, storeBaseID, storeSMTP, prevRecDescription, prevRecType, updateAllExtras) {
789//         Log.debug("(" + this._rdfNS + "): updateRDF recDescription=" + recDescription + " localIdentityData.email=" + localIdentityData.email);
790       
791//      if (!localIdentityData.email) {
792//          Log.debug("updateRDF: no Sender-email for Recipient, aborting.");
793//          return;
794//      }
795        if (!recDescription || recDescription.length == 0) return;
796
797        if (!prevRecDescription) prevRecDescription = recDescription;
798        if (!prevRecType) prevRecType = recType;
799
800        var resource = this._getRDFResourceForVIdentity(prevRecDescription, prevRecType);
801        if (!resource) return;
802//      Log.debug("updateRDF " + resource.ValueUTF8);
803       
804        var position = this.getContainer(recType).IndexOf(resource); // check for index in new recType
805        this.removeVIdentityFromRDF(resource, prevRecType);
806       
807        resource = this._getRDFResourceForVIdentity(recDescription, recType);
808
809        this._setRDFValue(resource, "email", localIdentityData.email);
810        this._setRDFValue(resource, "fullName", localIdentityData.fullName);
811        if (storeBaseID)
812            this._setRDFValue(resource, "id", localIdentityData.id.key);
813        else    this._unsetRDFValue(resource, "id", this._getRDFValue(resource, "id"))
814        if (storeSMTP && localIdentityData.smtp.key != NO_SMTP_TAG)
815            this._setRDFValue(resource, "smtp", localIdentityData.smtp.key);
816        else    this._unsetRDFValue(resource, "smtp", this._getRDFValue(resource, "smtp"))
817        this._setRDFValue(resource, "name", recDescription);
818 
819        if (localIdentityData.extras) {
820          let self = this;
821          localIdentityData.extras.loopThroughExtras(
822            function (extra) {
823              if (updateAllExtras || extra.active)
824                extra.value = self._setRDFValue(resource, extra.field, extra.value) });
825//           Log.debug("extras: " + localIdentityData.extras.status());
826        }
827       
828        let _date = new Date();
829        this._setRDFValue(resource, "timeChanged", _date.getTime());
830       
831//      Log.debug("updateRDF add " + resource.ValueUTF8 + " at position " + position);
832        if (position != -1) this.getContainer(recType).InsertElementAt(resource, position, true);
833        else this.getContainer(recType).AppendElement(resource);
834    },
835
836    _setRDFValue : function (resource, field, value) {
837//      Log.debug("_setRDFValue " + resource.ValueUTF8 + " " + field + " " + value);
838        if (!value) return value; // return if some value was not set.
839//      Log.debug("_setRDFValue " + this._rdfService + " " + this._rdfDataSource);
840        var predicate = this._rdfService.GetResource(this._rdfNS + "rdf#" + field);
841        var name = this._rdfService.GetLiteral(value);
842        var target = this._rdfDataSource.GetTarget(resource, predicate, true);
843       
844        if (target instanceof Components.interfaces.nsIRDFLiteral)
845            this._rdfDataSource.Change(resource, predicate, target, name);
846        else    this._rdfDataSource.Assert(resource, predicate, name, true);
847        return value;
848    },
849
850    //  code adapted from http://xulsolutions.blogspot.com/2006/07/creating-uninstall-script-for.html
851    AccountManagerObserver : {
852        _uninstall : false,
853        observe : function(subject, topic, data) {
854            if (topic == "am-smtpChanges" || topic == "am-acceptChanges") {
855                Log.debug("account/smtp changes observed");
856                this.searchIdentityMismatch();
857                this.searchSmtpMismatch();
858                this.refreshAccountInfo();
859            }
860        },
861        register : function() {
862            Log.debug("register AccountManagerObserver");
863            var obsService = Components.classes["@mozilla.org/observer-service;1"].
864                getService(Components.interfaces.nsIObserverService)
865            obsService.addObserver(this, "am-smtpChanges", false);
866            obsService.addObserver(this, "am-acceptChanges", false);
867        },
868        unregister : function() {
869            var obsService = Components.classes["@mozilla.org/observer-service;1"].
870                getService(Components.interfaces.nsIObserverService)
871            try {
872                obsService.removeObserver(this, "am-smtpChanges");
873                obsService.removeObserver(this, "am-acceptChanges");
874            } catch(e) { };
875        }
876    }
877}
878
879
880function rdfDatasourceAccess() {
881    this._rdfDataSource = new rdfDatasource("virtualIdentity.rdf", false);
882    this.stringBundle = Services.strings.createBundle("chrome://v_identity/locale/v_identity.properties");
883}
884
885rdfDatasourceAccess.prototype = {
886    _rdfDataSource : null,
887    stringBundle : null,
888   
889    clean : function() {
890        this._rdfDataSource.clean();
891    },
892   
893    updateVIdentityFromStorage : function(recipientName, recipientType, currentIdentity, currentIdentityIsVid, isNotFirstInputElement, currentWindow) {
894        var localIdentities = new identityCollection();
895        localIdentities.addWithoutDuplicates(this._rdfDataSource.readVIdentityFromRDF(recipientName, recipientType));
896        if (localIdentities.number == 1) Log.debug("using data from direct match");
897        localIdentities.addWithoutDuplicates(this._rdfDataSource.findMatchingFilter(recipientName, recipientType));
898       
899        var returnValue = {}; returnValue.identityCollection = localIdentities; returnValue.result = "drop";
900        if (localIdentities.number == 0) {
901            Log.debug("updateVIdentityFromStorage no usable Storage-Data found.");
902        }
903        else {
904            Log.debug("compare with current Identity");
905            if (vIprefs.get("storage_getOneOnly") &&        // if requested to retrieve only storageID for first recipient entered
906                isNotFirstInputElement &&                           // and it is now not the first recipient entered
907                !localIdentities.identityDataCollection[0].equalsIdentity(currentIdentity, false).equal) {      // and this id is different than the current used one
908                    StorageNotification.info(this.stringBundle.GetStringFromName("vident.smartIdentity.vIStorageCollidingIdentity"));
909//                  returnValue.result = "drop";    // this is the default value
910            }
911            // only update fields if new Identity is different than old one.
912            else {
913                Log.debug("updateVIdentityFromStorage check if storage-data matches current Identity.");
914                var compResult = localIdentities.identityDataCollection[0].equalsIdentity(currentIdentity, true);
915                if (!compResult.equal) {
916                    var warning = this.__getWarning("replaceVIdentity", recipientName, compResult.compareMatrix);
917                    if (    !currentIdentityIsVid ||
918                        !vIprefs.get("storage_warn_vI_replace") ||
919                        (this.__askWarning(warning, currentWindow) == "accept")) {
920                            returnValue.result = "accept";
921                    }
922                }
923                else {
924                    returnValue.result = "equal";
925                }
926            }
927        }
928        return returnValue;
929    },
930   
931    storeVIdentityToAllRecipients : function(identityData, recipients, currentWindow) {
932        var multipleRecipients = (recipients.length > 1);
933        var dontUpdateMultipleNoEqual = (vIprefs.get("storage_dont_update_multiple") && multipleRecipients)
934        Log.debug("storeVIdentityToAllRecipients dontUpdateMultipleNoEqual='" + dontUpdateMultipleNoEqual + "'")
935       
936        let returnValue = { update : "cancel" };
937        for (var j = 0; j < recipients.length; j++) {
938            returnValue = this.__updateStorageFromVIdentity(identityData, recipients[j].recipient, recipients[j].recipientType, dontUpdateMultipleNoEqual, currentWindow);
939            if (returnValue.update != "accept")  break;
940        }
941        return returnValue;
942    },
943
944    getVIdentityFromAllRecipients : function(allIdentities, recipients) {
945        if (!vIprefs.get("storage"))
946            { Log.debug("Storage deactivated"); return; }
947        var initnumber = allIdentities.number;
948        for (var j = 0; j < recipients.length; j++) {
949            allIdentities.addWithoutDuplicates(this._rdfDataSource.readVIdentityFromRDF(recipients[j].recipient, recipients[j].recipientType));
950            allIdentities.addWithoutDuplicates(this._rdfDataSource.findMatchingFilter(recipients[j].recipient, recipients[j].recipientType));
951        }
952        Log.debug("found " + (allIdentities.number-initnumber) + " address(es)")
953    },
954
955    __updateStorageFromVIdentity : function(identityData, recipient, recipientType, dontUpdateMultipleNoEqual, currentWindow) {
956        Log.debug("__updateStorageFromVIdentity.")
957        var storageDataByType = this._rdfDataSource.readVIdentityFromRDF(recipient, recipientType);
958        var storageDataByFilter = this._rdfDataSource.findMatchingFilter(recipient, recipientType);
959       
960        // update (storing) of data by type is required if there is
961        // no data stored by type (or different data stored) and no equal filter found
962        var storageDataByTypeCompResult = storageDataByType?storageDataByType.equalsIdentity(identityData, true):null;
963        var storageDataByTypeEqual = (storageDataByType && storageDataByTypeCompResult.equal);
964        var storageDataByFilterEqual = (storageDataByFilter && storageDataByFilter.equalsIdentity(identityData, false).equal);
965       
966        var doUpdate = "accept";
967        if (    (!storageDataByType && !storageDataByFilterEqual) ||
968            (!storageDataByTypeEqual && !storageDataByFilterEqual && !dontUpdateMultipleNoEqual) ) {
969            Log.debug("__updateStorageFromVIdentity updating")
970            if (storageDataByType && !storageDataByTypeEqual && vIprefs.get("storage_warn_update")) {
971                Log.debug("__updateStorageFromVIdentity overwrite warning");
972                doUpdate = this.__askWarning(this.__getWarning("updateStorage", recipient, storageDataByTypeCompResult.compareMatrix), currentWindow);
973            }
974        }
975        if (doUpdate == "accept") this._rdfDataSource.updateRDFFromVIdentity(identityData, recipient, recipientType);
976        return { update : doUpdate, storedIdentity : storageDataByType };
977    },
978   
979    __getWarning : function(warningCase, recipient, compareMatrix) {
980        var warning = { title: null, recLabel : null, recipient : null, warning : null, css: null, query : null, class : null };
981        warning.title = this.stringBundle.GetStringFromName("vident." + warningCase + ".title")
982        warning.recLabel = this.stringBundle.GetStringFromName("vident." + warningCase + ".recipient") + ":";
983        warning.recipient = recipient;
984        warning.warning = 
985            "<table class='" + warningCase + "'><thead><tr><th class='col1'/>" +
986                "<th class='col2'>" + this.stringBundle.GetStringFromName("vident." + warningCase + ".currentIdentity") + "</th>" +
987                "<th class='col3'>" + this.stringBundle.GetStringFromName("vident." + warningCase + ".storedIdentity") + "</th>" +
988            "</tr></thead>" +
989            "<tbody>" + compareMatrix + "</tbody>" +
990            "</table>"
991        warning.css = "vI.DialogBrowser.css";
992        warning.query = this.stringBundle.GetStringFromName("vident." + warningCase + ".query");
993        warning.class = warningCase;
994        return warning;
995    },
996
997    __askWarning : function(warning, currentWindow) {
998        var retVar = { returnValue: null };
999        var answer = currentWindow.openDialog("chrome://v_identity/content/vI_Dialog.xul","",
1000                    "chrome, dialog, modal, alwaysRaised, resizable=yes",
1001                     warning, retVar)
1002        Log.debug("retVar.returnValue=" + retVar.returnValue)
1003        return retVar.returnValue;
1004    },
1005}
1006
1007
1008// create with name of the file to import into
1009function rdfDatasourceImporter(rdfFileName) {
1010    this._rdfFileName = rdfFileName;
1011    if (this._rdfFileName) this.import();
1012}
1013
1014rdfDatasourceImporter.prototype = {
1015    _rdfService :       Components.classes["@mozilla.org/rdf/rdf-service;1"]
1016                            .getService(Components.interfaces.nsIRDFService),
1017    _rdfDataSource :    null,
1018    _rdfFileName :      null,
1019    _rdfImportDataSource :    null,
1020
1021    _getMatchingIdentity : function(name, email, fullName) {
1022        var accounts = getAccountsArray();
1023        for (let acc = 0; acc < accounts.length; acc++) {
1024            let account = accounts[acc];
1025            let identities = getIdentitiesArray(account);
1026            for (let i = 0; i < identities.length; i++) {
1027                let identity = identities[i];
1028                if (name == identity.identityName || (fullName == identity.fullName && email == identity.email)) return identity.key;
1029            }
1030        }
1031        return null;
1032    },
1033   
1034    _getMatchingSMTP : function(label, hostname, username) {
1035        var servers, smtpService = Components.classes["@mozilla.org/messengercompose/smtp;1"]
1036            .getService(Components.interfaces.nsISmtpService);
1037        // check for new https://hg.mozilla.org/comm-central/rev/fab9e5145cd4 smtpService
1038        if (typeof(smtpService.servers) == "object") servers = smtpService.servers;
1039        else servers = smtpService.smtpServers;
1040
1041        while (servers && servers.hasMoreElements()) {
1042            var server = servers.getNext(); 
1043            if (server instanceof Components.interfaces.nsISmtpServer && !server.redirectorType)
1044                if (label == (server.description?server.description:server.hostname) || (hostname == server.hostname && username == server.username))
1045                    return server.key;
1046        }
1047        return null;
1048    },
1049   
1050    _translateRelevantIDs : function() {
1051        var relevantIDs = this._rdfImportDataSource.getRelevantIDs();
1052        for (var id in relevantIDs) {
1053            var resource = this._rdfService.GetResource(this._rdfImportDataSource._rdfNS + this._rdfImportDataSource._rdfNSIdentities + "/" + id);
1054            var values = { id : null, identityName : null, email : null, fullName : null }
1055            values.identityName = this._rdfImportDataSource._getRDFValue(resource, "identityName");
1056            values.email = this._rdfImportDataSource._getRDFValue(resource, "email");
1057            values.fullName = this._rdfImportDataSource._getRDFValue(resource, "fullName");
1058            values.id = this._getMatchingIdentity(values.identityName, values.email, values.fullName);
1059            values.id = values.id?values.id:"import_" + id
1060            relevantIDs[id] = values;
1061            Log.debug("import: translate relevant ID from previous '" + id + "' to current '" + relevantIDs[id].id + "'");
1062        }
1063        return relevantIDs;
1064    },
1065   
1066    _storeMappedIDs : function(relevantIDs) {
1067        for (var id in relevantIDs) {
1068            if (relevantIDs[id].id == "import_" + id) {
1069                var resource = this._rdfService
1070                    .GetResource(this._rdfDataSource._rdfNS + this._rdfDataSource._rdfNSIdentities + "/" + relevantIDs[id].id);
1071                this._rdfDataSource._setRDFValue(resource, "identityName", relevantIDs[id].identityName);
1072                this._rdfDataSource._setRDFValue(resource, "fullName", relevantIDs[id].fullName);
1073                this._rdfDataSource._setRDFValue(resource, "email", relevantIDs[id].email);
1074               
1075                var position = this._rdfDataSource._identityContainer.IndexOf(resource); // check for index in new recType
1076                if (position != -1) this._rdfDataSource._identityContainer.InsertElementAt(resource, position, false);
1077                else this._rdfDataSource._identityContainer.AppendElement(resource);
1078            }
1079        }
1080    },
1081   
1082    _translateRelevantSMTPs : function() {
1083        var relevantSMTPs = this._rdfImportDataSource.getRelevantSMTPs();
1084        for (var smtp in relevantSMTPs) {
1085            var resource = this._rdfService.GetResource(this._rdfImportDataSource._rdfNS + this._rdfImportDataSource._rdfNSSMTPservers + "/" + smtp);
1086            var values = { smtp : null, label : null, hostname : null, username : null }
1087            values.label = this._rdfImportDataSource._getRDFValue(resource, "label");
1088            values.hostname = this._rdfImportDataSource._getRDFValue(resource, "hostname");
1089            values.username = this._rdfImportDataSource._getRDFValue(resource, "username");
1090            values.smtp =  this._getMatchingSMTP(values.label, values.hostname, values.username);
1091            values.smtp = values.smtp?values.smtp:"import_" + smtp;
1092            relevantSMTPs[smtp] = values;
1093            Log.debug("import: translate relevant SMTP from previous '" + smtp + "' to current '" + relevantSMTPs[smtp].smtp + "'");
1094        }
1095        return relevantSMTPs;
1096    },
1097   
1098    _storeMappedSMTPs : function(relevantSMTPs) {
1099        for (var smtp in relevantSMTPs) {
1100            if (relevantSMTPs[smtp].smtp == "import_" + smtp) {
1101                var resource = this._rdfService
1102                    .GetResource(this._rdfDataSource._rdfNS + this._rdfDataSource._rdfNSSMTPservers + "/" + relevantSMTPs[smtp].smtp);
1103                this._rdfDataSource._setRDFValue(resource, "label", relevantSMTPs[smtp].label);
1104                this._rdfDataSource._setRDFValue(resource, "hostname", relevantSMTPs[smtp].hostname);
1105                this._rdfDataSource._setRDFValue(resource, "username", relevantSMTPs[smtp].username);
1106               
1107                var position = this._rdfDataSource._smtpContainer.IndexOf(resource); // check for index in new recType
1108                if (position != -1) this._rdfDataSource._smtpContainer.InsertElementAt(resource, position, false);
1109                else this._rdfDataSource._smtpContainer.AppendElement(resource);
1110            }
1111        }
1112    },
1113   
1114    import : function() {
1115        var filePicker = Components.classes["@mozilla.org/filepicker;1"]
1116            .createInstance(Components.interfaces.nsIFilePicker);
1117
1118        filePicker.init(get3PaneWindow(), "", Components.interfaces.nsIFilePicker.modeOpen);
1119        filePicker.appendFilter("RDF Files","*.rdf");
1120        filePicker.appendFilters(Components.interfaces.nsIFilePicker.filterText | Components.interfaces.nsIFilePicker.filterAll );
1121       
1122        if (filePicker.show() == Components.interfaces.nsIFilePicker.returnOK) {
1123            Log.debug("import: preparation:");
1124           
1125            var importRdfDataFile = Components.classes["@mozilla.org/file/local;1"]
1126                .createInstance(Components.interfaces.nsILocalFile);
1127            var file = Components.classes["@mozilla.org/file/directory_service;1"]
1128                .getService(Components.interfaces.nsIProperties).get("ProfD", Components.interfaces.nsIFile);
1129            var delimiter = (file.path.match(/\\/))?"\\":"/";
1130            importRdfDataFile.initWithPath(file.path + delimiter + this._rdfFileName + "_import");
1131            filePicker.file.copyTo(importRdfDataFile.parent,importRdfDataFile.leafName);
1132
1133            Log.debug("import: copied file from " + filePicker.file.path + " to " + importRdfDataFile.path + "'");
1134           
1135            // init Datasources
1136            this._rdfImportDataSource = new rdfDatasource(importRdfDataFile.leafName, true);
1137           
1138            // search matching IDs and SMTPs for anyones used in import-file
1139            var relevantIDs = this._translateRelevantIDs();
1140            var relevantSMTPs = this._translateRelevantSMTPs();
1141           
1142            Log.debug("import: preparation done.");
1143           
1144            for each (let treeType in Array("email", "maillist", "newsgroup", "filter")) {
1145                // re-initialize importDataSource to point rdfService to the right Resources
1146                this._rdfImportDataSource = new rdfDatasource(importRdfDataFile.leafName, true);
1147                var container = this._rdfImportDataSource.getContainer(treeType)
1148                if (container.GetCount() == 0) continue;
1149                Log.debug("importing " + treeType + ": " + container.GetCount()+ " datasets from " + this._rdfImportDataSource._rdfDataSource.URI);
1150                var enumerator = container.GetElements();
1151                // re-initialize dataSource to point rdfService to the right Resources
1152                this._rdfDataSource = new rdfDatasource(this._rdfFileName, true);
1153                var count = 0;
1154                while (enumerator.hasMoreElements()) {
1155                    var resource = enumerator.getNext(); count += 1;
1156                    resource.QueryInterface(Components.interfaces.nsIRDFResource);
1157//                     Log.debug(" " + count + " ");
1158                    var name = this._rdfImportDataSource._getRDFValue(resource, "name")
1159                    var email = this._rdfImportDataSource._getRDFValue(resource, "email")
1160                    var fullName = this._rdfImportDataSource._getRDFValue(resource, "fullName")
1161                    var id = this._rdfImportDataSource._getRDFValue(resource, "id")
1162                    id = id?relevantIDs[id].id:null
1163                    var smtp = this._rdfImportDataSource._getRDFValue(resource, "smtp")
1164                    smtp = (smtp && smtp != DEFAULT_SMTP_TAG)?relevantSMTPs[smtp].smtp:smtp
1165                    var localIdentityData = new identityData(email, fullName, id, smtp, new identityDataExtras(this._rdfImportDataSource, resource))
1166                   
1167                    this._rdfDataSource.updateRDF(name, treeType, localIdentityData, false, false, null, null, true)
1168                    var resource = this._rdfDataSource._getRDFResourceForVIdentity(name, treeType);
1169                    if (id) this._rdfDataSource._setRDFValue(resource, "id", id);       // localIdentityData can only store valid id's, this one might be a temporary invalid id
1170                    if (smtp) this._rdfDataSource._setRDFValue(resource, "smtp", smtp); // localIdentityData can only store valid smtp's, this one might be a temporary invalid smtp
1171                }
1172            }
1173           
1174            Log.debug("import: removing temporary file " + importRdfDataFile.path);
1175            this._rdfImportDataSource = null; importRdfDataFile.remove(false);
1176            Log.debug("import: import done.");
1177           
1178            Log.debug("import: cleaning ID/SMTP storages:");
1179            this._rdfDataSource = new rdfDatasource(this._rdfFileName, true);
1180           
1181            this._storeMappedIDs(relevantIDs);
1182            this._rdfDataSource.searchIdentityMismatch();
1183            this._storeMappedSMTPs(relevantSMTPs);
1184            this._rdfDataSource.searchSmtpMismatch();
1185           
1186            this._rdfDataSource.refreshAccountInfo();
1187            this._rdfDataSource.clean();
1188            this._rdfDataSource = null;
1189            Log.debug("import: cleaning ID/SMTP storages done.");
1190            Log.debug("IMPORT DONE.");
1191        }
1192    }
1193}
Note: See TracBrowser for help on using the repository browser.