public MailSignatureData SaveSignature(int mailboxId, string html, bool isActive)
{
if (!string.IsNullOrEmpty(html))
{
var imagesReplacer = new StorageManager(Tenant, User, Log);
html = imagesReplacer.ChangeEditorImagesLinks(html, mailboxId);
}
CacheEngine.Clear(User);
var signature = new MailboxSignature
{
MailboxId = mailboxId,
Tenant = Tenant,
Html = html,
IsActive = isActive
};
using (var daoFactory = new DaoFactory())
{
var result = daoFactory
.CreateMailboxSignatureDao(Tenant, User)
.SaveSignature(signature);
if (result <= 0)
{
throw new Exception("Save failed");
}
}
return(ToMailMailSignature(signature));
}
public AccountInfo CreateAccount(MailBoxData mbox, out LoginResult loginResult)
{
if (mbox == null)
{
throw new NullReferenceException("mbox");
}
using (var client = new MailClient(mbox, CancellationToken.None,
certificatePermit: Defines.SslCertificatesErrorPermit, log: Log))
{
loginResult = client.TestLogin();
}
if (!loginResult.IngoingSuccess || !loginResult.OutgoingSuccess)
{
return(null);
}
if (!MailboxEngine.SaveMailBox(mbox))
{
throw new Exception(string.Format("SaveMailBox {0} failed", mbox.EMail));
}
CacheEngine.Clear(User);
var account = new AccountInfo(mbox.MailBoxId, mbox.EMailView, mbox.Name, mbox.Enabled, mbox.QuotaError,
MailBoxData.AuthProblemType.NoProblems, new MailSignatureData(mbox.MailBoxId, Tenant, "", false),
new MailAutoreplyData(mbox.MailBoxId, Tenant, false, false, false, DateTime.MinValue,
DateTime.MinValue, string.Empty, string.Empty), false, mbox.EMailInFolder, false, false);
return(account);
}
public void RemoveMailBox(MailBoxData mailbox, bool needRecalculateFolders = true)
{
if (mailbox.MailBoxId <= 0)
{
throw new Exception("MailBox id is 0");
}
long freedQuotaSize;
using (var db = new DbManager(Defines.CONNECTION_STRING_NAME, Defines.RemoveMailboxTimeout))
{
var daoFactory = new DaoFactory(db);
using (var tx = daoFactory.DbManager.BeginTransaction())
{
freedQuotaSize = RemoveMailBoxInfo(daoFactory, mailbox);
tx.Commit();
}
}
var engine = new EngineFactory(mailbox.TenantId, mailbox.UserId, Log);
engine.QuotaEngine.QuotaUsedDelete(freedQuotaSize);
CacheEngine.Clear(mailbox.UserId);
engine.IndexEngine.Remove(mailbox);
if (!needRecalculateFolders)
{
return;
}
engine.OperationEngine.RecalculateFolders();
}
public AccountInfo CreateAccountSimple(string email, string password, out List <LoginResult> loginResults)
{
MailBoxData mbox = null;
var domain = email.Substring(email.IndexOf('@') + 1);
var engine = new EngineFactory(Tenant, User);
var mailboxSettings = engine.MailBoxSettingEngine.GetMailBoxSettings(domain);
if (mailboxSettings == null)
{
throw new Exception("Unknown mail provider settings.");
}
var testMailboxes = mailboxSettings.ToMailboxList(email, password, Tenant, User);
loginResults = new List <LoginResult>();
foreach (var mb in testMailboxes)
{
LoginResult loginResult;
using (var client = new MailClient(mb, CancellationToken.None, Defines.TcpTimeout,
Defines.SslCertificatesErrorPermit, log: Log))
{
loginResult = client.TestLogin();
}
loginResults.Add(loginResult);
if (!loginResult.IngoingSuccess || !loginResult.OutgoingSuccess)
{
continue;
}
mbox = mb;
break;
}
if (mbox == null)
{
return(null);
}
if (!MailboxEngine.SaveMailBox(mbox))
{
throw new Exception(string.Format("SaveMailBox {0} failed", email));
}
CacheEngine.Clear(User);
var account = new AccountInfo(mbox.MailBoxId, mbox.EMailView, mbox.Name, mbox.Enabled, mbox.QuotaError,
MailBoxData.AuthProblemType.NoProblems, new MailSignatureData(mbox.MailBoxId, Tenant, "", false),
new MailAutoreplyData(mbox.MailBoxId, Tenant, false, false, false, DateTime.MinValue,
DateTime.MinValue, string.Empty, string.Empty), false, mbox.EMailInFolder, false, false);
return(account);
}
public int SetAccountEnable(MailAddress address, bool enabled, out LoginResult loginResult)
{
if (address == null)
{
throw new ArgumentNullException("address");
}
var engine = new EngineFactory(Tenant);
var tuple = engine.MailboxEngine.GetMailboxFullInfo(new СoncreteUserMailboxExp(address, Tenant, User));
if (tuple == null)
{
throw new NullReferenceException(string.Format("Account wasn't found by email: {0}", address.Address));
}
if (enabled)
{
// Check account connection setting on activation
using (var client = new MailClient(tuple.Item1, CancellationToken.None,
certificatePermit: Defines.SslCertificatesErrorPermit, log: Log))
{
loginResult = client.TestLogin();
}
if (!loginResult.IngoingSuccess || !loginResult.OutgoingSuccess)
{
return(-1);
}
}
int mailboxId;
using (var daoFactory = new DaoFactory())
{
var daoMailbox = daoFactory.CreateMailboxDao();
loginResult = null;
mailboxId =
daoMailbox.Enable(new СoncreteUserMailboxExp(tuple.Item2.Id, tuple.Item2.Tenant, tuple.Item2.User),
enabled)
? tuple.Item2.Id
: -1;
}
if (mailboxId == -1)
{
return(mailboxId);
}
CacheEngine.Clear(User);
return(mailboxId);
}
public AccountInfo CreateAccountOAuth(string code, byte type)
{
var oAuthToken = OAuth20TokenHelper.GetAccessToken <GoogleLoginProvider>(code);
if (oAuthToken == null)
{
throw new Exception(@"Empty oauth token");
}
var loginProfile = GoogleLoginProvider.Instance.GetLoginProfile(oAuthToken.AccessToken);
var email = loginProfile.EMail;
if (string.IsNullOrEmpty(email))
{
throw new Exception(@"Empty email");
}
var beginDate = DateTime.UtcNow.Subtract(new TimeSpan(MailBoxData.DefaultMailLimitedTimeDelta));
var mboxImap = MailboxEngine.GetDefaultMailboxData(email, "", (AuthorizationServiceType)type,
true, false);
mboxImap.OAuthToken = oAuthToken.ToJson();
mboxImap.BeginDate = beginDate; // Apply restrict for download
if (!MailboxEngine.SaveMailBox(mboxImap, (AuthorizationServiceType)type))
{
throw new Exception(string.Format("SaveMailBox {0} failed", email));
}
CacheEngine.Clear(User);
if (Defines.IsSignalRAvailable)
{
var engine = new EngineFactory(Tenant, User);
engine.AccountEngine.SetAccountsActivity();
}
var account = new AccountInfo(mboxImap.MailBoxId, mboxImap.EMailView, mboxImap.Name, mboxImap.Enabled,
mboxImap.QuotaError,
MailBoxData.AuthProblemType.NoProblems, new MailSignatureData(mboxImap.MailBoxId, Tenant, "", false),
new MailAutoreplyData(mboxImap.MailBoxId, Tenant, false, false, false, DateTime.MinValue,
DateTime.MinValue, string.Empty, string.Empty), true, mboxImap.EMailInFolder, false, false);
return(account);
}
public void RemoveMailGroup(int id)
{
if (!IsAdmin)
{
throw new SecurityException("Need admin privileges.");
}
if (id < 0)
{
throw new ArgumentException(@"Invalid mailgroup id.", "id");
}
using (var daoFactory = new DaoFactory())
{
var serverGroupDao = daoFactory.CreateServerGroupDao(Tenant);
var group = serverGroupDao.Get(id);
if (group == null)
{
throw new Exception("Group not found");
}
var serverAddressDao = daoFactory.CreateServerAddressDao(Tenant);
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))
{
serverGroupDao.Delete(id);
serverAddressDao.DeleteAddressesFromMailGroup(id);
serverAddressDao.Delete(group.AddressId);
engine.RemoveAlias(group.Address);
tx.Commit();
}
}
CacheEngine.ClearAll();
}
public List <AccountInfo> GetAccountInfoList()
{
var accountInfoList = CacheEngine.Get(User);
if (accountInfoList != null)
{
return(accountInfoList);
}
List <Account> accounts;
List <MailSignatureData> signatures;
List <MailAutoreplyData> autoreplies;
using (var daoFactory = new DaoFactory())
{
accounts = daoFactory.CreateAccountDao(Tenant, User)
.GetAccounts();
var mailboxIds = accounts.Select(a => a.MailboxId).ToList();
signatures = daoFactory.CreateMailboxSignatureDao(Tenant, User)
.GetSignatures(mailboxIds)
.ConvertAll(s => new MailSignatureData(s.MailboxId, s.Tenant, s.Html, s.IsActive))
.ToList();
autoreplies = daoFactory.CreateMailboxAutoreplyDao(Tenant, User)
.GetAutoreplies(mailboxIds)
.ConvertAll(
r =>
new MailAutoreplyData(r.MailboxId, r.Tenant, r.TurnOn, r.OnlyContacts, r.TurnOnToDate,
r.FromDate, r.ToDate, r.Subject, r.Html))
.ToList();
}
accountInfoList = ToAccountInfoList(accounts, signatures, autoreplies);
CacheEngine.Set(User, accountInfoList);
return(accountInfoList);
}
public bool SetAccountEmailInFolder(int mailboxId, string emailInFolder)
{
if (mailboxId < 0)
{
throw new ArgumentNullException("mailboxId");
}
bool saved;
using (var daoFactory = new DaoFactory())
{
var daoMailbox = daoFactory.CreateMailboxDao();
var mailbox = daoMailbox.GetMailBox(
new СoncreteUserMailboxExp(
mailboxId,
Tenant, User)
);
if (mailbox == null)
{
return(false);
}
saved = daoMailbox.SetMailboxEmailIn(mailbox, emailInFolder);
}
if (!saved)
{
return(saved);
}
CacheEngine.Clear(User);
return(saved);
}
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));
}
}
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 AccountInfo UpdateAccount(MailBoxData newMailBoxData, out LoginResult loginResult)
{
if (newMailBoxData == null)
{
throw new NullReferenceException("mbox");
}
Mailbox mbox;
using (var daoFactory = new DaoFactory())
{
var daoMailbox = daoFactory.CreateMailboxDao();
mbox =
daoMailbox.GetMailBox(
new СoncreteUserMailboxExp(
newMailBoxData.EMail,
Tenant, User));
if (null == mbox)
{
throw new ArgumentException("Mailbox with specified email doesn't exist.");
}
if (mbox.IsTeamlabMailbox)
{
throw new ArgumentException("Mailbox with specified email can't be updated");
}
if (!string.IsNullOrEmpty(mbox.OAuthToken))
{
var needSave = false;
if (!mbox.Name.Equals(newMailBoxData.Name))
{
mbox.Name = newMailBoxData.Name;
needSave = true;
}
if (!mbox.BeginDate.Equals(newMailBoxData.BeginDate))
{
mbox.BeginDate = newMailBoxData.BeginDate;
mbox.ImapIntervals = null;
needSave = true;
}
if (needSave)
{
daoMailbox.SaveMailBox(mbox);
CacheEngine.Clear(User);
}
var accountInfo = new AccountInfo(mbox.Id, mbox.Address, mbox.Name, mbox.Enabled, mbox.QuotaError,
MailBoxData.AuthProblemType.NoProblems, new MailSignatureData(mbox.Id, Tenant, "", false),
new MailAutoreplyData(mbox.Id, Tenant, false, false, false, DateTime.MinValue,
DateTime.MinValue, string.Empty, string.Empty), false, mbox.EmailInFolder, false, false);
loginResult = new LoginResult
{
Imap = mbox.Imap,
IngoingSuccess = true,
OutgoingSuccess = true
};
return(accountInfo);
}
}
newMailBoxData.Password = string.IsNullOrEmpty(newMailBoxData.Password)
? mbox.Password
: newMailBoxData.Password;
newMailBoxData.SmtpPassword = string.IsNullOrEmpty(newMailBoxData.SmtpPassword)
? mbox.SmtpPassword
: newMailBoxData.SmtpPassword;
newMailBoxData.Imap = mbox.Imap;
return(CreateAccount(newMailBoxData, out loginResult));
}
public AccountInfo UpdateAccountOAuth(int mailboxId, string code, byte type)
{
if (string.IsNullOrEmpty(code))
{
throw new ArgumentException(@"Empty OAuth code", "code");
}
var oAuthToken = OAuth20TokenHelper.GetAccessToken <GoogleLoginProvider>(code);
if (oAuthToken == null)
{
throw new Exception(@"Empty OAuth token");
}
if (string.IsNullOrEmpty(oAuthToken.AccessToken))
{
throw new Exception(@"Empty OAuth AccessToken");
}
if (string.IsNullOrEmpty(oAuthToken.RefreshToken))
{
throw new Exception(@"Empty OAuth RefreshToken");
}
if (oAuthToken.IsExpired)
{
throw new Exception(@"OAuth token is expired");
}
var loginProfile = GoogleLoginProvider.Instance.GetLoginProfile(oAuthToken.AccessToken);
var email = loginProfile.EMail;
if (string.IsNullOrEmpty(email))
{
throw new Exception(@"Empty email");
}
Mailbox mbox;
using (var daoFactory = new DaoFactory())
{
var daoMailbox = daoFactory.CreateMailboxDao();
mbox = daoMailbox.GetMailBox(
new СoncreteUserMailboxExp(
mailboxId,
Tenant, User));
if (null == mbox)
{
throw new ArgumentException("Mailbox with specified email doesn't exist.");
}
if (mbox.IsTeamlabMailbox || string.IsNullOrEmpty(mbox.OAuthToken))
{
throw new ArgumentException("Mailbox with specified email can't be updated");
}
if (!mbox.Address.Equals(email, StringComparison.InvariantCultureIgnoreCase))
{
throw new ArgumentException("Mailbox with specified email can't be updated");
}
mbox.OAuthToken = oAuthToken.ToJson();
var result = daoMailbox.SaveMailBox(mbox);
mbox.Id = result;
}
CacheEngine.Clear(User);
if (Defines.IsSignalRAvailable)
{
var engine = new EngineFactory(Tenant, User);
engine.AccountEngine.SetAccountsActivity();
}
var accountInfo = new AccountInfo(mbox.Id, mbox.Address, mbox.Name, mbox.Enabled, mbox.QuotaError,
MailBoxData.AuthProblemType.NoProblems, new MailSignatureData(mbox.Id, Tenant, "", false),
new MailAutoreplyData(mbox.Id, Tenant, false, false, false, DateTime.MinValue,
DateTime.MinValue, string.Empty, string.Empty), true, mbox.EmailInFolder, false, false);
return(accountInfo);
}
public ServerMailboxData CreateMailbox(string name, string localPart, int domainId, string userId)
{
ServerMailboxData mailboxData;
using (var daoFactory = new DaoFactory())
{
var serverDomainDao = daoFactory.CreateServerDomainDao(Tenant);
var serverDomain = serverDomainDao.GetDomain(domainId);
var isSharedDomain = serverDomain.Tenant == Defines.SHARED_TENANT_ID;
if (!IsAdmin && !isSharedDomain)
{
throw new SecurityException("Need admin privileges.");
}
var tenantQuota = CoreContext.TenantManager.GetTenantQuota(Tenant);
if (isSharedDomain &&
(tenantQuota.Trial ||
tenantQuota.Free))
{
throw new SecurityException("Not available in unpaid version");
}
if (string.IsNullOrEmpty(localPart))
{
throw new ArgumentException(@"Invalid local part.", "localPart");
}
if (domainId < 0)
{
throw new ArgumentException(@"Invalid domain id.", "domainId");
}
if (name.Length > 255)
{
throw new ArgumentException(@"Sender name exceed limitation of 64 characters.", "name");
}
Guid user;
if (!Guid.TryParse(userId, out user))
{
throw new ArgumentException(@"Invalid user id.", "userId");
}
if (isSharedDomain && !IsAdmin && user != SecurityContext.CurrentAccount.ID)
{
throw new SecurityException(
"Creation of a shared mailbox is allowed only for the current account if user is not admin.");
}
var teamlabAccount = CoreContext.Authentication.GetAccountByID(user);
if (teamlabAccount == null)
{
throw new InvalidDataException("Unknown user.");
}
var userInfo = CoreContext.UserManager.GetUsers(user);
if (userInfo.IsVisitor())
{
throw new InvalidDataException("User is visitor.");
}
if (localPart.Length > 64)
{
throw new ArgumentException(@"Local part of mailbox exceed limitation of 64 characters.",
"localPart");
}
if (!Parser.IsEmailLocalPartValid(localPart))
{
throw new ArgumentException("Incorrect local part of mailbox.");
}
var serverAddressDao = daoFactory.CreateServerAddressDao(Tenant);
if (serverAddressDao.IsAddressAlreadyRegistered(localPart, serverDomain.Name))
{
throw new DuplicateNameException("You want to create a mailbox with already existing address.");
}
if (Defines.ServerDomainMailboxPerUserLimit > 0)
{
var engineFactory = new EngineFactory(Tenant, userId);
var accounts = engineFactory.AccountEngine.GetAccountInfoList();
var countDomainMailboxes =
accounts.Count(a =>
a.IsTeamlabMailbox &&
Parser.ParseAddress(a.Email)
.Domain.Equals(serverDomain.Name, StringComparison.InvariantCultureIgnoreCase));
if (countDomainMailboxes >= Defines.ServerDomainMailboxPerUserLimit)
{
throw new ArgumentOutOfRangeException(
string.Format("Count of user's mailboxes must be less or equal {0}.",
Defines.ServerDomainMailboxPerUserLimit));
}
}
var serverDao = daoFactory.CreateServerDao();
var server = serverDao.Get(Tenant);
var mailboxLocalPart = localPart.ToLowerInvariant();
var login = string.Format("{0}@{1}", mailboxLocalPart, serverDomain.Name);
var password = PasswordGenerator.GenerateNewPassword(12);
var utcNow = DateTime.UtcNow;
var mailboxDao = daoFactory.CreateMailboxDao();
using (var tx = daoFactory.DbManager.BeginTransaction(IsolationLevel.ReadUncommitted))
{
var mailbox = new Mailbox
{
Id = 0,
Tenant = Tenant,
User = userId,
Name = name,
Address = login,
OAuthToken = null,
OAuthType = (int)AuthorizationServiceType.None,
ServerId = server.ImapSettingsId,
Password = password,
SmtpServerId = server.SmtpSettingsId,
SmtpPassword = password,
SizeLast = 0,
MsgCountLast = 0,
BeginDate = Defines.MinBeginDate,
Imap = true,
Enabled = true,
IsTeamlabMailbox = true,
IsRemoved = false,
DateCreated = utcNow
};
mailbox.Id = mailboxDao.SaveMailBox(mailbox);
var address = new ServerAddress
{
Id = 0,
Tenant = Tenant,
MailboxId = mailbox.Id,
DomainId = serverDomain.Id,
AddressName = localPart,
IsAlias = false,
IsMailGroup = false,
DateCreated = utcNow
};
address.Id = serverAddressDao.Save(address);
var engine = new Server.Core.ServerEngine(server.Id, server.ConnectionString);
var maildir = PostfixMaildirUtil.GenerateMaildirPath(serverDomain.Name, localPart, utcNow);
var serverMailbox = new Server.Core.Entities.Mailbox
{
Name = name,
Password = password,
Login = login,
LocalPart = localPart,
Domain = serverDomain.Name,
Active = true,
Quota = 0,
Maldir = maildir,
Modified = utcNow,
Created = utcNow,
};
var serverAddress = new Alias
{
Name = name,
Address = login,
GoTo = login,
Domain = serverDomain.Name,
IsActive = true,
IsGroup = false,
Modified = utcNow,
Created = utcNow
};
engine.SaveMailbox(serverMailbox, serverAddress);
tx.Commit();
CacheEngine.Clear(userId);
mailboxData = ToMailboxData(mailbox, ToServerDomainAddressData(address, login),
new List <ServerDomainAddressData>());
}
}
return(mailboxData);
}
public ServerMailboxData UpdateMailboxDisplayName(int mailboxId, string name)
{
using (var daoFactory = new DaoFactory())
{
var serverAddressDao = daoFactory.CreateServerAddressDao(Tenant);
var serverMailboxAddresses = serverAddressDao.GetList(mailboxId);
if (!serverMailboxAddresses.Any())
{
throw new ArgumentException("Mailbox not found");
}
var serverMailboxAddress = serverMailboxAddresses.FirstOrDefault(a => !a.IsAlias && !a.IsMailGroup);
if (serverMailboxAddress == null)
{
throw new ArgumentException("Mailbox not found");
}
var serverMailboxAliases = serverMailboxAddresses.Where(a => a.IsAlias).ToList();
var serverDomainDao = daoFactory.CreateServerDomainDao(Tenant);
var serverDomain = serverDomainDao.GetDomain(serverMailboxAddress.DomainId);
var isSharedDomain = serverDomain.Tenant == Defines.SHARED_TENANT_ID;
if (!IsAdmin && !isSharedDomain)
{
throw new SecurityException("Need admin privileges.");
}
var tenantQuota = CoreContext.TenantManager.GetTenantQuota(Tenant);
if (isSharedDomain &&
(tenantQuota.Trial ||
tenantQuota.Free))
{
throw new SecurityException("Not available in unpaid version");
}
if (name.Length > 255)
{
throw new ArgumentException(@"Sender name exceed limitation of 64 characters.", "name");
}
var mailboxDao = daoFactory.CreateMailboxDao();
var serverMailbox =
mailboxDao.GetMailBox(new ConcreteTenantServerMailboxExp(mailboxId, Tenant, false));
serverMailbox.Name = name;
mailboxDao.SaveMailBox(serverMailbox);
CacheEngine.Clear(serverMailbox.User);
var address = ToServerDomainAddressData(serverMailboxAddress, serverDomain);
var aliases = serverMailboxAliases.ConvertAll(a => ToServerDomainAddressData(a, serverDomain));
var mailboxData = ToMailboxData(serverMailbox, address, aliases);
return(mailboxData);
}
}
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 void RemoveAlias(int mailboxId, int addressId)
{
if (!IsAdmin)
{
throw new SecurityException("Need admin privileges.");
}
if (mailboxId < 0)
{
throw new ArgumentException(@"Invalid address id.", "mailboxId");
}
using (var daoFactory = new DaoFactory())
{
var mailboxDao = daoFactory.CreateMailboxDao();
var mailbox = mailboxDao.GetMailBox(new ConcreteTenantServerMailboxExp(mailboxId, Tenant, false));
if (mailbox == null)
{
throw new ArgumentException("Mailbox not exists");
}
if (!mailbox.IsTeamlabMailbox)
{
throw new ArgumentException("Invalid mailbox type");
}
var serverAddressDao = daoFactory.CreateServerAddressDao(Tenant);
var alias = serverAddressDao.Get(addressId);
if (!alias.IsAlias)
{
throw new ArgumentException("Address is not alias");
}
var serverDomainDao = daoFactory.CreateServerDomainDao(Tenant);
var serverDomain = serverDomainDao.GetDomain(alias.DomainId);
if (serverDomain == null)
{
throw new ArgumentException("Domain not exists");
}
var aliasEmail = string.Format("{0}@{1}", alias.AddressName, 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))
{
serverAddressDao.Delete(addressId);
engine.RemoveAlias(aliasEmail);
tx.Commit();
}
CacheEngine.Clear(mailbox.User);
}
}
