2014-11-25 22:09:55 +01:00
|
|
|
/* -*- Mode: javascript; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
|
|
|
|
(function() {
|
|
|
|
'use strict';
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @name Account
|
|
|
|
* @constructor
|
|
|
|
* @param {object} futureAccountData
|
|
|
|
*/
|
2016-09-30 18:02:46 +02:00
|
|
|
function Account(futureAccountData) {
|
2014-11-25 22:09:55 +01:00
|
|
|
// Data is immediately available
|
|
|
|
if (typeof futureAccountData.then !== 'function') {
|
|
|
|
angular.extend(this, futureAccountData);
|
2016-03-03 19:38:54 +01:00
|
|
|
_.forEach(this.identities, function(identity) {
|
2014-12-11 17:24:22 +01:00
|
|
|
if (identity.fullName)
|
|
|
|
identity.full = identity.fullName + ' <' + identity.email + '>';
|
|
|
|
else
|
|
|
|
identity.full = '<' + identity.email + '>';
|
|
|
|
});
|
|
|
|
Account.$log.debug('Account: ' + JSON.stringify(futureAccountData, undefined, 2));
|
2014-11-25 22:09:55 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
// The promise will be unwrapped first
|
|
|
|
//this.$unwrap(futureAccountData);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @memberof Account
|
|
|
|
* @desc The factory we'll use to register with Angular
|
|
|
|
* @returns the Account constructor
|
|
|
|
*/
|
2015-09-30 22:17:05 +02:00
|
|
|
Account.$factory = ['$q', '$timeout', '$log', 'sgSettings', 'Resource', 'Preferences', 'Mailbox', 'Message', function($q, $timeout, $log, Settings, Resource, Preferences, Mailbox, Message) {
|
2014-11-25 22:09:55 +01:00
|
|
|
angular.extend(Account, {
|
|
|
|
$q: $q,
|
|
|
|
$timeout: $timeout,
|
|
|
|
$log: $log,
|
2015-08-27 17:01:23 +02:00
|
|
|
$$resource: new Resource(Settings.activeUser('folderURL') + 'Mail', Settings.activeUser()),
|
2015-09-30 22:17:05 +02:00
|
|
|
$Preferences: Preferences,
|
2014-12-11 17:24:22 +01:00
|
|
|
$Mailbox: Mailbox,
|
|
|
|
$Message: Message
|
2014-11-25 22:09:55 +01:00
|
|
|
});
|
|
|
|
|
|
|
|
return Account; // return constructor
|
|
|
|
}];
|
|
|
|
|
2015-07-29 17:47:01 +02:00
|
|
|
/**
|
|
|
|
* @module SOGo.MailerUI
|
|
|
|
* @desc Factory registration of Account in Angular module.
|
|
|
|
*/
|
|
|
|
try {
|
|
|
|
angular.module('SOGo.MailerUI');
|
|
|
|
}
|
|
|
|
catch(e) {
|
|
|
|
angular.module('SOGo.MailerUI', ['SOGo.Common']);
|
|
|
|
}
|
2014-11-25 22:09:55 +01:00
|
|
|
angular.module('SOGo.MailerUI')
|
2015-05-06 04:06:13 +02:00
|
|
|
.factory('Account', Account.$factory);
|
2014-11-25 22:09:55 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @memberof Account
|
|
|
|
* @desc Set the list of accounts and instanciate a new Account object for each item.
|
|
|
|
* @param {array} [data] - the metadata of the accounts
|
|
|
|
* @returns the list of accounts
|
|
|
|
*/
|
|
|
|
Account.$findAll = function(data) {
|
2015-08-27 17:01:23 +02:00
|
|
|
if (!data) {
|
|
|
|
return Account.$$resource.fetch('', 'mailAccounts').then(function(o) {
|
|
|
|
return Account.$unwrapCollection(o);
|
2014-11-25 22:09:55 +01:00
|
|
|
});
|
|
|
|
}
|
2015-08-27 17:01:23 +02:00
|
|
|
return Account.$unwrapCollection(data);
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @memberof Account
|
|
|
|
* @desc Unwrap to a collection of Account instances.
|
|
|
|
* @param {object} data - the accounts information
|
|
|
|
* @returns a collection of Account objects
|
|
|
|
*/
|
|
|
|
Account.$unwrapCollection = function(data) {
|
|
|
|
var collection = [];
|
|
|
|
|
|
|
|
angular.forEach(data, function(o, i) {
|
|
|
|
o.id = i;
|
|
|
|
collection[i] = new Account(o);
|
|
|
|
});
|
2016-05-26 17:18:36 +02:00
|
|
|
Account.$accounts = collection;
|
|
|
|
|
2014-11-25 22:09:55 +01:00
|
|
|
return collection;
|
|
|
|
};
|
|
|
|
|
2016-05-26 21:48:15 +02:00
|
|
|
/**
|
|
|
|
* @function getLength
|
|
|
|
* @memberof Account.prototype
|
|
|
|
* @desc Used by md-virtual-repeat / md-on-demand
|
|
|
|
* @returns the number of mailboxes in the account
|
|
|
|
*/
|
|
|
|
Account.prototype.getLength = function() {
|
|
|
|
return this.$flattenMailboxes().length;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @function getItemAtIndex
|
|
|
|
* @memberof Account.prototype
|
|
|
|
* @desc Used by md-virtual-repeat / md-on-demand
|
|
|
|
* @returns the mailbox at the specified index
|
|
|
|
*/
|
|
|
|
Account.prototype.getItemAtIndex = function(index) {
|
|
|
|
var expandedMailboxes;
|
|
|
|
|
|
|
|
expandedMailboxes = this.$flattenMailboxes();
|
|
|
|
if (index >= 0 && index < expandedMailboxes.length)
|
|
|
|
return expandedMailboxes[index];
|
|
|
|
|
|
|
|
return null;
|
|
|
|
};
|
|
|
|
|
2014-11-25 22:09:55 +01:00
|
|
|
/**
|
|
|
|
* @function $getMailboxes
|
|
|
|
* @memberof Account.prototype
|
|
|
|
* @desc Fetch the list of mailboxes for the current account.
|
2015-05-06 04:06:13 +02:00
|
|
|
* @param {object} [options] - force a reload by setting 'reload' to true
|
2014-11-25 22:09:55 +01:00
|
|
|
* @returns a promise of the HTTP operation
|
|
|
|
*/
|
2014-12-18 21:22:29 +01:00
|
|
|
Account.prototype.$getMailboxes = function(options) {
|
2015-08-28 21:15:40 +02:00
|
|
|
var _this = this;
|
2014-12-11 17:24:22 +01:00
|
|
|
|
2014-12-18 21:22:29 +01:00
|
|
|
if (this.$mailboxes && !(options && options.reload)) {
|
2015-08-28 21:15:40 +02:00
|
|
|
return Account.$q.when(this.$mailboxes);
|
2014-12-11 17:24:22 +01:00
|
|
|
}
|
|
|
|
else {
|
2016-11-08 21:20:41 +01:00
|
|
|
return Account.$Mailbox.$find(this, options).then(function(data) {
|
2014-12-11 17:24:22 +01:00
|
|
|
_this.$mailboxes = data;
|
2016-05-27 19:55:14 +02:00
|
|
|
_this.$expanded = false;
|
2015-09-30 22:17:05 +02:00
|
|
|
|
|
|
|
// Set expanded folders from user's settings
|
2017-06-01 19:46:57 +02:00
|
|
|
var expandedFolders,
|
|
|
|
_visit = function(mailboxes) {
|
|
|
|
_.forEach(mailboxes, function(o) {
|
|
|
|
o.$expanded = (expandedFolders.indexOf('/' + o.id) >= 0);
|
|
|
|
if (o.children && o.children.length > 0) {
|
|
|
|
_visit(o.children);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
};
|
|
|
|
if (Account.$Preferences.settings.Mail.ExpandedFolders) {
|
2017-10-31 18:25:51 +01:00
|
|
|
if (angular.isString(Account.$Preferences.settings.Mail.ExpandedFolders)) {
|
2017-06-01 19:46:57 +02:00
|
|
|
// Backward compatibility support
|
2017-10-31 18:25:51 +01:00
|
|
|
try {
|
|
|
|
expandedFolders = angular.fromJson(Account.$Preferences.settings.Mail.ExpandedFolders);
|
|
|
|
}
|
|
|
|
catch (e) {
|
|
|
|
Account.$log.warn("Can't parse list of expanded folders. String was: " +
|
|
|
|
Account.$Preferences.settings.Mail.ExpandedFolders);
|
2017-11-01 18:29:46 +01:00
|
|
|
expandedFolders = [];
|
2017-10-31 18:25:51 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2017-06-01 19:46:57 +02:00
|
|
|
expandedFolders = Account.$Preferences.settings.Mail.ExpandedFolders;
|
2017-10-31 18:25:51 +01:00
|
|
|
}
|
2017-06-01 19:46:57 +02:00
|
|
|
_this.$expanded = (expandedFolders.indexOf('/' + _this.id) >= 0);
|
|
|
|
if (expandedFolders.length > 0) {
|
|
|
|
_visit(_this.$mailboxes);
|
2015-09-30 22:17:05 +02:00
|
|
|
}
|
2017-06-01 19:46:57 +02:00
|
|
|
}
|
|
|
|
if (Account.$accounts)
|
|
|
|
_this.$expanded |= (Account.$accounts.length == 1); // Always expand single account
|
|
|
|
_this.$flattenMailboxes({reload: true});
|
2015-09-30 22:17:05 +02:00
|
|
|
|
2015-08-28 21:15:40 +02:00
|
|
|
return _this.$mailboxes;
|
2014-12-11 17:24:22 +01:00
|
|
|
});
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2015-04-29 17:23:21 +02:00
|
|
|
/**
|
|
|
|
* @function $flattenMailboxes
|
|
|
|
* @memberof Account.prototype
|
|
|
|
* @desc Get a flatten array of the mailboxes.
|
2016-05-26 17:18:36 +02:00
|
|
|
* @param {object} [options] - the following boolean attributes are available:
|
|
|
|
* - reload: rebuild the flatten array of mailboxes from the original tree representation (this.$mailboxes)
|
|
|
|
* - all: return all mailboxes, ignoring their expanstion state
|
|
|
|
* - saveState: save expansion state of mailboxes to the server
|
2015-04-29 17:23:21 +02:00
|
|
|
* @returns an array of Mailbox instances
|
|
|
|
*/
|
|
|
|
Account.prototype.$flattenMailboxes = function(options) {
|
2014-12-11 17:24:22 +01:00
|
|
|
var _this = this,
|
|
|
|
allMailboxes = [],
|
2015-09-30 22:17:05 +02:00
|
|
|
expandedMailboxes = [],
|
2015-04-29 17:23:21 +02:00
|
|
|
_visit = function(mailboxes) {
|
2016-03-03 19:38:54 +01:00
|
|
|
_.forEach(mailboxes, function(o) {
|
2015-04-29 17:23:21 +02:00
|
|
|
allMailboxes.push(o);
|
2015-10-08 22:42:24 +02:00
|
|
|
if ((options && options.all || o.$expanded) && o.children && o.children.length > 0) {
|
2015-04-29 17:23:21 +02:00
|
|
|
_visit(o.children);
|
2014-12-11 17:24:22 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
2015-10-08 22:42:24 +02:00
|
|
|
if (this.$$flattenMailboxes && !(options && (options.reload || options.all))) {
|
2014-12-11 17:24:22 +01:00
|
|
|
allMailboxes = this.$$flattenMailboxes;
|
|
|
|
}
|
|
|
|
else {
|
2015-04-29 17:23:21 +02:00
|
|
|
_visit(this.$mailboxes);
|
2015-12-10 18:07:01 +01:00
|
|
|
if (!options || !options.all) {
|
|
|
|
_this.$$flattenMailboxes = allMailboxes;
|
|
|
|
if (options && options.saveState) {
|
2016-05-26 17:18:36 +02:00
|
|
|
// Save expansion state of mailboxes to the server
|
|
|
|
_.forEach(Account.$accounts, function(account) {
|
2016-05-26 21:48:15 +02:00
|
|
|
if (account.$expanded) {
|
|
|
|
expandedMailboxes.push('/' + account.id);
|
|
|
|
}
|
2016-05-26 17:18:36 +02:00
|
|
|
_.reduce(account.$$flattenMailboxes, function(expandedFolders, mailbox) {
|
|
|
|
if (mailbox.$expanded) {
|
|
|
|
expandedFolders.push('/' + mailbox.id);
|
|
|
|
}
|
|
|
|
return expandedFolders;
|
|
|
|
}, expandedMailboxes);
|
|
|
|
});
|
2015-12-10 18:07:01 +01:00
|
|
|
Account.$$resource.post(null, 'saveFoldersState', expandedMailboxes);
|
|
|
|
}
|
2015-09-30 22:17:05 +02:00
|
|
|
}
|
2014-12-11 17:24:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return allMailboxes;
|
|
|
|
};
|
|
|
|
|
|
|
|
Account.prototype.$getMailboxByType = function(type) {
|
|
|
|
var mailbox,
|
|
|
|
// Recursive find function
|
|
|
|
_find = function(mailboxes) {
|
|
|
|
var mailbox = _.find(mailboxes, function(o) {
|
|
|
|
return o.type == type;
|
|
|
|
});
|
|
|
|
if (!mailbox) {
|
|
|
|
angular.forEach(mailboxes, function(o) {
|
|
|
|
if (!mailbox && o.children && o.children.length > 0) {
|
|
|
|
mailbox = _find(o.children);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
return mailbox;
|
|
|
|
};
|
2014-12-16 21:47:34 +01:00
|
|
|
mailbox = _find(this.$mailboxes);
|
2014-12-11 17:24:22 +01:00
|
|
|
|
2016-02-08 21:36:01 +01:00
|
|
|
return mailbox;
|
2014-12-11 17:24:22 +01:00
|
|
|
};
|
|
|
|
|
2014-12-16 21:47:34 +01:00
|
|
|
/**
|
|
|
|
* @function $getMailboxByPath
|
|
|
|
* @memberof Account.prototype
|
|
|
|
* @desc Recursively find a mailbox using its path
|
|
|
|
* @returns a promise of the HTTP operation
|
|
|
|
*/
|
|
|
|
Account.prototype.$getMailboxByPath = function(path) {
|
|
|
|
var mailbox = null,
|
|
|
|
// Recursive find function
|
|
|
|
_find = function(mailboxes) {
|
|
|
|
var mailbox = _.find(mailboxes, function(o) {
|
|
|
|
return o.path == path;
|
|
|
|
});
|
|
|
|
if (!mailbox) {
|
|
|
|
angular.forEach(mailboxes, function(o) {
|
|
|
|
if (!mailbox && o.children && o.children.length > 0) {
|
|
|
|
mailbox = _find(o.children);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
return mailbox;
|
|
|
|
};
|
|
|
|
mailbox = _find(this.$mailboxes);
|
|
|
|
|
|
|
|
return mailbox;
|
|
|
|
};
|
|
|
|
|
2014-12-18 21:22:29 +01:00
|
|
|
/**
|
|
|
|
* @function $newMailbox
|
|
|
|
* @memberof Account.prototype
|
|
|
|
* @desc Create a new mailbox on the server and refresh the list of mailboxes.
|
|
|
|
* @returns a promise of the HTTP operations
|
|
|
|
*/
|
|
|
|
Account.prototype.$newMailbox = function(path, name) {
|
2015-08-19 03:20:34 +02:00
|
|
|
var _this = this;
|
2014-12-18 21:22:29 +01:00
|
|
|
|
2015-08-19 03:20:34 +02:00
|
|
|
return Account.$$resource.post(path.toString(), 'createFolder', {name: name}).then(function() {
|
2014-12-18 21:22:29 +01:00
|
|
|
_this.$getMailboxes({reload: true});
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
2018-01-12 21:00:51 +01:00
|
|
|
/**
|
|
|
|
* @function $certificate
|
|
|
|
* @memberof Account.prototype
|
|
|
|
* @desc View the S/MIME certificate details associated to the account.
|
|
|
|
* @returns a promise of the HTTP operation
|
|
|
|
*/
|
|
|
|
Account.prototype.$certificate = function() {
|
|
|
|
var _this = this;
|
|
|
|
|
|
|
|
if (this.security && this.security.hasCertificate) {
|
|
|
|
if (this.$$certificate)
|
|
|
|
return Account.$q.when(this.$$certificate);
|
|
|
|
else {
|
|
|
|
return Account.$$resource.fetch(this.id.toString(), 'certificate').then(function(data) {
|
|
|
|
_this.$$certificate = data;
|
|
|
|
return data;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return Account.$q.reject();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-12-21 22:41:06 +01:00
|
|
|
/**
|
|
|
|
* @function $removeCertificate
|
|
|
|
* @memberof Account.prototype
|
|
|
|
* @desc Remove any S/MIME certificate associated with the account.
|
|
|
|
* @returns a promise of the HTTP operation
|
|
|
|
*/
|
|
|
|
Account.prototype.$removeCertificate = function() {
|
|
|
|
var _this = this;
|
|
|
|
|
2018-01-12 21:00:51 +01:00
|
|
|
return Account.$$resource.fetch(this.id.toString(), 'removeCertificate').then(function() {
|
|
|
|
_this.security.hasCertificate = false;
|
|
|
|
});
|
2017-12-21 22:41:06 +01:00
|
|
|
};
|
|
|
|
|
2015-12-22 03:14:39 +01:00
|
|
|
/**
|
|
|
|
* @function updateQuota
|
|
|
|
* @memberof Account.prototype
|
|
|
|
* @param {Object} data - the inbox quota information returned by the server
|
|
|
|
* @desc Update the quota definition associated to the account
|
|
|
|
*/
|
|
|
|
Account.prototype.updateQuota = function(data) {
|
|
|
|
var percent, format, description;
|
|
|
|
|
|
|
|
percent = (Math.round(data.usedSpace * 10000 / data.maxQuota) / 100);
|
|
|
|
format = l("quotasFormat");
|
|
|
|
description = format.formatted(percent, Math.round(data.maxQuota/10.24)/100);
|
|
|
|
|
|
|
|
this.$quota = { percent: percent, description: description };
|
|
|
|
};
|
|
|
|
|
2014-12-11 17:24:22 +01:00
|
|
|
/**
|
|
|
|
* @function $newMessage
|
|
|
|
* @memberof Account.prototype
|
|
|
|
* @desc Prepare a new Message object associated to the appropriate mailbox.
|
|
|
|
* @returns a promise of the HTTP operations
|
|
|
|
*/
|
2017-08-29 17:45:24 +02:00
|
|
|
Account.prototype.$newMessage = function(options) {
|
2015-07-13 21:22:58 +02:00
|
|
|
var _this = this;
|
2014-12-11 17:24:22 +01:00
|
|
|
|
|
|
|
// Query account for draft folder and draft UID
|
2015-07-13 21:22:58 +02:00
|
|
|
return Account.$$resource.fetch(this.id.toString(), 'compose').then(function(data) {
|
2015-08-09 16:36:54 +02:00
|
|
|
Account.$log.debug('New message (compose): ' + JSON.stringify(data, undefined, 2));
|
2015-07-13 21:22:58 +02:00
|
|
|
var message = new Account.$Message(data.accountId, _this.$getMailboxByPath(data.mailboxPath), data);
|
|
|
|
return message;
|
|
|
|
}).then(function(message) {
|
2014-12-11 17:24:22 +01:00
|
|
|
// Fetch draft initial data
|
2015-07-13 21:22:58 +02:00
|
|
|
return Account.$$resource.fetch(message.$absolutePath({asDraft: true}), 'edit').then(function(data) {
|
2018-01-24 04:23:14 +01:00
|
|
|
var accountDefaults = Account.$Preferences.defaults.AuxiliaryMailAccounts[_this.id];
|
|
|
|
if (accountDefaults.security) {
|
|
|
|
if (accountDefaults.security.alwaysSign)
|
|
|
|
data.sign = true;
|
|
|
|
if (accountDefaults.security.alwaysEncrypt)
|
|
|
|
data.encrypt = true;
|
|
|
|
}
|
2015-08-09 16:36:54 +02:00
|
|
|
Account.$log.debug('New message (edit): ' + JSON.stringify(data, undefined, 2));
|
2015-04-18 14:50:06 +02:00
|
|
|
angular.extend(message.editable, data);
|
2016-01-25 20:21:38 +01:00
|
|
|
message.isNew = true;
|
2017-11-08 22:40:33 +01:00
|
|
|
if (options && options.mailto) {
|
|
|
|
if (angular.isObject(options.mailto))
|
|
|
|
angular.extend(message.editable, options.mailto);
|
|
|
|
else
|
|
|
|
message.$parseMailto(options.mailto);
|
|
|
|
}
|
2015-07-13 21:22:58 +02:00
|
|
|
return message;
|
2014-12-11 17:24:22 +01:00
|
|
|
});
|
2014-11-30 14:50:26 +01:00
|
|
|
});
|
2014-11-25 22:09:55 +01:00
|
|
|
};
|
|
|
|
|
2015-07-04 02:40:06 +02:00
|
|
|
/**
|
|
|
|
* @function $addDelegate
|
|
|
|
* @memberof Account.prototype
|
|
|
|
* @param {Object} user - a User object with minimal set of attributes (uid, isGroup, cn, c_email)
|
|
|
|
* @desc Remove a user from the account's delegates
|
|
|
|
* @see {@link User.$filter}
|
|
|
|
*/
|
|
|
|
Account.prototype.$addDelegate = function(user) {
|
|
|
|
var _this = this,
|
|
|
|
deferred = Account.$q.defer(),
|
|
|
|
param = {uid: user.uid};
|
2016-03-03 19:38:54 +01:00
|
|
|
if (!user.uid || _.indexOf(_.map(this.delegates, 'uid'), user.uid) > -1) {
|
2015-07-04 02:40:06 +02:00
|
|
|
// No UID specified or user already in delegates
|
|
|
|
deferred.resolve();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
Account.$$resource.fetch(this.id.toString(), 'addDelegate', param).then(function() {
|
|
|
|
_this.delegates.push(user);
|
|
|
|
deferred.resolve(_this.users);
|
|
|
|
}, function(data, status) {
|
|
|
|
deferred.reject(l('An error occured please try again.'));
|
|
|
|
});
|
|
|
|
}
|
|
|
|
return deferred.promise;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @function $removeDelegate
|
|
|
|
* @memberof Account.prototype
|
|
|
|
* @param {Object} user - a User object with minimal set of attributes (uid, isGroup, cn, c_email)
|
|
|
|
* @desc Remove a user from the account's delegates
|
|
|
|
* @return a promise of the server call to remove the user from the account's delegates
|
|
|
|
*/
|
|
|
|
Account.prototype.$removeDelegate = function(uid) {
|
|
|
|
var _this = this,
|
|
|
|
param = {uid: uid};
|
|
|
|
return Account.$$resource.fetch(this.id.toString(), 'removeDelegate', param).then(function() {
|
2016-03-03 19:38:54 +01:00
|
|
|
var i = _.indexOf(_.map(_this.delegates, 'uid'), uid);
|
2015-07-04 02:40:06 +02:00
|
|
|
if (i >= 0) {
|
|
|
|
_this.delegates.splice(i, 1);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
2014-11-25 22:09:55 +01:00
|
|
|
})();
|