public MockServer(ServerSetup setup)
: base(setup)
{
_serverData = MockServerData.GetInstance();
_serverData.Domains.Clear();
_serverData.Mailboxes.Clear();
_serverData.Groups.Clear();
_domainDal = new WebDomainDal(setup.Tenant);
_mailboxDal = new MailboxDal(setup.Tenant, SetupInfo.Limits.MailboxMaxCountPerUser);
_mailgroupDal = new MailGroupDal(setup.Tenant);
_mailaddressDal = new MailAddressDal(setup.Tenant);
var domains = _domainDal.GetTenantDomains();
foreach (var domain in domains)
{
_serverData.Domains.Add(new WebDomainBase(domain.name));
}
var mailboxesDto = _mailboxDal.GetMailboxes();
foreach (var mailboxDto in mailboxesDto)
{
var aliasList =
_mailaddressDal.GetMailboxAliases(mailboxDto.mailbox.id)
.Select(
aliasDto =>
new MailAddressBase(aliasDto.name, new WebDomainBase(aliasDto.domain.name)))
.ToList();
var resultMailbox = new MailboxBase(
new MailAccountBase(mailboxDto.mailbox.address),
//Its not login. It adress. Needed only for testing
new MailAddressBase(mailboxDto.mailbox_address.name,
new WebDomainBase(mailboxDto.mailbox_address.domain.name)), aliasList);
_serverData.Mailboxes.Add(resultMailbox);
}
var groupsDto = _mailgroupDal.GetMailGroups();
foreach (var resultGroup in from groupDto in groupsDto
let groupAddresses = groupDto.addresses.Select(address =>
new MailAddressBase(address.name,
new WebDomainBase
(
address
.domain
.name)))
.ToList()
select new MailGroupBase(
new MailAddressBase(groupDto.address.name,
new WebDomainBase(groupDto.address.domain.name)),
groupAddresses))
{
_serverData.Groups.Add(resultGroup);
}
}
protected override void _UpdateMailbox(MailboxBase mailbox)
{
var oldMailbox = _serverData.Mailboxes.FirstOrDefault(r => r.Address.Equals(mailbox.Address));
_serverData.Mailboxes.Remove(oldMailbox);
_serverData.Mailboxes.Add(mailbox);
}
protected override void _UpdateMailbox(MailboxBase mailbox)
{
var updateMailboxQuery = new SqlUpdate(MailboxTable.name)
.Set(MailboxTable.Columns.name, mailbox.Name)
.Where(MailboxTable.Columns.username, mailbox.Address.ToString());
using (var db = _dbManager.GetAdminDb())
{
db.ExecuteNonQuery(updateMailboxQuery);
}
}
public override IMailbox CreateMailbox(string name, string localpart, string password, IWebDomain domain, IMailAccount account, IMailServerFactory factory)
{
if (string.IsNullOrEmpty(localpart))
{
throw new ArgumentNullException("localpart");
}
if (domain == null)
{
throw new ArgumentNullException("domain");
}
if (account == null)
{
throw new ArgumentNullException("account");
}
if (localpart.Length + domain.Name.Length > 318) // 318 because of @ sign
{
throw new ArgumentException("Address of mailbox exceed limitation of 319 characters.", "localpart");
}
var mailboxBase = new MailboxBase(new MailAccountBase(account.Login),
new MailAddressBase(localpart, new WebDomainBase(domain)),
name,
new List <MailAddressBase>())
{
Address = { DateCreated = DateTime.UtcNow }
};
MailboxWithAddressDto mailboxWithAddressDto;
using (var dbContextWithTran = TeamlabMailboxDal.CreateMailDbContext(true))
{
mailboxWithAddressDto = TeamlabMailboxDal.CreateMailbox(account.TeamlabAccount, mailboxBase.Name,
mailboxBase.Address.ToString(), password,
mailboxBase.Address.LocalPart,
mailboxBase.Address.DateCreated,
domain.Id, domain.Name, domain.IsVerified, dbContextWithTran.DbManager);
_CreateMailbox(account.Login, password, localpart, domain.Name, name);
dbContextWithTran.CommitTransaction();
}
var mailboxAddress = factory.CreateMailAddress(mailboxWithAddressDto.mailbox_address.id, mailboxWithAddressDto.mailbox_address.tenant, mailboxWithAddressDto.mailbox_address.name, domain);
var mailbox = factory.CreateMailbox(mailboxWithAddressDto.mailbox.id, mailboxWithAddressDto.mailbox.tenant,
mailboxAddress, mailboxWithAddressDto.mailbox.name, account, new List <IMailAddress>(), this);
return(mailbox);
}
protected override MailboxBase _CreateMailbox(string login, string password, string localpart, string domain)
{
var result_mailbox = new MailboxBase(new MailAccountBase(login),
new MailAddressBase(localpart, new WebDomainBase(domain)),
new List <MailAddressBase>());
if (_serverData.Mailboxes.Any(r => r.Address.ToString().Equals(result_mailbox.Address.ToString())))
{
throw new DuplicateNameException("You want to create mailbox with already existing address");
}
_serverData.Mailboxes.Add(result_mailbox);
return(result_mailbox);
}
protected override void _DeleteMailbox(MailboxBase mailbox)
{
//Todo: think about free space in maildir
var delete_mailbox_query = new SqlDelete(MailboxTable.name).Where(MailboxTable.Columns.username, mailbox.Address.ToString());
var delete_mailbox_aliases = new SqlDelete(AliasTable.name).Where(AliasTable.Columns.redirect, mailbox.Address.ToString());
using (var db = _dbManager.GetAdminDb())
{
using (var t = db.BeginTransaction())
{
ClearMailboxStorageSpace(mailbox.Address.LocalPart, mailbox.Address.Domain.Name);
db.ExecuteNonQuery(delete_mailbox_query);
db.ExecuteNonQuery(delete_mailbox_aliases);
t.Commit();
}
}
}
protected abstract void _DeleteMailbox(MailboxBase mailbox);
protected abstract void _UpdateMailbox(MailboxBase mailbox);
protected override void _DeleteMailbox(MailboxBase mailbox)
{
_serverData.Mailboxes.Remove(mailbox);
}
protected override void _UpdateMailbox(MailboxBase mailbox)
{
throw new NotSupportedException();
}
protected override List <MailboxBase> _GetMailboxes(ICollection <string> mailbox_names)
{
var names_arg = mailbox_names.ToArray();
const string mailbox_ns = "msm";
const string domain_ns = "msd";
const string address_ns = "msa";
var mailbox_query = new SqlQuery(MailboxTable.name.Alias(mailbox_ns))
.InnerJoin(AliasTable.name.Alias(address_ns),
Exp.EqColumns(MailboxTable.Columns.domain.Prefix(mailbox_ns),
AliasTable.Columns.domain.Prefix(address_ns)))
.InnerJoin(DomainTable.name.Alias(domain_ns),
Exp.EqColumns(MailboxTable.Columns.domain.Prefix(mailbox_ns),
DomainTable.Columns.domain.Prefix(domain_ns)))
.Select(MailboxTable.Columns.username.Prefix(mailbox_ns))
.Select(MailboxTable.Columns.password.Prefix(mailbox_ns))
.Select(MailboxTable.Columns.name.Prefix(mailbox_ns))
.Select(MailboxTable.Columns.maildir.Prefix(mailbox_ns))
.Select(MailboxTable.Columns.quota.Prefix(mailbox_ns))
.Select(MailboxTable.Columns.local_part.Prefix(mailbox_ns))
.Select(MailboxTable.Columns.domain.Prefix(mailbox_ns))
.Select(MailboxTable.Columns.created.Prefix(mailbox_ns))
.Select(MailboxTable.Columns.modified.Prefix(mailbox_ns))
.Select(MailboxTable.Columns.active.Prefix(mailbox_ns))
.Select(AliasTable.Columns.address.Prefix(address_ns))
.Select(AliasTable.Columns.redirect.Prefix(address_ns))
.Select(AliasTable.Columns.domain.Prefix(address_ns))
.Select(AliasTable.Columns.created.Prefix(address_ns))
.Select(AliasTable.Columns.modified.Prefix(address_ns))
.Select(AliasTable.Columns.active.Prefix(address_ns))
.Select(DomainTable.Columns.domain.Prefix(domain_ns))
.Select(DomainTable.Columns.description.Prefix(domain_ns))
.Select(DomainTable.Columns.aliases.Prefix(domain_ns))
.Select(DomainTable.Columns.mailboxes.Prefix(domain_ns))
.Select(DomainTable.Columns.maxquota.Prefix(domain_ns))
.Select(DomainTable.Columns.quota.Prefix(domain_ns))
.Select(DomainTable.Columns.transport.Prefix(domain_ns))
.Select(DomainTable.Columns.backupmx.Prefix(domain_ns))
.Select(DomainTable.Columns.created.Prefix(domain_ns))
.Select(DomainTable.Columns.modified.Prefix(domain_ns))
.Select(DomainTable.Columns.active.Prefix(domain_ns))
.Where(MailboxTable.Columns.active.Prefix(mailbox_ns), 1)
.Where(AliasTable.Columns.active.Prefix(address_ns), true)
.Where(AliasTable.Columns.is_group.Prefix(address_ns), false)
.Where(Exp.In(MailboxTable.Columns.username.Prefix(mailbox_ns), names_arg))
.Where(Exp.EqColumns(AliasTable.Columns.redirect.Prefix(address_ns),
MailboxTable.Columns.username.Prefix(mailbox_ns)));
var mailbox_list = new List <MailboxBase>();
List <object[]> db_result;
using (var db = _dbManager.GetAdminDb())
{
db_result = db.ExecuteList(mailbox_query).ToList();
}
if (!db_result.Any())
{
return(mailbox_list);
}
var grouped_result = db_result.GroupBy(r => r[0]).ToDictionary(g => g.Key, g => g.ToList());
const int domain_start_index = ToDtoConverters.mailbox_columns_count + ToDtoConverters.mail_address_columns_count;
foreach (var group in grouped_result)
{
var mailbox_dto = group.Value[0].SubArray(0, ToDtoConverters.mailbox_columns_count).ToMailboxDto();
var alias_list = new List <MailAddressBase>();
foreach (var group_val in group.Value)
{
var address_dto = group_val.SubArray(ToDtoConverters.mailbox_columns_count, ToDtoConverters.mail_address_columns_count).ToAddressDto();
var domain_dto = group_val.SubArray(domain_start_index, group_val.Length - domain_start_index).ToWebDomainDto();
address_dto.Domain = domain_dto;
var addr = address_dto.ToPostfixAddress();
if (addr.ToString() != mailbox_dto.username)
{
alias_list.Add(addr);
}
}
var mailbox = new MailboxBase(
new MailAccountBase(mailbox_dto.username),
new MailAddressBase(mailbox_dto.local_part,
new WebDomainBase(mailbox_dto.domain)), alias_list);
mailbox_list.Add(mailbox);
}
return(mailbox_list);
}
