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

source: content/modules/vI_rdfDatasource.js @ c0a8de

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

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