public void RemoveMailbox(MailBoxData mailBox)
{
var engine = new EngineFactory(mailBox.TenantId);
using (var daoFactory = new DaoFactory())
{
var serverAddressDao = daoFactory.CreateServerAddressDao(mailBox.TenantId);
var serverMailboxAddresses = serverAddressDao.GetList(mailBox.MailBoxId);
var serverMailboxAddress = serverMailboxAddresses.FirstOrDefault(a => !a.IsAlias && !a.IsMailGroup);
if (serverMailboxAddress == null)
{
throw new InvalidDataException("Mailbox address not found");
}
var serverDomainDao = daoFactory.CreateServerDomainDao(mailBox.TenantId);
var serverDomain = serverDomainDao.GetDomain(serverMailboxAddress.DomainId);
if (serverDomain == null)
{
throw new InvalidDataException("Domain not found");
}
var serverGroupDao = daoFactory.CreateServerGroupDao(mailBox.TenantId);
var serverGroups = serverGroupDao.GetList();
var serverDao = daoFactory.CreateServerDao();
var server = serverDao.Get(mailBox.TenantId);
var serverEngine = new Server.Core.ServerEngine(server.Id, server.ConnectionString);
var utcNow = DateTime.UtcNow;
using (var tx = daoFactory.DbManager.BeginTransaction(IsolationLevel.ReadUncommitted))
{
foreach (var serverGroup in serverGroups)
{
var addresses = serverAddressDao.GetGroupAddresses(serverGroup.Id);
var index = addresses.FindIndex(a => a.Id == serverMailboxAddress.Id);
if (index < 0)
{
continue;
}
addresses.RemoveAt(index);
if (addresses.Count == 0)
{
serverGroupDao.Delete(serverGroup.Id);
serverAddressDao.DeleteAddressesFromMailGroup(serverGroup.Id);
serverEngine.RemoveAlias(serverGroup.Address);
}
else
{
serverAddressDao.DeleteAddressFromMailGroup(serverGroup.Id, serverMailboxAddress.Id);
var goTo = string.Join(",",
addresses.Select(m => string.Format("{0}@{1}", m.AddressName, serverDomain.Name)));
var serverAddress = new Alias
{
Name = "",
Address = serverGroup.Address,
GoTo = goTo,
Domain = serverDomain.Name,
IsActive = true,
IsGroup = true,
Modified = utcNow,
Created = serverGroup.DateCreated
};
serverEngine.SaveAlias(serverAddress);
}
}
serverAddressDao.Delete(serverMailboxAddresses.Select(a => a.Id).ToList());
foreach (var mailboxAddress in serverMailboxAddresses)
{
serverEngine.RemoveAlias(string.Format("{0}@{1}", mailboxAddress.AddressName, serverDomain.Name));
}
engine.MailboxEngine.RemoveMailBox(daoFactory, mailBox, false);
serverEngine.RemoveMailbox(string.Format("{0}@{1}", serverMailboxAddress.AddressName,
serverDomain.Name));
tx.Commit();
}
}
}
public ServerDomainAddressData AddAlias(int mailboxId, string aliasName)
{
if (!IsAdmin)
{
throw new SecurityException("Need admin privileges.");
}
if (string.IsNullOrEmpty(aliasName))
{
throw new ArgumentException(@"Invalid alias name.", "aliasName");
}
if (mailboxId < 0)
{
throw new ArgumentException(@"Invalid mailbox id.", "mailboxId");
}
if (aliasName.Length > 64)
{
throw new ArgumentException(@"Local part of mailbox alias exceed limitation of 64 characters.", "aliasName");
}
if (!Parser.IsEmailLocalPartValid(aliasName))
{
throw new ArgumentException("Incorrect mailbox alias.");
}
var mailboxAliasName = aliasName.ToLowerInvariant();
using (var daoFactory = new DaoFactory())
{
var mailboxDao = daoFactory.CreateMailboxDao();
var mailbox = mailboxDao.GetMailBox(new ConcreteTenantMailboxExp(mailboxId, Tenant));
if (mailbox == null)
{
throw new ArgumentException("Mailbox not exists");
}
if (!mailbox.IsTeamlabMailbox)
{
throw new ArgumentException("Invalid mailbox type");
}
if (mailbox.Tenant == Defines.SHARED_TENANT_ID)
{
throw new InvalidOperationException("Adding mailbox alias is not allowed for shared domain.");
}
var mailAddress = new MailAddress(mailbox.Address);
var serverDomainDao = daoFactory.CreateServerDomainDao(Tenant);
var serverDomain = serverDomainDao.GetDomains().FirstOrDefault(d => d.Name == mailAddress.Host);
if (serverDomain == null)
{
throw new ArgumentException("Domain not exists");
}
var mailboxAddress = mailAddress.Address;
var serverAddressDao = daoFactory.CreateServerAddressDao(Tenant);
if (serverAddressDao.IsAddressAlreadyRegistered(mailboxAliasName, serverDomain.Name))
{
throw new DuplicateNameException("You want to create a mailbox with already existing address.");
}
var utcNow = DateTime.UtcNow;
var address = new ServerAddress
{
Id = 0,
Tenant = Tenant,
MailboxId = mailbox.Id,
DomainId = serverDomain.Id,
AddressName = mailboxAliasName,
IsAlias = true,
IsMailGroup = false,
DateCreated = utcNow
};
var aliasEmail = string.Format("{0}@{1}", mailboxAliasName, serverDomain.Name);
var serverDao = daoFactory.CreateServerDao();
var server = serverDao.Get(Tenant);
var engine = new Server.Core.ServerEngine(server.Id, server.ConnectionString);
using (var tx = daoFactory.DbManager.BeginTransaction(IsolationLevel.ReadUncommitted))
{
address.Id = serverAddressDao.Save(address);
var serverAddress = new Alias
{
Name = mailbox.Name,
Address = aliasEmail,
GoTo = mailboxAddress,
Domain = serverDomain.Name,
IsActive = true,
IsGroup = false,
Modified = utcNow,
Created = utcNow
};
engine.SaveAlias(serverAddress);
tx.Commit();
}
CacheEngine.Clear(mailbox.User);
return(new ServerDomainAddressData
{
Id = address.Id,
DomainId = address.DomainId,
Email = aliasEmail
});
}
}
public void RemoveMailGroupMember(int mailgroupId, int addressId)
{
if (!IsAdmin)
{
throw new SecurityException("Need admin privileges.");
}
if (addressId < 0)
{
throw new ArgumentException(@"Invalid address id.", "addressId");
}
if (mailgroupId < 0)
{
throw new ArgumentException(@"Invalid mailgroup id.", "mailgroupId");
}
using (var daoFactory = new DaoFactory())
{
var serverGroupDao = daoFactory.CreateServerGroupDao(Tenant);
var group = serverGroupDao.Get(mailgroupId);
if (group == null)
{
throw new Exception("Group not found");
}
var serverAddressDao = daoFactory.CreateServerAddressDao(Tenant);
var groupMembers = serverAddressDao.GetGroupAddresses(mailgroupId);
var removeMember = groupMembers.FirstOrDefault(a => a.Id == addressId);
if (removeMember == null)
{
throw new ArgumentException("Member not found");
}
groupMembers.Remove(removeMember);
if (groupMembers.Count == 0)
{
throw new Exception("Can't remove last member; Remove group.");
}
var serverDao = daoFactory.CreateServerDao();
var server = serverDao.Get(Tenant);
var groupAddress = serverAddressDao.Get(group.AddressId);
var serverDomainDao = daoFactory.CreateServerDomainDao(Tenant);
var serverDomain = serverDomainDao.GetDomain(groupAddress.DomainId);
var engine = new Server.Core.ServerEngine(server.Id, server.ConnectionString);
var utcNow = DateTime.UtcNow;
using (var tx = daoFactory.DbManager.BeginTransaction(IsolationLevel.ReadUncommitted))
{
serverAddressDao.DeleteAddressFromMailGroup(mailgroupId, addressId);
var goTo = string.Join(",",
groupMembers.Select(m => string.Format("{0}@{1}", m.AddressName, serverDomain.Name)));
var groupEmail = string.Format("{0}@{1}", groupAddress.AddressName, serverDomain.Name);
var serverAddress = new Alias
{
Name = "",
Address = groupEmail,
GoTo = goTo,
Domain = serverDomain.Name,
IsActive = true,
IsGroup = true,
Modified = utcNow,
Created = group.DateCreated
};
engine.SaveAlias(serverAddress);
tx.Commit();
}
}
CacheEngine.ClearAll();
}
public ServerDomainGroupData CreateMailGroup(string name, int domainId, List <int> addressIds)
{
if (!IsAdmin)
{
throw new SecurityException("Need admin privileges.");
}
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException(@"Invalid mailgroup name.", "name");
}
if (domainId < 0)
{
throw new ArgumentException(@"Invalid domain id.", "domainId");
}
if (name.Length > 64)
{
throw new ArgumentException(@"Local part of mailgroup exceed limitation of 64 characters.", "name");
}
if (!Parser.IsEmailLocalPartValid(name))
{
throw new ArgumentException(@"Incorrect group name.", "name");
}
if (!addressIds.Any())
{
throw new ArgumentException(@"Empty collection of address_ids.", "addressIds");
}
var mailgroupName = name.ToLowerInvariant();
using (var daoFactory = new DaoFactory())
{
var serverDomainDao = daoFactory.CreateServerDomainDao(Tenant);
var serverDomain = serverDomainDao.GetDomain(domainId);
if (serverDomain.Tenant == Defines.SHARED_TENANT_ID)
{
throw new InvalidOperationException("Creating mail group is not allowed for shared domain.");
}
var serverAddressDao = daoFactory.CreateServerAddressDao(Tenant);
if (serverAddressDao.IsAddressAlreadyRegistered(mailgroupName, serverDomain.Name))
{
throw new DuplicateNameException("You want to create a group with already existing address.");
}
var utcNow = DateTime.UtcNow;
var address = new ServerAddress
{
Id = 0,
Tenant = Tenant,
MailboxId = -1,
DomainId = serverDomain.Id,
AddressName = mailgroupName,
IsAlias = false,
IsMailGroup = true,
DateCreated = utcNow
};
var groupEmail = string.Format("{0}@{1}", mailgroupName, serverDomain.Name);
var groupAddressData = ServerMailboxEngine.ToServerDomainAddressData(address, groupEmail);
var newGroupMembers = serverAddressDao.GetList(addressIds);
var newGroupMemberIds = newGroupMembers.ConvertAll(m => m.Id);
var newGroupMemberDataList =
newGroupMembers.ConvertAll(m =>
ServerMailboxEngine.ToServerDomainAddressData(m,
string.Format("{0}@{1}", m.AddressName, serverDomain.Name)));
var goTo = string.Join(",",
newGroupMembers.Select(m => string.Format("{0}@{1}", m.AddressName, serverDomain.Name)));
var serverDao = daoFactory.CreateServerDao();
var server = serverDao.Get(Tenant);
var engine = new Server.Core.ServerEngine(server.Id, server.ConnectionString);
var group = new ServerGroup
{
Id = 0,
Tenant = Tenant,
Address = groupEmail,
AddressId = 0,
DateCreated = utcNow
};
using (var tx = daoFactory.DbManager.BeginTransaction(IsolationLevel.ReadUncommitted))
{
address.Id = serverAddressDao.Save(address);
group.AddressId = address.Id;
var serverGroupDao = daoFactory.CreateServerGroupDao(Tenant);
group.Id = serverGroupDao.Save(group);
serverAddressDao.AddAddressesToMailGroup(group.Id, newGroupMemberIds);
var serverAddress = new Alias
{
Name = "",
Address = groupEmail,
GoTo = goTo,
Domain = serverDomain.Name,
IsActive = true,
IsGroup = true,
Modified = utcNow,
Created = utcNow
};
engine.SaveAlias(serverAddress);
tx.Commit();
}
CacheEngine.ClearAll();
return(ToServerDomainGroupData(group.Id, groupAddressData, newGroupMemberDataList));
}
}
public ServerDomainGroupData AddMailGroupMember(int mailgroupId, int addressId)
{
if (!IsAdmin)
{
throw new SecurityException("Need admin privileges.");
}
if (addressId < 0)
{
throw new ArgumentException(@"Invalid address id.", "addressId");
}
if (mailgroupId < 0)
{
throw new ArgumentException(@"Invalid mailgroup id.", "mailgroupId");
}
using (var daoFactory = new DaoFactory())
{
var serverGroupDao = daoFactory.CreateServerGroupDao(Tenant);
var group = serverGroupDao.Get(mailgroupId);
if (group == null)
{
throw new Exception("Group not found");
}
var serverAddressDao = daoFactory.CreateServerAddressDao(Tenant);
var groupMembers = serverAddressDao.GetGroupAddresses(mailgroupId);
if (groupMembers.Exists(a => a.Id == addressId))
{
throw new DuplicateNameException("Member already exists");
}
var newMemberAddress = serverAddressDao.Get(addressId);
if (newMemberAddress == null)
{
throw new Exception("Member not found");
}
var serverDao = daoFactory.CreateServerDao();
var server = serverDao.Get(Tenant);
var engine = new Server.Core.ServerEngine(server.Id, server.ConnectionString);
var utcNow = DateTime.UtcNow;
ServerAddress groupAddress;
string groupEmail;
List <ServerDomainAddressData> newGroupMemberDataList;
using (var tx = daoFactory.DbManager.BeginTransaction(IsolationLevel.ReadUncommitted))
{
serverAddressDao.AddAddressesToMailGroup(mailgroupId, new List <int> {
addressId
});
groupMembers.Add(newMemberAddress);
groupAddress = serverAddressDao.Get(group.AddressId);
var serverDomainDao = daoFactory.CreateServerDomainDao(Tenant);
var serverDomain = serverDomainDao.GetDomain(groupAddress.DomainId);
var goTo = string.Join(",",
groupMembers.Select(m => string.Format("{0}@{1}", m.AddressName, serverDomain.Name)));
groupEmail = string.Format("{0}@{1}", groupAddress.AddressName, serverDomain.Name);
newGroupMemberDataList =
groupMembers.ConvertAll(m =>
ServerMailboxEngine.ToServerDomainAddressData(m,
string.Format("{0}@{1}", m.AddressName, serverDomain.Name)));
var serverAddress = new Alias
{
Name = "",
Address = groupEmail,
GoTo = goTo,
Domain = serverDomain.Name,
IsActive = true,
IsGroup = true,
Modified = utcNow,
Created = utcNow
};
engine.SaveAlias(serverAddress);
tx.Commit();
}
var groupAddressData = ServerMailboxEngine.ToServerDomainAddressData(groupAddress, groupEmail);
CacheEngine.ClearAll();
return(ToServerDomainGroupData(group.Id, groupAddressData, newGroupMemberDataList));
}
}
