private void RestoreDomainsByMail(List<string> domains, int packageId, int mailDomainId)
{
// add/update domains/pointers
foreach (string domainName in domains)
{
DomainInfo domain = ServerController.GetDomain(domainName);
if (domain == null)
{
domain = new DomainInfo();
domain.DomainName = domainName;
domain.PackageId = packageId;
domain.MailDomainId = mailDomainId;
ServerController.AddDomainItem(domain);
}
else
{
domain.MailDomainId = mailDomainId;
ServerController.UpdateDomain(domain);
}
}
}
public static int AddDomain(DomainInfo domain)
{
return AddDomain(domain, false);
}
public static int AddDomainItem(DomainInfo domain)
{
return DataProvider.AddDomain(SecurityContext.User.UserId,
domain.PackageId, domain.ZoneItemId, domain.DomainName, domain.HostingAllowed,
domain.WebSiteId, domain.MailDomainId, domain.IsSubDomain, domain.IsInstantAlias, domain.IsDomainPointer);
}
private void FillRecordData(IEnumerable<DnsRecordInfo> records, DomainInfo domain, string dnsServer)
{
foreach (var record in records)
{
FillRecordData(record, domain, dnsServer);
}
}
public static int ImporHostHeader(int userId, int packageId, int siteId)
{
WebSite siteItem = (WebSite)PackageController.GetPackageItem(siteId);
if (siteItem == null)
return -1;
// load live site from service
WebServer web = new WebServer();
ServiceProviderProxy.Init(web, siteItem.ServiceId);
// Verify if already exists
List<DomainInfo> domains = ServerController.GetDomains(packageId);
// Get hostheader
foreach (ServerBinding b in web.GetSiteBindings(siteItem.SiteId))
{
if ((!DoesHeaderExistInDomains(b.Host.ToLower(), domains)) && (!string.IsNullOrEmpty(b.Host)))
{
// If not get domain info and add to domains
int domainId = FindDomainForHeader(b.Host.ToLower(), domains);
if (domainId > 0)
{
DomainInfo domain = ServerController.GetDomain(domainId);
DomainInfo newDomain = new DomainInfo();
newDomain.DomainName = b.Host.ToLower();
newDomain.PackageId = domain.PackageId;
newDomain.IsDomainPointer = true;
int newDomainID = ServerController.AddDomain(newDomain, domain.IsInstantAlias, false);
if (newDomainID > 0)
{
newDomain = ServerController.GetDomain(newDomainID);
if (newDomain != null)
{
newDomain.WebSiteId = siteId;
newDomain.ZoneItemId = domain.ZoneItemId;
newDomain.DomainItemId = domain.DomainId;
ServerController.UpdateDomain(newDomain);
}
}
}
}
}
return 0;
}
public static DomainInfo UpdateDomainWhoisData(DomainInfo domain)
{
try
{
var idn = new IdnMapping();
var whoisResult = WhoisClient.Query(idn.GetAscii(domain.DomainName).ToLowerInvariant());
string creationDateString = ParseWhoisDomainInfo(whoisResult.Raw, _createdDatePatterns);
string expirationDateString = ParseWhoisDomainInfo(whoisResult.Raw, _expiredDatePatterns);
domain.CreationDate = ParseDate(creationDateString);
domain.ExpirationDate = ParseDate(expirationDateString);
domain.RegistrarName = ParseWhoisDomainInfo(whoisResult.Raw, _registrarNamePatterns);
domain.LastUpdateDate = DateTime.Now;
DataProvider.UpdateWhoisDomainInfo(domain.DomainId, domain.CreationDate, domain.ExpirationDate, DateTime.Now, domain.RegistrarName);
}
catch (Exception e)
{
//wrong domain
}
return domain;
}
public int AddDomain(DomainInfo domain)
{
return(ServerController.AddDomain(domain));
}
private string ExpandVariables(string str, InstallationInfo inst)
{
str = ReplaceTemplateVariable(str, "installer.contentpath", inst[PROPERTY_CONTENT_PATH]);
str = ReplaceTemplateVariable(str, "installer.website", webSiteName);
str = ReplaceTemplateVariable(str, "installer.virtualdir", inst.VirtualDir);
string fullWebPath = webSiteName;
if (!String.IsNullOrEmpty(inst.VirtualDir))
{
fullWebPath += "/" + inst.VirtualDir;
}
// try to load domain info
DomainInfo domain = ServerController.GetDomain(webSiteName);
string fullWebPathPrefix = (domain != null && domain.IsSubDomain) ? "" : "www.";
// app URLs
if (appUrls == null)
{
// read web pointers
List <DomainInfo> sitePointers = WebServerController.GetWebSitePointers(inst.WebSiteId);
StringBuilder sb = new StringBuilder();
sb.Append("<urls>");
sb.Append("<url value=\"").Append(fullWebPath).Append("\"/>");
foreach (DomainInfo pointer in sitePointers)
{
string pointerWebPath = pointer.DomainName;
if (!String.IsNullOrEmpty(inst.VirtualDir))
{
pointerWebPath += "/" + inst.VirtualDir;
}
sb.Append("<url value=\"").Append(pointerWebPath).Append("\"/>");
}
sb.Append("</urls>");
appUrls = sb.ToString();
}
str = ReplaceTemplateVariable(str, "installer.appurls", appUrls);
string slashVirtualDir = "";
if (!String.IsNullOrEmpty(inst.VirtualDir))
{
slashVirtualDir = "/" + inst.VirtualDir;
}
str = ReplaceTemplateVariable(str, "installer.slashvirtualdir", slashVirtualDir);
str = ReplaceTemplateVariable(str, "installer.website.www", fullWebPathPrefix + webSiteName);
str = ReplaceTemplateVariable(str, "installer.fullwebpath", fullWebPath);
str = ReplaceTemplateVariable(str, "installer.fullwebpath.www", fullWebPathPrefix + fullWebPath);
//Replace ObjectQualifierNormalized which is not defined on portal
str = ReplaceTemplateVariable(str, "ObjectQualifierNormalized", "");
/*
* Application installer variable 'installer.database.server' is obsolete
* and should not be used to install Application Packs.
* Instead, please use the following two variables:
* - installer.database.server.external - defines external database address
* - installer.database.server.internal - defines internal database address
*
* See TFS Issue 952 for details.
*/
//apply external database address
str = ReplaceTemplateVariable(str, "installer.database.server",
((serverIpAddressExternal != null) ? serverIpAddressExternal : ""));
str = ReplaceTemplateVariable(str, "installer.database.server.external",
((serverIpAddressExternal != null) ? serverIpAddressExternal : String.Empty));
//apply internal database address
str = ReplaceTemplateVariable(str, "installer.database.server.internal",
((serverIpAddressInternal != null) ? serverIpAddressInternal : String.Empty));
str = ReplaceTemplateVariable(str, "installer.database", inst.DatabaseName);
str = ReplaceTemplateVariable(str, "installer.database.user", inst.Username);
str = ReplaceTemplateVariable(str, "installer.database.password",
((inst.Password != null) ? inst.Password : ""));
foreach (string[] pair in inst.PropertiesArray)
{
str = ReplaceTemplateVariable(str, pair[0], pair[1]);
}
return(str);
}
public int CreateUserAccountInternal(int parentPackageId, string username, string password,
int roleId, string firstName, string lastName, string email, string secondaryEmail, bool htmlMail,
bool sendAccountLetter,
bool createPackage, int planId, bool sendPackageLetter,
string domainName, bool tempDomain, bool createWebSite,
bool createFtpAccount, string ftpAccountName, bool createMailAccount, string hostName, bool createZoneRecord)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
| DemandAccount.IsReseller);
if (accountCheck < 0)
{
return(accountCheck);
}
// check package
int packageCheck = SecurityContext.CheckPackage(parentPackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// check if username exists
if (UserController.UserExists(username))
{
return(BusinessErrorCodes.ERROR_ACCOUNT_WIZARD_USER_EXISTS);
}
// check if domain exists
int checkDomainResult = ServerController.CheckDomain(domainName);
if (checkDomainResult < 0)
{
return(checkDomainResult);
}
// check if FTP account exists
if (String.IsNullOrEmpty(ftpAccountName))
{
ftpAccountName = username;
}
if (FtpServerController.FtpAccountExists(ftpAccountName))
{
return(BusinessErrorCodes.ERROR_ACCOUNT_WIZARD_FTP_ACCOUNT_EXISTS);
}
// load parent package
PackageInfo parentPackage = PackageController.GetPackage(parentPackageId);
/********************************************
* CREATE USER ACCOUNT
* *****************************************/
UserInfo user = new UserInfo();
user.RoleId = roleId;
user.StatusId = (int)UserStatus.Active;
user.OwnerId = parentPackage.UserId;
user.IsDemo = false;
user.IsPeer = false;
// account info
user.FirstName = firstName;
user.LastName = lastName;
user.Email = email;
user.SecondaryEmail = secondaryEmail;
user.Username = username;
// user.Password = password;
user.HtmlMail = htmlMail;
// add a new user
createdUserId = UserController.AddUser(user, false, password);
if (createdUserId < 0)
{
// exit
return(createdUserId);
}
userCreated = true;
// create package
// load hosting plan
createdPackageId = -1;
if (createPackage)
{
try
{
HostingPlanInfo plan = PackageController.GetHostingPlan(planId);
PackageResult packageResult = PackageController.AddPackage(
createdUserId, planId, plan.PlanName, "", (int)PackageStatus.Active, DateTime.Now, false);
createdPackageId = packageResult.Result;
}
catch (Exception ex)
{
// error while adding package
// remove user account
UserController.DeleteUser(createdUserId);
throw ex;
}
if (createdPackageId < 0)
{
// rollback wizard
Rollback();
// return code
return(createdPackageId);
}
// create domain
int domainId = 0;
if ((createWebSite || createMailAccount || createZoneRecord) && !String.IsNullOrEmpty(domainName))
{
try
{
DomainInfo domain = new DomainInfo();
domain.PackageId = createdPackageId;
domain.DomainName = domainName;
domain.HostingAllowed = false;
domainId = ServerController.AddDomain(domain, false, false);
if (domainId < 0)
{
// rollback wizard
Rollback();
// return
return(domainId);
}
}
catch (Exception ex)
{
// rollback wizard
Rollback();
// error while adding domain
throw new Exception("Could not add domain", ex);
}
}
if (createWebSite && (domainId > 0))
{
// create web site
try
{
int webSiteId = WebServerController.AddWebSite(
createdPackageId, hostName, domainId, 0, true, false);
if (webSiteId < 0)
{
// rollback wizard
Rollback();
// return
return(webSiteId);
}
}
catch (Exception ex)
{
// rollback wizard
Rollback();
// error while creating web site
throw new Exception("Could not create web site", ex);
}
}
// create FTP account
if (createFtpAccount)
{
try
{
FtpAccount ftpAccount = new FtpAccount();
ftpAccount.PackageId = createdPackageId;
ftpAccount.Name = ftpAccountName;
ftpAccount.Password = password;
ftpAccount.Folder = "\\";
ftpAccount.CanRead = true;
ftpAccount.CanWrite = true;
int ftpAccountId = FtpServerController.AddFtpAccount(ftpAccount);
if (ftpAccountId < 0)
{
// rollback wizard
Rollback();
// return
return(ftpAccountId);
}
}
catch (Exception ex)
{
// rollback wizard
Rollback();
// error while creating ftp account
throw new Exception("Could not create FTP account", ex);
}
}
if (createMailAccount && (domainId > 0))
{
// create default mailbox
try
{
// load mail policy
UserSettings settings = UserController.GetUserSettings(createdUserId, UserSettings.MAIL_POLICY);
string catchAllName = !String.IsNullOrEmpty(settings["CatchAllName"])
? settings["CatchAllName"] : "mail";
MailAccount mailbox = new MailAccount();
mailbox.Name = catchAllName + "@" + domainName;
mailbox.PackageId = createdPackageId;
// gather information from the form
mailbox.Enabled = true;
mailbox.ResponderEnabled = false;
mailbox.ReplyTo = "";
mailbox.ResponderSubject = "";
mailbox.ResponderMessage = "";
// password
mailbox.Password = password;
// redirection
mailbox.ForwardingAddresses = new string[] { };
mailbox.DeleteOnForward = false;
mailbox.MaxMailboxSize = 0;
int mailAccountId = MailServerController.AddMailAccount(mailbox);
if (mailAccountId < 0)
{
// rollback wizard
Rollback();
// return
return(mailAccountId);
}
// set catch-all account
MailDomain mailDomain = MailServerController.GetMailDomain(createdPackageId, domainName);
mailDomain.CatchAllAccount = "mail";
mailDomain.PostmasterAccount = "mail";
mailDomain.AbuseAccount = "mail";
MailServerController.UpdateMailDomain(mailDomain);
int mailDomainId = mailDomain.Id;
}
catch (Exception ex)
{
// rollback wizard
Rollback();
// error while creating mail account
throw new Exception("Could not create mail account", ex);
}
}
// Instant Alias / Temporary URL
if (tempDomain && (domainId > 0))
{
int instantAliasId = ServerController.CreateDomainInstantAlias("", domainId);
if (instantAliasId < 0)
{
// rollback wizard
Rollback();
return(instantAliasId);
}
}
// Domain DNS Zone
if (createZoneRecord && (domainId > 0))
{
ServerController.EnableDomainDns(domainId);
}
}
// send welcome letters
if (sendAccountLetter)
{
int result = PackageController.SendAccountSummaryLetter(createdUserId, null, null, true);
if (result < 0)
{
// rollback wizard
Rollback();
// return
return(result);
}
}
if (createPackage && sendPackageLetter)
{
int result = PackageController.SendPackageSummaryLetter(createdPackageId, null, null, true);
if (result < 0)
{
// rollback wizard
Rollback();
// return
return(result);
}
}
return(createdUserId);
}
public static void AddServiceDNSRecords(int packageId, string groupName, DomainInfo domain, string serviceIP, bool wildcardOnly)
{
int serviceId = PackageController.GetPackageServiceId(packageId, groupName);
if (serviceId > 0)
{
List<DnsRecord> tmpZoneRecords = new List<DnsRecord>();
List<GlobalDnsRecord> dnsRecords = ServerController.GetDnsRecordsByService(serviceId);
if (wildcardOnly)
{
List<GlobalDnsRecord> temp = new List<GlobalDnsRecord>();
foreach (GlobalDnsRecord d in dnsRecords)
{
if ((d.RecordName == "*") ||
(d.RecordName == "@"))
temp.Add(d);
}
dnsRecords = temp;
}
DnsZone zone = (DnsZone)PackageController.GetPackageItem(domain.ZoneItemId);
tmpZoneRecords.AddRange(DnsServerController.BuildDnsResourceRecords(dnsRecords, "", domain.ZoneName, serviceIP));
try
{
DNSServer dns = new DNSServer();
ServiceProviderProxy.Init(dns, zone.ServiceId);
DnsRecord[] domainRecords = dns.GetZoneRecords(domain.DomainName);
List<DnsRecord> zoneRecords = new List<DnsRecord>();
foreach (DnsRecord t in tmpZoneRecords)
{
if (!RecordDoesExist(t, domainRecords))
zoneRecords.Add(t);
}
// add new resource records
dns.AddZoneRecords(zone.Name, zoneRecords.ToArray());
}
catch (Exception ex1)
{
TaskManager.WriteError(ex1, "Error updating DNS records");
}
}
}
public int CreateUserAccountInternal(int parentPackageId, string username, string password,
int roleId, string firstName, string lastName, string email, string secondaryEmail, bool htmlMail,
bool sendAccountLetter,
bool createPackage, int planId, bool sendPackageLetter,
string domainName, bool tempDomain, bool createWebSite,
bool createFtpAccount, string ftpAccountName, bool createMailAccount)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
| DemandAccount.IsReseller);
if (accountCheck < 0) return accountCheck;
// check package
int packageCheck = SecurityContext.CheckPackage(parentPackageId, DemandPackage.IsActive);
if (packageCheck < 0) return packageCheck;
// check if username exists
if (UserController.UserExists(username))
return BusinessErrorCodes.ERROR_ACCOUNT_WIZARD_USER_EXISTS;
// check if domain exists
int checkDomainResult = ServerController.CheckDomain(domainName);
if (checkDomainResult < 0)
return checkDomainResult;
// check if FTP account exists
if (String.IsNullOrEmpty(ftpAccountName))
ftpAccountName = username;
if (FtpServerController.FtpAccountExists(ftpAccountName))
return BusinessErrorCodes.ERROR_ACCOUNT_WIZARD_FTP_ACCOUNT_EXISTS;
// load parent package
PackageInfo parentPackage = PackageController.GetPackage(parentPackageId);
/********************************************
* CREATE USER ACCOUNT
* *****************************************/
UserInfo user = new UserInfo();
user.RoleId = roleId;
user.StatusId = (int)UserStatus.Active;
user.OwnerId = parentPackage.UserId;
user.IsDemo = false;
user.IsPeer = false;
// account info
user.FirstName = firstName;
user.LastName = lastName;
user.Email = email;
user.SecondaryEmail = secondaryEmail;
user.Username = username;
user.Password = password;
user.HtmlMail = htmlMail;
// add a new user
createdUserId = UserController.AddUser(user, false);
if (createdUserId < 0)
{
// exit
return createdUserId;
}
userCreated = true;
// create package
// load hosting plan
createdPackageId = -1;
if (createPackage)
{
try
{
HostingPlanInfo plan = PackageController.GetHostingPlan(planId);
PackageResult packageResult = PackageController.AddPackage(
createdUserId, planId, plan.PlanName, "", (int)PackageStatus.Active, DateTime.Now, false);
createdPackageId = packageResult.Result;
}
catch (Exception ex)
{
// error while adding package
// remove user account
UserController.DeleteUser(createdUserId);
throw ex;
}
if (createdPackageId < 0)
{
// rollback wizard
Rollback();
// return code
return createdPackageId;
}
// create domain
int domainId = 0;
if ((createWebSite || createMailAccount) && !String.IsNullOrEmpty(domainName))
{
try
{
DomainInfo domain = new DomainInfo();
domain.PackageId = createdPackageId;
domain.DomainName = domainName;
domain.HostingAllowed = false;
domainId = ServerController.AddDomain(domain, !tempDomain);
if (domainId < 0)
{
// rollback wizard
Rollback();
// return
return domainId;
}
}
catch (Exception ex)
{
// rollback wizard
Rollback();
// error while adding domain
throw new Exception("Could not add domain", ex);
}
}
if (createWebSite && !String.IsNullOrEmpty(domainName))
{
// create web site
try
{
int webSiteId = WebServerController.AddWebSite(
createdPackageId, domainId, 0, true);
if (webSiteId < 0)
{
// rollback wizard
Rollback();
// return
return webSiteId;
}
}
catch (Exception ex)
{
// rollback wizard
Rollback();
// error while creating web site
throw new Exception("Could not create web site", ex);
}
}
// create FTP account
if (createFtpAccount)
{
try
{
FtpAccount ftpAccount = new FtpAccount();
ftpAccount.PackageId = createdPackageId;
ftpAccount.Name = ftpAccountName;
ftpAccount.Password = password;
ftpAccount.Folder = "\\";
ftpAccount.CanRead = true;
ftpAccount.CanWrite = true;
int ftpAccountId = FtpServerController.AddFtpAccount(ftpAccount);
if (ftpAccountId < 0)
{
// rollback wizard
Rollback();
// return
return ftpAccountId;
}
}
catch (Exception ex)
{
// rollback wizard
Rollback();
// error while creating ftp account
throw new Exception("Could not create FTP account", ex);
}
}
if (createMailAccount && !String.IsNullOrEmpty(domainName))
{
// create default mailbox
try
{
// load mail policy
UserSettings settings = UserController.GetUserSettings(createdUserId, UserSettings.MAIL_POLICY);
string catchAllName = !String.IsNullOrEmpty(settings["CatchAllName"])
? settings["CatchAllName"] : "mail";
MailAccount mailbox = new MailAccount();
mailbox.Name = catchAllName + "@" + domainName;
mailbox.PackageId = createdPackageId;
// gather information from the form
mailbox.Enabled = true;
mailbox.ResponderEnabled = false;
mailbox.ReplyTo = "";
mailbox.ResponderSubject = "";
mailbox.ResponderMessage = "";
// password
mailbox.Password = password;
// redirection
mailbox.ForwardingAddresses = new string[] { };
mailbox.DeleteOnForward = false;
mailbox.MaxMailboxSize = 0;
int mailAccountId = MailServerController.AddMailAccount(mailbox);
if (mailAccountId < 0)
{
// rollback wizard
Rollback();
// return
return mailAccountId;
}
// set catch-all account
MailDomain mailDomain = MailServerController.GetMailDomain(createdPackageId, domainName);
mailDomain.CatchAllAccount = "mail";
mailDomain.PostmasterAccount = "mail";
mailDomain.AbuseAccount = "mail";
MailServerController.UpdateMailDomain(mailDomain);
int mailDomainId = mailDomain.Id;
// set mail domain pointer
// load domain instant alias
string instantAlias = ServerController.GetDomainAlias(createdPackageId, domainName);
DomainInfo instantDomain = ServerController.GetDomain(instantAlias);
if (instantDomain == null || instantDomain.MailDomainId > 0)
instantAlias = "";
if (!String.IsNullOrEmpty(instantAlias))
MailServerController.AddMailDomainPointer(mailDomainId, instantDomain.DomainId);
}
catch (Exception ex)
{
// rollback wizard
Rollback();
// error while creating mail account
throw new Exception("Could not create mail account", ex);
}
}
}
// send welcome letters
if (sendAccountLetter)
{
int result = PackageController.SendAccountSummaryLetter(createdUserId, null, null, true);
if (result < 0)
{
// rollback wizard
Rollback();
// return
return result;
}
}
if (createPackage && sendPackageLetter)
{
int result = PackageController.SendPackageSummaryLetter(createdPackageId, null, null, true);
if (result < 0)
{
// rollback wizard
Rollback();
// return
return result;
}
}
return createdUserId;
}
public static void AddServiceDNSRecords(int packageId, string groupName, DomainInfo domain, string serviceIP)
{
AddServiceDNSRecords(packageId, groupName, domain, serviceIP, false);
}
private static DomainInfo GetDomain(DomainInfo domain, bool withLog = true)
{
// check domain
if (domain == null)
return null;
// get instant alias
domain.InstantAliasName = GetDomainAlias(domain.PackageId, domain.DomainName);
DomainInfo instantAlias = GetDomainItem(domain.InstantAliasName, true, false);
if (instantAlias != null)
domain.InstantAliasId = instantAlias.DomainId;
// Log Extension
if (withLog)
LogExtension.WriteObject(domain);
return domain;
}
public static DomainInfo UpdateDomainWhoisData(DomainInfo domain, DateTime? creationDate, DateTime? expirationDate, string registrarName)
{
DataProvider.UpdateWhoisDomainInfo(domain.DomainId, creationDate, expirationDate, DateTime.Now, registrarName);
domain.CreationDate = creationDate;
domain.ExpirationDate = expirationDate;
domain.RegistrarName = registrarName;
domain.LastUpdateDate = DateTime.Now;
return domain;
}
public int UpdateDomain(DomainInfo domain)
{
return ServerController.UpdateDomain(domain);
}
private void FillRecordData(DnsRecordInfo record, DomainInfo domain, string dnsServer)
{
record.DomainId = domain.DomainId;
record.Date = DateTime.Now;
record.DnsServer = dnsServer;
}
private void RestoreDomainByZone(string itemName, int packageId, int zoneId)
{
DomainInfo domain = ServerController.GetDomain(itemName);
if (domain == null)
{
domain = new DomainInfo();
domain.DomainName = itemName;
domain.PackageId = packageId;
domain.ZoneItemId = zoneId;
ServerController.AddDomainItem(domain);
}
else
{
domain.ZoneItemId = zoneId;
ServerController.UpdateDomain(domain);
}
}
private static int AddOrganizationDomain(int itemId, string domainName)
{
Log.WriteStart(string.Format("Importing domain {0}...", domainName));
// load organization
Organization org = (Organization)PackageController.GetPackageItem(itemId);
if (org == null)
return -1;
// check package
int packageCheck = SecurityContext.CheckPackage(org.PackageId, DemandPackage.IsActive);
if (packageCheck < 0) return packageCheck;
DomainInfo domain = null;
// check if the domain already exists
int checkResult = ServerController.CheckDomain(domainName);
if (checkResult == BusinessErrorCodes.ERROR_DOMAIN_ALREADY_EXISTS)
{
// domain exists
// check if it belongs to the same space
domain = ServerController.GetDomain(domainName);
if (domain == null)
return checkResult;
if (domain.PackageId != org.PackageId)
return checkResult;
if (DataProvider.ExchangeOrganizationDomainExists(domain.DomainId))
return BusinessErrorCodes.ERROR_ORGANIZATION_DOMAIN_IS_IN_USE;
}
else if (checkResult == BusinessErrorCodes.ERROR_RESTRICTED_DOMAIN)
{
return checkResult;
}
// create domain if required
if (domain == null)
{
domain = new DomainInfo();
domain.PackageId = org.PackageId;
domain.DomainName = domainName;
domain.IsInstantAlias = false;
domain.IsSubDomain = false;
// add domain
domain.DomainId = ServerController.AddDomain(domain);
}
// register domain
DataProvider.AddExchangeOrganizationDomain(itemId, domain.DomainId, false);
// register service item
OrganizationDomain exchDomain = new OrganizationDomain();
exchDomain.Name = domainName;
exchDomain.PackageId = org.PackageId;
exchDomain.ServiceId = org.ServiceId;
PackageController.AddPackageItem(exchDomain);
Log.WriteEnd("Domain imported");
return 0;
}
public static int AddOrganizationDomain(int itemId, string domainName)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0) return accountCheck;
// check domains quota
OrganizationStatistics orgStats = GetOrganizationStatistics(itemId);
if (orgStats.AllocatedDomains > -1
&& orgStats.CreatedDomains >= orgStats.AllocatedDomains)
return BusinessErrorCodes.ERROR_EXCHANGE_DOMAINS_QUOTA_LIMIT;
// place log record
TaskManager.StartTask("ORGANIZATION", "ADD_DOMAIN", domainName);
TaskManager.ItemId = itemId;
try
{
// load organization
Organization org = (Organization)PackageController.GetPackageItem(itemId);
if (org == null)
return -1;
// check package
int packageCheck = SecurityContext.CheckPackage(org.PackageId, DemandPackage.IsActive);
if (packageCheck < 0) return packageCheck;
DomainInfo domain = null;
// check if the domain already exists
int checkResult = ServerController.CheckDomain(domainName);
if (checkResult == BusinessErrorCodes.ERROR_DOMAIN_ALREADY_EXISTS)
{
// domain exists
// check if it belongs to the same space
domain = ServerController.GetDomain(domainName);
if (domain == null)
return checkResult;
if (domain.PackageId != org.PackageId)
return checkResult;
if (DataProvider.ExchangeOrganizationDomainExists(domain.DomainId))
return BusinessErrorCodes.ERROR_ORGANIZATION_DOMAIN_IS_IN_USE;
}
else if (checkResult == BusinessErrorCodes.ERROR_RESTRICTED_DOMAIN)
{
return checkResult;
}
// create domain if required
if (domain == null)
{
domain = new DomainInfo();
domain.PackageId = org.PackageId;
domain.DomainName = domainName;
domain.IsInstantAlias = false;
domain.IsSubDomain = false;
int domainId = ServerController.AddDomain(domain);
if (domainId < 0)
return domainId;
// add domain
domain.DomainId = domainId;
}
// register domain
DataProvider.AddExchangeOrganizationDomain(itemId, domain.DomainId, false);
// register service item
OrganizationDomain exchDomain = new OrganizationDomain();
exchDomain.Name = domainName;
exchDomain.PackageId = org.PackageId;
exchDomain.ServiceId = org.ServiceId;
PackageController.AddPackageItem(exchDomain);
Organizations orgProxy = GetOrganizationProxy(org.ServiceId);
orgProxy.CreateOrganizationDomain(org.DistinguishedName, domainName);
if (!string.IsNullOrEmpty(org.GlobalAddressList))
{
ExchangeServerController.AddAuthoritativeDomain(itemId, domain.DomainId);
}
if (org.IsOCSOrganization)
{
OCSController.AddDomain(domain.DomainName, itemId);
}
return 0;
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
private void CreateWebsitePanelDomain(int packageId)
{
// try to register domain in panel
DomainInfo domain = ServerController.GetDomain(FQDN);
// domain not found thus create newly one
if (domain == null)
{
domain = new DomainInfo();
domain.DomainName = FQDN;
domain.HostingAllowed = false;
domain.PackageId = packageId;
domain.DomainId = ServerController.AddDomain(domain);
}
// save domain id if it's created
if (domain.DomainId > 0)
ServiceSettings[INTERNAL_DOMAIN_ID] = domain.DomainId.ToString();
}
public int UpdateDomain(DomainInfo domain)
{
return(ServerController.UpdateDomain(domain));
}
public GenericSvcResult ActivateService(ProvisioningContext context)
{
GenericSvcResult result = new GenericSvcResult();
// remeber svc state
SaveObjectState(SERVICE_INFO, context.ServiceInfo);
// concretize service to be provisioned
DomainNameSvc domainSvc = (DomainNameSvc)context.ServiceInfo;
// concretize parent service
HostingPackageSvc packageSvc = (HostingPackageSvc)context.ParentSvcInfo;
try
{
// LOG INFO
TaskManager.StartTask(SystemTasks.SOURCE_ECOMMERCE, SystemTasks.SVC_ACTIVATE);
TaskManager.WriteParameter(CONTRACT_PARAM, domainSvc.ContractId);
TaskManager.WriteParameter(SVC_PARAM, domainSvc.ServiceName);
TaskManager.WriteParameter(SVC_ID_PARAM, domainSvc.ServiceId);
// 0. Do security checks
if (!CheckOperationClientPermissions(result))
{
// LOG ERROR
TaskManager.WriteError(ERROR_CLIENT_OPERATION_PERMISSIONS);
TaskManager.WriteParameter(RESULT_CODE_PARAM, result.ResultCode);
// EXIT
return result;
}
//
if (!CheckOperationClientStatus(result))
{
// LOG ERROR
TaskManager.WriteError(ERROR_CLIENT_OPERATION_STATUS);
TaskManager.WriteParameter(RESULT_CODE_PARAM, result.ResultCode);
// EXIT
return result;
}
// error: hosting addon should have parent svc assigned
if (packageSvc == null || packageSvc.PackageId == 0)
{
result.Succeed = false;
//
result.Error = PARENT_SVC_NOT_FOUND_MSG;
//
result.ResultCode = EcommerceErrorCodes.ERROR_PARENT_SVC_NOT_FOUND;
// LOG ERROR
TaskManager.WriteError(result.Error);
TaskManager.WriteParameter(RESULT_CODE_PARAM, result.ResultCode);
// EXIT
return result;
}
// first of all - create internal domain in WebsitePanel
if (domainSvc.Status == ServiceStatus.Ordered)
{
// create domain info object
DomainInfo domain = ServerController.GetDomain(domainSvc.Fqdn);
//
if (domain != null)
domainSvc.DomainId = domain.DomainId;
//
if (domain == null)
{
domain = new DomainInfo();
domain.DomainName = domainSvc.Fqdn;
domain.HostingAllowed = false;
domain.PackageId = packageSvc.PackageId;
// add internal domain
domainSvc.DomainId = ServerController.AddDomain(domain);
// check API result
if (domainSvc.DomainId < 1)
{
// ASSEMBLE ERROR
result.Succeed = false;
// try to find corresponding error code->error message mapping
if (ApiErrorCodesMap.ContainsKey(domainSvc.DomainId))
result.Error = ApiErrorCodesMap[domainSvc.DomainId];
else
result.Error = ERROR_ADD_INTERNAL_DOMAIN;
// copy result code
result.ResultCode = domainSvc.DomainId;
// LOG ERROR
TaskManager.WriteError(result.Error);
TaskManager.WriteParameter(RESULT_CODE_PARAM, result.ResultCode);
// EXIT
return result;
}
}
}
// update nameservers only
if (domainSvc["SPF_ACTION"] == "UPDATE_NS")
{
// remove service here...
ServiceController.DeleteCustomerService(domainSvc.ServiceId);
//
result.Succeed = true;
// EXIT
return result;
}
// load registrar wrapper
IDomainRegistrar registrar = (IDomainRegistrar)SystemPluginController.GetSystemPluginInstance(
domainSvc.ContractId, domainSvc.PluginId, true);
#region Commented operations
// prepare consumer account information
/*CommandParams cmdParams = PrepeareAccountParams(context.ConsumerInfo);
// copy svc properties
foreach (string keyName in domainSvc.GetAllKeys())
cmdParams[keyName] = domainSvc[keyName];
// check registrar requires sub-account to be created
if (registrar.SubAccountRequired)
{
// 1. Load user's settings
UserSettings userSettings = LoadUserSettings(context.ConsumerInfo.UserId, registrar.PluginName);
// 2. Ensure user has account on registrar's side
if (userSettings.SettingsArray == null || userSettings.SettingsArray.Length == 0)
{
// 3. Check account exists
bool exists = registrar.CheckSubAccountExists(context.ConsumerInfo.Username, context.ConsumerInfo.Email);
//
AccountResult accResult = null;
//
if (!exists)
{
// 4. Create user account
accResult = registrar.CreateSubAccount(cmdParams);
// copy keys & values
foreach (string keyName in accResult.AllKeys)
{
userSettings[keyName] = accResult[keyName];
}
}
else
{
// 4a. Get sub-account info
accResult = registrar.GetSubAccount(context.ConsumerInfo.Username,
context.ConsumerInfo.Email);
//
foreach (string keyName in accResult.AllKeys)
userSettings[keyName] = accResult[keyName];
}
// 5. Update user settings
int apiResult = UserController.UpdateUserSettings(userSettings);
// check API result
if (apiResult < 0)
{
// BUILD ERROR
result.Error = ERROR_UPDATE_USR_SETTINGS_MSG;
result.Succeed = false;
result.ResultCode = apiResult;
// LOG ERROR
TaskManager.WriteError(result.Error);
TaskManager.WriteParameter(RESULT_CODE_PARAM, result.ResultCode);
// ROLLBACK
RollbackOperation(domainSvc.DomainId);
// EXIT
return result;
}
}
// copy registrar-specific data
foreach (string[] pair in userSettings.SettingsArray)
{
// copy 2
cmdParams[pair[0]] = pair[1];
}
}*/
#endregion
// load NS settings
PackageSettings nsSettings = PackageController.GetPackageSettings(packageSvc.PackageId, PackageSettings.NAME_SERVERS);
// build name servers array
string[] nameServers = null;
if (!String.IsNullOrEmpty(nsSettings[PackageSettings.NAME_SERVERS]))
nameServers = nsSettings[PackageSettings.NAME_SERVERS].Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
// register or renew domain
if (domainSvc.Status == ServiceStatus.Ordered)
// try to register domain
registrar.RegisterDomain(domainSvc, context.ConsumerInfo, nameServers);
else
// try to renew domain
registrar.RenewDomain(domainSvc, context.ConsumerInfo, nameServers);
// change svc status to active
domainSvc.Status = ServiceStatus.Active;
// update service info
int updResult = UpdateServiceInfo(domainSvc);
// check update result for errors
if (updResult < 0)
{
// BUILD ERROR
result.ResultCode = updResult;
result.Succeed = false;
result.Error = ERROR_SVC_UPDATE_MSG;
// LOG ERROR
TaskManager.WriteError(result.Error);
TaskManager.WriteParameter(RESULT_CODE_PARAM, result.ResultCode);
// ROLLBACK
RollbackOperation(domainSvc.DomainId);
// EXIT
return result;
}
//
result.Succeed = true;
//
SetOutboundParameters(context);
}
catch (Exception ex)
{
// LOG ERROR
TaskManager.WriteError(ex);
result.Succeed = false;
// ROLLBACK
RollbackOperation(result.ResultCode);
}
finally
{
TaskManager.CompleteTask();
}
//
return result;
}
private void FillRecordData(DnsRecordInfo record, DomainInfo domain, string dnsServer)
{
record.DomainId = domain.DomainId;
record.Date = DateTime.Now;
record.DnsServer = dnsServer;
}
/// <remarks/>
public void AddDomainAsync(DomainInfo domain) {
this.AddDomainAsync(domain, null);
}
private static DomainInfo GetDomain(DomainInfo domain)
{
// check domain
if (domain == null)
return null;
// get instant alias
domain.InstantAliasName = GetDomainAlias(domain.PackageId, domain.DomainName);
DomainInfo instantAlias = GetDomainItem(domain.InstantAliasName);
if (instantAlias != null)
domain.InstantAliasId = instantAlias.DomainId;
return domain;
}
public int UpdateDomain(DomainInfo domain) {
object[] results = this.Invoke("UpdateDomain", new object[] {
domain});
return ((int)(results[0]));
}
public static int AddDomain(DomainInfo domain, bool createInstantAlias)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0) return accountCheck;
// check package
int packageCheck = SecurityContext.CheckPackage(domain.PackageId, DemandPackage.IsActive);
if (packageCheck < 0) return packageCheck;
// add main domain
int domainId = AddDomainInternal(domain.PackageId, domain.DomainName, true,
domain.IsSubDomain, false, domain.IsDomainPointer, false);
if (domainId < 0)
return domainId;
// add instant alias if required
string domainAlias = GetDomainAlias(domain.PackageId, domain.DomainName);
if (createInstantAlias && !String.IsNullOrEmpty(domainAlias))
{
AddDomainInternal(domain.PackageId, domainAlias, true, false, true, false, false);
}
return domainId;
}
/// <remarks/>
public System.IAsyncResult BeginUpdateDomain(DomainInfo domain, System.AsyncCallback callback, object asyncState) {
return this.BeginInvoke("UpdateDomain", new object[] {
domain}, callback, asyncState);
}
public static int UpdateDomain(DomainInfo domain)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0) return accountCheck;
// place log record
DomainInfo origDomain = GetDomain(domain.DomainId);
TaskManager.StartTask("DOMAIN", "UPDATE", origDomain.DomainName);
TaskManager.ItemId = domain.DomainId;
try
{
DataProvider.UpdateDomain(SecurityContext.User.UserId,
domain.DomainId, domain.ZoneItemId, domain.HostingAllowed, domain.WebSiteId,
domain.MailDomainId);
return 0;
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
/// <remarks/>
public void UpdateDomainAsync(DomainInfo domain) {
this.UpdateDomainAsync(domain, null);
}
public int AddDomain(DomainInfo domain)
{
return ServerController.AddDomain(domain);
}
/// <remarks/>
public void UpdateDomainAsync(DomainInfo domain, object userState) {
if ((this.UpdateDomainOperationCompleted == null)) {
this.UpdateDomainOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateDomainOperationCompleted);
}
this.InvokeAsync("UpdateDomain", new object[] {
domain}, this.UpdateDomainOperationCompleted, userState);
}
public static PackageResult AddPackageWithResources(int userId, int planId, string spaceName,
int statusId, bool sendLetter,
bool createResources, string domainName, bool createInstantAlias, bool createWebSite,
bool createFtpAccount, string ftpAccountName, bool createMailAccount)
{
try
{
TaskManager.StartTask("HOSTING_SPACE_WR", "ADD", spaceName);
PackageResult result = new PackageResult();
// check account
result.Result = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
| DemandAccount.IsReseller);
if (result.Result < 0) return result;
// check if domain exists
result.Result = ServerController.CheckDomain(domainName);
if (result.Result < 0)
return result;
// load user info
UserInfo user = UserController.GetUser(userId);
if (createFtpAccount)
{
// check if FTP account exists
if (String.IsNullOrEmpty(ftpAccountName))
ftpAccountName = user.Username;
if (FtpServerController.FtpAccountExists(ftpAccountName))
{
result.Result = BusinessErrorCodes.ERROR_ACCOUNT_WIZARD_FTP_ACCOUNT_EXISTS;
return result;
}
}
// load hosting plan
HostingPlanInfo plan = PackageController.GetHostingPlan(planId);
string packageName = spaceName;
if (String.IsNullOrEmpty(packageName) || packageName.Trim() == "")
packageName = plan.PlanName;
// create package
int packageId = -1;
try
{
result = PackageController.AddPackage(
userId, planId, packageName, "", statusId, DateTime.Now, false);
}
catch (Exception ex)
{
// error while adding package
throw ex;
}
if (result.Result < 0)
return result;
packageId = result.Result;
// create domain
if (createResources)
{
int domainId = 0;
if (!String.IsNullOrEmpty(domainName))
{
try
{
DomainInfo domain = new DomainInfo();
domain.PackageId = packageId;
domain.DomainName = domainName;
domain.HostingAllowed = false;
domainId = ServerController.AddDomain(domain, createInstantAlias);
if (domainId < 0)
{
result.Result = domainId;
DeletePackage(packageId);
return result;
}
}
catch (Exception ex)
{
// error while adding domain
DeletePackage(packageId);
throw new Exception("Could not add domain", ex);
}
}
if (createWebSite && !String.IsNullOrEmpty(domainName))
{
// create web site
try
{
int webSiteId = WebServerController.AddWebSite(
packageId, domainId, 0, true);
if (webSiteId < 0)
{
result.Result = webSiteId;
DeletePackage(packageId);
return result;
}
}
catch (Exception ex)
{
// error while creating web site
DeletePackage(packageId);
throw new Exception("Could not create web site", ex);
}
}
// create FTP account
if (createFtpAccount)
{
try
{
FtpAccount ftpAccount = new FtpAccount();
ftpAccount.PackageId = packageId;
ftpAccount.Name = ftpAccountName;
ftpAccount.Password = user.Password;
ftpAccount.Folder = "\\";
ftpAccount.CanRead = true;
ftpAccount.CanWrite = true;
int ftpAccountId = FtpServerController.AddFtpAccount(ftpAccount);
if (ftpAccountId < 0)
{
result.Result = ftpAccountId;
DeletePackage(packageId);
return result;
}
}
catch (Exception ex)
{
// error while creating ftp account
DeletePackage(packageId);
throw new Exception("Could not create FTP account", ex);
}
}
if (createMailAccount && !String.IsNullOrEmpty(domainName))
{
// create default mailbox
try
{
// load mail policy
UserSettings settings = UserController.GetUserSettings(userId, UserSettings.MAIL_POLICY);
string catchAllName = !String.IsNullOrEmpty(settings["CatchAllName"])
? settings["CatchAllName"] : "mail";
MailAccount mailbox = new MailAccount();
mailbox.Name = catchAllName + "@" + domainName;
mailbox.PackageId = packageId;
// gather information from the form
mailbox.Enabled = true;
mailbox.ResponderEnabled = false;
mailbox.ReplyTo = "";
mailbox.ResponderSubject = "";
mailbox.ResponderMessage = "";
// password
mailbox.Password = user.Password;
// redirection
mailbox.ForwardingAddresses = new string[] { };
mailbox.DeleteOnForward = false;
mailbox.MaxMailboxSize = 0;
int mailAccountId = MailServerController.AddMailAccount(mailbox);
if (mailAccountId < 0)
{
result.Result = mailAccountId;
DeletePackage(packageId);
return result;
}
// set catch-all account
MailDomain mailDomain = MailServerController.GetMailDomain(packageId, domainName);
mailDomain.CatchAllAccount = catchAllName;
mailDomain.PostmasterAccount = "mail";
mailDomain.AbuseAccount = "mail";
MailServerController.UpdateMailDomain(mailDomain);
int mailDomainId = mailDomain.Id;
// set mail domain pointer
// load domain instant alias
string instantAlias = ServerController.GetDomainAlias(packageId, domainName);
DomainInfo instantDomain = ServerController.GetDomain(instantAlias);
if (instantDomain == null || instantDomain.MailDomainId > 0)
instantAlias = "";
if (!String.IsNullOrEmpty(instantAlias))
MailServerController.AddMailDomainPointer(mailDomainId, instantDomain.DomainId);
}
catch (Exception ex)
{
// error while creating mail account
DeletePackage(packageId);
throw new Exception("Could not create mail account", ex);
}
}
}
TaskManager.ItemId = result.Result;
TaskManager.TaskParameters["SendLetter"] = sendLetter;
return result;
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
private static DomainInfo CreateNewDomain(int packageId, string domainName)
{
// new domain
DomainInfo domain = new DomainInfo();
domain.PackageId = packageId;
domain.DomainName = domainName;
domain.IsInstantAlias = true;
domain.IsSubDomain = true;
return domain;
}
private void RestoreDomainsByWebSite(ServerBinding[] bindings, int packageId, int webSiteId, string itemName)
{
// detect all web site related domains
List<string> domainNames = new List<string>();
foreach (ServerBinding binding in bindings)
{
string pointerName = binding.Host;
if (pointerName == null)
continue;
pointerName = pointerName.ToLower();
if (pointerName.StartsWith("www."))
pointerName = pointerName.Substring(4);
if (!domainNames.Contains(pointerName) && !String.IsNullOrEmpty(pointerName))
domainNames.Add(pointerName);
}
string siteName = itemName.ToLower();
if (siteName.StartsWith("www."))
siteName = siteName.Substring(4);
if (!domainNames.Contains(siteName))
domainNames.Add(siteName);
foreach (string domainName in domainNames)
{
DomainInfo domain = ServerController.GetDomain(domainName);
if (domain == null)
{
domain = new DomainInfo();
domain.DomainName = domainName;
domain.PackageId = packageId;
domain.WebSiteId = webSiteId;
ServerController.AddDomainItem(domain);
}
else
{
domain.WebSiteId = webSiteId;
ServerController.UpdateDomain(domain);
}
}
}
public static ResultObject AddOrganizationDomain(int itemId, string domainName)
{
ResultObject result = new ResultObject();
result.IsSuccess = true;
try
{
// initialize task manager
TaskManager.StartTask(TaskManagerSource, "ADD_DOMAIN");
TaskManager.WriteParameter("itemId", itemId);
TaskManager.WriteParameter("domain", domainName);
// load organization item
ExchangeOrganization item = PackageController.GetPackageItem(itemId) as ExchangeOrganization;
if (item == null)
{
return(Error <ResultObject>(OrganizationNotFoundError));
}
#region Check Space and Account
// Check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(Warning <ResultObject>((-accountCheck).ToString()));
}
// Check space
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(Warning <ResultObject>((-packageCheck).ToString()));
}
#endregion
// get organization details
ExchangeOrganization org = GetOrganizationDetails(item.Id);
if (org == null)
{
return(Error <ResultObject>(OrganizationNotFoundError));
}
// check domains quota
if (org.MaxDomainsCountQuota > -1 && org.Domains.Length >= org.MaxDomainsCountQuota)
{
return(Error <IntResult>(AddDomainQuotaExceededError));
}
// check if the domain already exists
DomainInfo domain = null;
int checkResult = ServerController.CheckDomain(domainName);
if (checkResult == BusinessErrorCodes.ERROR_DOMAIN_ALREADY_EXISTS)
{
// domain exists
// check if it belongs to the same space
domain = ServerController.GetDomain(domainName);
if (domain == null)
{
return(Error <ResultObject>((-checkResult).ToString()));
}
if (domain.PackageId != org.PackageId)
{
return(Error <ResultObject>((-checkResult).ToString()));
}
// check if domain is already used in this organization
foreach (ExchangeOrganizationDomain orgDomain in org.Domains)
{
if (String.Equals(orgDomain.Name, domainName, StringComparison.InvariantCultureIgnoreCase))
{
return(Error <ResultObject>(AddDomainAlreadyUsedError));
}
}
}
else if (checkResult == BusinessErrorCodes.ERROR_RESTRICTED_DOMAIN)
{
return(Error <ResultObject>((-checkResult).ToString()));
}
// create domain if required
if (domain == null)
{
domain = new DomainInfo();
domain.PackageId = org.PackageId;
domain.DomainName = domainName;
domain.IsInstantAlias = false;
domain.IsSubDomain = false;
int domainId = ServerController.AddDomain(domain);
if (domainId < 0)
{
return(Error <ResultObject>((-domainId).ToString()));
}
// add domain
domain.DomainId = domainId;
}
// get Exchange service
ExchangeServerHostedEdition exchange = GetExchangeService(item.ServiceId);
// add domain
exchange.AddOrganizationDomain(item.Name, domainName);
return(result);
}
catch (Exception ex)
{
// log error
TaskManager.WriteError(ex);
// exit with error code
return(Error <ResultObject>(AddDomainError, ex.Message));
}
finally
{
TaskManager.CompleteTask();
}
}
