protected override MailGroupBase _CreateMailGroup(MailAddressBase address, List <MailAddressBase> in_addresses)
{
var creation_date = DateTime.UtcNow;
var members_string = string.Join(",", in_addresses.Select(addr => addr.ToString()));
var insert_addresses = new SqlInsert(AliasTable.name)
.InColumns(AliasTable.Columns.address, AliasTable.Columns.redirect, AliasTable.Columns.domain,
AliasTable.Columns.modified,
AliasTable.Columns.created, AliasTable.Columns.active, AliasTable.Columns.is_group)
.Values(address.ToString(), members_string, address.Domain.Name, creation_date, creation_date, true, true);
try
{
using (var db = _dbManager.GetAdminDb())
{
db.ExecuteNonQuery(insert_addresses);
}
}
catch (MySqlException ex)
{
if (ex.Message.StartsWith("Duplicate entry"))
{
throw new ArgumentException("You want to create already existing group");
}
throw;
}
return(new MailGroupBase(address, in_addresses));
}
public IMailAddress AddAlias(string aliasName, IWebDomain domain, IMailServerFactory factory)
{
if (Aliases.Any(a => a.LocalPart == aliasName && a.Domain.Id == domain.Id))
{
throw new DuplicateNameException("You want to add already existed alias");
}
var addressBase = new MailAddressBase(aliasName, new WebDomainBase(domain))
{
DateCreated = DateTime.UtcNow
};
MailAddressDto aliasDto;
using (var dbContextWithTran = TeamlabMailboxDal.CreateMailDbContext(true))
{
if (TeamlabAddressDal.IsAddressAlreadyRegistered(aliasName, domain.Name, dbContextWithTran.DbManager))
{
throw new DuplicateNameException("You want to add already existed alias");
}
aliasDto = TeamlabAddressDal.AddMailboxAlias(Id, aliasName, addressBase.DateCreated,
domain.Id, domain.Name, domain.IsVerified, dbContextWithTran.DbManager);
_AddAlias(addressBase);
dbContextWithTran.CommitTransaction();
}
var alias = factory.CreateMailAddress(aliasDto.id, aliasDto.tenant, addressBase.LocalPart, domain);
Aliases.Add(alias);
return(alias);
}
protected override void _RemoveMember(MailAddressBase address)
{
var group = _serverData.Groups.Find(g => g.Address.ToString().Equals(Address.ToString()));
if (group.InAddresses.All(a => !Equals(address.ToString(), a.ToString())))
{
throw new ArgumentException();
}
group.InAddresses.Remove(address);
}
protected override void _AddMember(MailAddressBase address)
{
var group = _serverData.Groups.Find(g => g.Address.ToString().Equals(Address.ToString()));
if (group.InAddresses.Any(a => a.Equals(address)))
{
throw new DuplicateNameException("You want to add already existed address");
}
group.InAddresses.Add(address);
}
protected override void _RemoveAlias(MailAddressBase aliasToRemove)
{
var removeMailboxAlias = new SqlDelete(AliasTable.name)
.Where(AliasTable.Columns.address, aliasToRemove.ToString());
var dbManager = new PostfixAdminDbManager(Server.Id, Server.ConnectionString);
using (var db = dbManager.GetAdminDb())
{
db.ExecuteNonQuery(removeMailboxAlias);
}
}
protected override void _RemoveMember(MailAddressBase address)
{
using (var db = GetDb())
{
var members = _GetMembers(db);
if (members.All(a => a.name != address.ToString()))
{
throw new ArgumentException("You want to remove nonexistent address");
}
UpdateGroupMembers(db, members.Select(m => m.name).Where(m => m != address.ToString()));
}
}
public void AddMember(int mailboxAddressId, IMailServerFactory factory)
{
if (mailboxAddressId < 0)
{
throw new ArgumentException("Negative parameter value", "mailboxAddressId");
}
if (factory == null)
{
throw new ArgumentNullException("factory");
}
MailAddressDto addressDto;
using (var dbContextWithTran = TeamlabMailGroupDal.CreateMailDbContext(true))
{
addressDto = TeamlabAddressDal.GetMailAddress(mailboxAddressId, dbContextWithTran.DbManager);
if (addressDto == null)
{
throw new ArgumentException("Address not exists");
}
if (Address.Domain.Tenant != addressDto.domain.tenant)
{
throw new ArgumentException("Address not belongs to this domain");
}
if (InAddresses.Any(addr => addr.Id == mailboxAddressId))
{
throw new ArgumentException("Address already exists");
}
var mailboxAddress = new MailAddressBase(addressDto.name, new WebDomainBase(addressDto.domain.name));
TeamlabMailGroupDal.AddAddressToMailGroup(Id, mailboxAddressId, dbContextWithTran.DbManager);
_AddMember(mailboxAddress);
dbContextWithTran.CommitTransaction();
}
InAddresses.Add(factory.CreateMailAddress(addressDto.id, addressDto.tenant, addressDto.name,
factory.CreateWebDomain(addressDto.domain.id,
addressDto.domain.tenant,
addressDto.domain.name,
addressDto.domain.is_virified,
Server)));
}
protected override MailGroupBase _CreateMailGroup(MailAddressBase address, List <MailAddressBase> mailboxAddressList)
{
if (address == null)
{
throw new ArgumentNullException("address", "MockServer::_CreateMailGroup");
}
if (_serverData.Groups.Any(r => r.Address.ToString().Equals(address.ToString())))
{
throw new ArgumentException();
}
var resultGroup = new MailGroupBase(address, mailboxAddressList);
_serverData.Groups.Add(resultGroup);
return(resultGroup);
}
protected override void _AddMember(MailAddressBase address)
{
using (var db = GetDb())
{
var members = _GetMembers(db);
if (members.Any(a => a.name == address.ToString()))
{
throw new DuplicateNameException("You want to add already existed address");
}
var membersAddresses = members.Select(m => m.name).ToList();
membersAddresses.Add(address.ToString());
UpdateGroupMembers(db, membersAddresses);
}
}
protected override void _AddAlias(MailAddressBase aliasToAdd)
{
var insertMailboxAlias = new SqlInsert(AliasTable.name)
.InColumnValue(AliasTable.Columns.address, aliasToAdd.ToString())
.InColumnValue(AliasTable.Columns.redirect, Address.ToString())
.InColumnValue(AliasTable.Columns.domain, aliasToAdd.Domain.Name)
.InColumnValue(AliasTable.Columns.created, aliasToAdd.DateCreated)
.InColumnValue(AliasTable.Columns.modified, aliasToAdd.DateCreated)
.InColumnValue(AliasTable.Columns.active, true)
.InColumnValue(AliasTable.Columns.is_group, false);
var dbManager = new PostfixAdminDbManager(Server.Id, Server.ConnectionString);
using (var db = dbManager.GetAdminDb())
{
db.ExecuteNonQuery(insertMailboxAlias);
}
}
public void RemoveMember(int mailbox_address_id)
{
if (mailbox_address_id < 0)
{
throw new ArgumentException("Negative parameter value", "mailbox_address_id");
}
using (var db_context_with_tran = TeamlabMailGroupDal.CreateMailDbContext(true))
{
var address_dto = TeamlabAddressDal.GetMailAddress(mailbox_address_id, db_context_with_tran.DbManager);
if (address_dto == null)
{
throw new ArgumentException("Address not exists");
}
var mailbox_address = new MailAddressBase(address_dto.name, new WebDomainBase(address_dto.domain.name));
TeamlabMailGroupDal.DeleteAddressFromMailGroup(Id, mailbox_address_id, db_context_with_tran.DbManager);
_RemoveMember(mailbox_address);
db_context_with_tran.CommitTransaction();
}
}
protected abstract void _RemoveAlias(MailAddressBase aliasToRemove);
public override INotificationAddress CreateNotificationAddress(string localpart, string password, IWebDomain domain,
IMailServerFactory factory)
{
if (string.IsNullOrEmpty(localpart))
{
throw new ArgumentNullException("localpart");
}
if (string.IsNullOrEmpty(password))
{
throw new ArgumentNullException("password");
}
if (domain == null)
{
throw new ArgumentNullException("domain");
}
if (localpart.Length + domain.Name.Length > 318) // 318 because of @ sign
{
throw new ArgumentException("Address of mailbox exceed limitation of 319 characters.", "localpart");
}
var notificationAddressBase = new MailAddressBase(localpart, new WebDomainBase(domain));
var address = notificationAddressBase.ToString();
var smtpSettings = TeamlabServerDal.GetTenantServerSettings().FirstOrDefault(s => s.type == ServerType.Smtp);
if (smtpSettings == null)
{
throw new Exception("No smtp settings.");
}
var smtpLogin = smtpSettings.smtpLoginFormat.Replace("%EMAILADDRESS%", address)
.Replace("%EMAILLOCALPART%", localpart)
.Replace("%EMAILDOMAIN%", notificationAddressBase.Domain.Name.ToLowerInvariant())
.Replace("%EMAILHOSTNAME%", Path.GetFileNameWithoutExtension(notificationAddressBase.Domain.Name.ToLowerInvariant()));
var notificationAddressSettings =
SettingsManager.Instance.LoadSettings <NotificationAddressSettings>(Tenant);
if (!string.IsNullOrEmpty(notificationAddressSettings.NotificationAddress))
{
throw new Exception("Setting already exists. Remove first.");
}
_CreateNotificationAddress(address, password, localpart, domain.Name);
notificationAddressSettings = new NotificationAddressSettings {
NotificationAddress = address
};
if (!SettingsManager.Instance.SaveSettings(notificationAddressSettings, Tenant))
{
_DeleteNotificationAddress(address);
throw new Exception("Could not save notification address setting.");
}
var notificationAddress =
factory.CreateNotificationAddress(localpart, domain, smtpSettings.hostname, smtpSettings.port,
smtpLogin,
true, smtpSettings.socket_type, smtpSettings.authentication_type);
return(notificationAddress);
}
protected abstract MailGroupBase _CreateMailGroup(MailAddressBase address, List <MailAddressBase> mailboxAddressList);
protected abstract void _RemoveMember(MailAddressBase address);
protected abstract void _AddMember(MailAddressBase address);
protected override void _RemoveAlias(MailAddressBase alias_to_remove)
{
var mailbox = _serverData.Mailboxes.Find(m => m.Address.ToString().Equals(Address.ToString()));
mailbox.Aliases.Remove(alias_to_remove);
}
protected override void _AddAlias(MailAddressBase alias_to_add)
{
var mailbox = _serverData.Mailboxes.Find(m => m.Address.ToString().Equals(Address.ToString()));
mailbox.Aliases.Add(alias_to_add);
}
protected abstract void _AddAlias(MailAddressBase aliasToAdd);
