896 lines
No EOL
38 KiB
C#
896 lines
No EOL
38 KiB
C#
// Copyright (c) 2012, Outercurve Foundation.
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// - Redistributions of source code must retain the above copyright notice, this
|
|
// list of conditions and the following disclaimer.
|
|
//
|
|
// - Redistributions in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// - Neither the name of the Outercurve Foundation nor the names of its
|
|
// contributors may be used to endorse or promote products derived from this
|
|
// software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
|
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Web;
|
|
using WebsitePanel.Providers.ExchangeHostedEdition;
|
|
using WebsitePanel.Providers.ResultObjects;
|
|
using WebsitePanel.Providers.Common;
|
|
using WebsitePanel.Providers;
|
|
using System.Collections.Specialized;
|
|
using System.Collections;
|
|
using System.Net.Mail;
|
|
|
|
namespace WebsitePanel.EnterpriseServer
|
|
{
|
|
public class ExchangeHostedEditionController
|
|
{
|
|
// messages
|
|
public const string GeneralError = "GeneralError";
|
|
public const string ExchangeServiceNotEnabledError = "ExchangeServiceNotEnabledError";
|
|
public const string ProgramIdIsNotSetError = "ProgramIdIsNotSetError";
|
|
public const string OfferIdIsNotSetError = "OfferIdIsNotSetError";
|
|
public const string CreateOrganizationError = "CreateOrganizationError";
|
|
public const string OrganizationNotFoundError = "OrganizationNotFoundError";
|
|
public const string SendOrganizationSummaryError = "SendOrganizationSummaryError";
|
|
public const string SendOrganizationTemplateNotSetError = "SendOrganizationTemplateNotSetError";
|
|
public const string AddDomainError = "AddDomainError";
|
|
public const string AddDomainQuotaExceededError = "AddDomainQuotaExceededError";
|
|
public const string AddDomainExistsError = "AddDomainExistsError";
|
|
public const string AddDomainAlreadyUsedError = "AddDomainAlreadyUsedError";
|
|
public const string DeleteDomainError = "DeleteDomainError";
|
|
public const string UpdateQuotasError = "UpdateQuotasError";
|
|
public const string UpdateQuotasWrongQuotaError = "UpdateQuotasWrongQuotaError";
|
|
public const string UpdateCatchAllError = "UpdateCatchAllError";
|
|
public const string UpdateServicePlanError = "UpdateServicePlanError";
|
|
public const string DeleteOrganizationError = "DeleteOrganizationError";
|
|
|
|
public const string TempDomainSetting = "temporaryDomain";
|
|
public const string ExchangeControlPanelUrlSetting = "ecpURL";
|
|
|
|
// other constants
|
|
public const string TaskManagerSource = "ExchangeHostedEdition";
|
|
|
|
public static IntResult CreateOrganization(int packageId, string organizationId,
|
|
string domain, string adminName, string adminEmail, string adminPassword)
|
|
{
|
|
IntResult result = new IntResult();
|
|
result.IsSuccess = true;
|
|
|
|
try
|
|
{
|
|
// initialize task manager
|
|
TaskManager.StartTask(TaskManagerSource, "CREATE_ORGANIZATION");
|
|
TaskManager.WriteParameter("packageId", packageId);
|
|
TaskManager.WriteParameter("organizationId", organizationId);
|
|
TaskManager.WriteParameter("domain", domain);
|
|
TaskManager.WriteParameter("adminName", adminName);
|
|
TaskManager.WriteParameter("adminEmail", adminEmail);
|
|
TaskManager.WriteParameter("adminPassword", adminPassword);
|
|
|
|
// get Exchange service ID
|
|
int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.ExchangeHostedEdition);
|
|
if(serviceId < 1)
|
|
return Error<IntResult>(ExchangeServiceNotEnabledError);
|
|
|
|
#region Check Space and Account
|
|
// Check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (accountCheck < 0)
|
|
return Warning<IntResult>((-accountCheck).ToString());
|
|
|
|
// Check space
|
|
int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive);
|
|
if (packageCheck < 0)
|
|
return Warning<IntResult>((-packageCheck).ToString());
|
|
#endregion
|
|
|
|
// get Exchange service
|
|
ExchangeServerHostedEdition exchange = GetExchangeService(serviceId);
|
|
|
|
// load service settings to know ProgramID, OfferID
|
|
StringDictionary serviceSettings = ServerController.GetServiceSettings(serviceId);
|
|
string programId = serviceSettings["programID"];
|
|
string offerId = serviceSettings["offerID"];
|
|
|
|
// check settings
|
|
if(String.IsNullOrEmpty(programId))
|
|
result.ErrorCodes.Add(ProgramIdIsNotSetError);
|
|
if (String.IsNullOrEmpty(offerId))
|
|
result.ErrorCodes.Add(OfferIdIsNotSetError);
|
|
|
|
if (result.ErrorCodes.Count > 0)
|
|
{
|
|
result.IsSuccess = false;
|
|
return result;
|
|
}
|
|
|
|
#region Create organization
|
|
int itemId = -1;
|
|
ExchangeOrganization org = null;
|
|
try
|
|
{
|
|
// create organization
|
|
exchange.CreateOrganization(organizationId, programId, offerId, domain, adminName, adminEmail, adminPassword);
|
|
|
|
// save item into meta-base
|
|
org = new ExchangeOrganization();
|
|
org.Name = organizationId;
|
|
org.PackageId = packageId;
|
|
org.ServiceId = serviceId;
|
|
itemId = PackageController.AddPackageItem(org);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// log error
|
|
TaskManager.WriteError(ex);
|
|
return Error<IntResult>(CreateOrganizationError);
|
|
}
|
|
#endregion
|
|
|
|
#region Update organization quotas
|
|
// update max org quotas
|
|
UpdateOrganizationQuotas(org);
|
|
|
|
// override quotas
|
|
ResultObject quotasResult = ExchangeHostedEditionController.UpdateOrganizationQuotas(itemId,
|
|
org.MaxMailboxCountQuota,
|
|
org.MaxContactCountQuota,
|
|
org.MaxDistributionListCountQuota);
|
|
|
|
if (!quotasResult.IsSuccess)
|
|
return Error<IntResult>(quotasResult, CreateOrganizationError);
|
|
#endregion
|
|
|
|
#region Add temporary domain
|
|
// load settings
|
|
PackageSettings settings = GetExchangePackageSettings(org);
|
|
string tempDomainTemplate = settings[TempDomainSetting];
|
|
if (!String.IsNullOrEmpty(tempDomainTemplate))
|
|
{
|
|
// add temp domain
|
|
string tempDomain = String.Format("{0}.{1}", domain, tempDomainTemplate);
|
|
AddOrganizationDomain(itemId, tempDomain);
|
|
}
|
|
|
|
#endregion
|
|
|
|
result.Value = itemId;
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// log error
|
|
TaskManager.WriteError(ex);
|
|
|
|
// exit with error code
|
|
return Error<IntResult>(GeneralError, ex.Message);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static List<ExchangeOrganization> GetOrganizations(int packageId)
|
|
{
|
|
List<ServiceProviderItem> items = PackageController.GetPackageItemsByType(
|
|
packageId, typeof(ExchangeOrganization), false);
|
|
|
|
return items.ConvertAll<ExchangeOrganization>(i => { return (ExchangeOrganization)i; });
|
|
}
|
|
|
|
public static ExchangeOrganization GetOrganizationDetails(int itemId)
|
|
{
|
|
// load organization item
|
|
ExchangeOrganization item = PackageController.GetPackageItem(itemId) as ExchangeOrganization;
|
|
if (item == null)
|
|
return null; // organization item not found
|
|
|
|
// get Exchange service
|
|
ExchangeServerHostedEdition exchange = GetExchangeService(item.ServiceId);
|
|
|
|
// get organization details
|
|
ExchangeOrganization org = exchange.GetOrganizationDetails(item.Name);
|
|
|
|
//ExchangeOrganization org = new ExchangeOrganization
|
|
//{
|
|
// Id = item.Id,
|
|
// PackageId = item.PackageId,
|
|
// ServiceId = item.ServiceId,
|
|
// Name = item.Name,
|
|
// AdministratorEmail = "admin@email.com",
|
|
// AdministratorName = "Administrator Mailbox",
|
|
// CatchAllAddress = "",
|
|
// ContactCount = 1,
|
|
// ContactCountQuota = 2,
|
|
// MaxContactCountQuota = 3,
|
|
// DistinguishedName = "DN=....",
|
|
// DistributionListCount = 2,
|
|
// DistributionListCountQuota = 3,
|
|
// MaxDistributionListCountQuota = 3,
|
|
// MaxDomainsCountQuota = 4,
|
|
// ExchangeControlPanelUrl = "http://ecp.domain.com",
|
|
// MailboxCount = 3,
|
|
// MailboxCountQuota = 4,
|
|
// MaxMailboxCountQuota = 4,
|
|
// ProgramId = "HostedExchange",
|
|
// OfferId = "2",
|
|
// ServicePlan = "HostedExchange_Basic",
|
|
// Domains = GetOrganizationDomains(item.Id).ToArray()
|
|
//};
|
|
|
|
// update item props
|
|
org.Id = item.Id;
|
|
org.PackageId = item.PackageId;
|
|
org.ServiceId = item.ServiceId;
|
|
org.Name = item.Name;
|
|
org.CatchAllAddress = item.CatchAllAddress;
|
|
|
|
// update max quotas
|
|
UpdateOrganizationQuotas(org);
|
|
|
|
// process summary information
|
|
org.SummaryInformation = GetExchangeOrganizationSummary(org);
|
|
|
|
// process domains
|
|
PackageSettings settings = GetExchangePackageSettings(org);
|
|
if(settings != null)
|
|
{
|
|
// get settings
|
|
string tempDomain = settings[TempDomainSetting];
|
|
string ecpUrl = settings[ExchangeControlPanelUrlSetting];
|
|
|
|
// iterate through domains
|
|
foreach (ExchangeOrganizationDomain domain in org.Domains)
|
|
{
|
|
if (tempDomain != null && domain.Name.EndsWith("." + tempDomain, StringComparison.InvariantCultureIgnoreCase))
|
|
domain.IsTemp = true;
|
|
if (domain.IsDefault && ecpUrl != null)
|
|
org.ExchangeControlPanelUrl = Utils.ReplaceStringVariable(ecpUrl, "domain_name", domain.Name);
|
|
}
|
|
}
|
|
|
|
// return org
|
|
return org;
|
|
}
|
|
|
|
public static void UpdateOrganizationQuotas(ExchangeOrganization org)
|
|
{
|
|
// load default package quotas
|
|
PackageContext cntx = PackageController.GetPackageContext(org.PackageId);
|
|
if (!cntx.Groups.ContainsKey(ResourceGroups.ExchangeHostedEdition))
|
|
return;
|
|
|
|
org.MaxMailboxCountQuota = cntx.Quotas[Quotas.EXCHANGEHOSTEDEDITION_MAILBOXES].QuotaAllocatedValue;
|
|
org.MaxContactCountQuota = cntx.Quotas[Quotas.EXCHANGEHOSTEDEDITION_CONTACTS].QuotaAllocatedValue;
|
|
org.MaxDistributionListCountQuota = cntx.Quotas[Quotas.EXCHANGEHOSTEDEDITION_DISTRIBUTIONLISTS].QuotaAllocatedValue;
|
|
org.MaxDomainsCountQuota = cntx.Quotas[Quotas.EXCHANGEHOSTEDEDITION_DOMAINS].QuotaAllocatedValue;
|
|
}
|
|
|
|
public static List<ExchangeOrganizationDomain> GetOrganizationDomains(int itemId)
|
|
{
|
|
// load organization item
|
|
ExchangeOrganization item = PackageController.GetPackageItem(itemId) as ExchangeOrganization;
|
|
if (item == null)
|
|
return null; // organization item not found
|
|
|
|
// get Exchange service
|
|
ExchangeServerHostedEdition exchange = GetExchangeService(item.ServiceId);
|
|
|
|
// get organization domains
|
|
List<ExchangeOrganizationDomain> domains = new List<ExchangeOrganizationDomain>();
|
|
domains.AddRange(exchange.GetOrganizationDomains(item.Name));
|
|
return domains;
|
|
|
|
//return new List<ExchangeOrganizationDomain>
|
|
//{
|
|
// new ExchangeOrganizationDomain { Identity = "org101\\domain1.com", Name = "domain1.com", IsDefault = true, IsTemp = false },
|
|
// new ExchangeOrganizationDomain { Identity = "org101\\org101.tempdomain.com", Name = "org101.tempdomain.com", IsDefault = false, IsTemp = true },
|
|
// new ExchangeOrganizationDomain { Identity = "org101\\myseconddomain.com", Name = "myseconddomain.com", IsDefault = false, IsTemp = false }
|
|
//};
|
|
}
|
|
|
|
public static string GetExchangeOrganizationSummary(int itemId)
|
|
{
|
|
// load organization details
|
|
ExchangeOrganization org = GetOrganizationDetails(itemId);
|
|
if (org == null)
|
|
return null; // organization not found
|
|
|
|
return GetExchangeOrganizationSummary(org);
|
|
}
|
|
|
|
private static string GetExchangeOrganizationSummary(ExchangeOrganization org)
|
|
{
|
|
// evaluate template
|
|
MailTemplate template = EvaluateOrganizationSummaryTemplate(org);
|
|
if (template == null || template.Body == null)
|
|
return null;
|
|
|
|
return template.IsHtml ? template.Body : template.Body.Replace("\n", "<br/>");
|
|
}
|
|
|
|
private static MailTemplate EvaluateOrganizationSummaryTemplate(ExchangeOrganization org)
|
|
{
|
|
#region create template context
|
|
Hashtable items = new Hashtable();
|
|
|
|
// add organization
|
|
items["org"] = org;
|
|
|
|
// add package information
|
|
PackageInfo space = PackageController.GetPackage(org.PackageId);
|
|
items["space"] = space;
|
|
|
|
// add user information
|
|
UserInfo user = UserController.GetUser(space.UserId);
|
|
items["user"] = user;
|
|
#endregion
|
|
|
|
#region load template
|
|
// load template settings
|
|
UserSettings settings = UserController.GetUserSettings(user.UserId, UserSettings.EXCHANGE_HOSTED_EDITION_ORGANIZATION_SUMMARY);
|
|
if(settings == null)
|
|
return null;
|
|
|
|
// create template
|
|
MailTemplate template = new MailTemplate();
|
|
|
|
// from
|
|
template.From = settings["From"];
|
|
|
|
// BCC
|
|
template.Bcc = settings["CC"];
|
|
|
|
// subject
|
|
template.Subject = settings["Subject"];
|
|
|
|
// body
|
|
template.IsHtml = user.HtmlMail;
|
|
string bodySetting = template.IsHtml ? "HtmlBody" : "TextBody";
|
|
template.Body = settings[bodySetting];
|
|
|
|
// priority
|
|
string priority = settings["Priority"];
|
|
template.Priority = String.IsNullOrEmpty(priority)
|
|
? MailPriority.Normal
|
|
: (MailPriority)Enum.Parse(typeof(MailPriority), priority, true);
|
|
#endregion
|
|
|
|
#region evaluate template
|
|
if(template.Subject != null)
|
|
template.Subject = PackageController.EvaluateTemplate(template.Subject, items);
|
|
|
|
if(template.Body != null)
|
|
template.Body = PackageController.EvaluateTemplate(template.Body, items);
|
|
#endregion
|
|
|
|
return template;
|
|
}
|
|
|
|
private static PackageSettings GetExchangePackageSettings(ExchangeOrganization org)
|
|
{
|
|
// load package settings
|
|
return PackageController.GetPackageSettings(org.PackageId, PackageSettings.EXCHANGE_HOSTED_EDITION);
|
|
}
|
|
|
|
public static ResultObject SendExchangeOrganizationSummary(int itemId, string toEmail)
|
|
{
|
|
ResultObject result = new ResultObject();
|
|
result.IsSuccess = true;
|
|
|
|
try
|
|
{
|
|
// initialize task manager
|
|
TaskManager.StartTask(TaskManagerSource, "SEND_SUMMARY");
|
|
TaskManager.WriteParameter("Item ID", itemId);
|
|
TaskManager.WriteParameter("To e-mail", toEmail);
|
|
|
|
// 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
|
|
|
|
// load organization details
|
|
ExchangeOrganization org = GetOrganizationDetails(item.Id);
|
|
if(org == null)
|
|
return Error<ResultObject>(OrganizationNotFoundError);
|
|
|
|
// get evaluated summary information
|
|
MailTemplate msg = EvaluateOrganizationSummaryTemplate(org);
|
|
if (msg == null)
|
|
return Error<ResultObject>(SendOrganizationTemplateNotSetError);
|
|
|
|
// send message
|
|
int sendResult = MailHelper.SendMessage(msg.From, toEmail, msg.Bcc, msg.Subject, msg.Body, msg.Priority, msg.IsHtml);
|
|
if (sendResult < 0)
|
|
return Error<ResultObject>((-sendResult).ToString());
|
|
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// log error
|
|
TaskManager.WriteError(ex);
|
|
|
|
// exit with error code
|
|
return Error<ResultObject>(SendOrganizationSummaryError, ex.Message);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
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();
|
|
}
|
|
}
|
|
|
|
public static ResultObject DeleteOrganizationDomain(int itemId, string domainName)
|
|
{
|
|
ResultObject result = new ResultObject();
|
|
result.IsSuccess = true;
|
|
|
|
try
|
|
{
|
|
// initialize task manager
|
|
TaskManager.StartTask(TaskManagerSource, "DELETE_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 Exchange service
|
|
ExchangeServerHostedEdition exchange = GetExchangeService(item.ServiceId);
|
|
|
|
// delete domain
|
|
exchange.DeleteOrganizationDomain(item.Name, domainName);
|
|
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// log error
|
|
TaskManager.WriteError(ex);
|
|
|
|
// exit with error code
|
|
return Error<ResultObject>(DeleteDomainError, ex.Message);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static ResultObject UpdateOrganizationQuotas(int itemId, int mailboxesNumber, int contactsNumber, int distributionListsNumber)
|
|
{
|
|
ResultObject result = new ResultObject();
|
|
result.IsSuccess = true;
|
|
|
|
try
|
|
{
|
|
// initialize task manager
|
|
TaskManager.StartTask(TaskManagerSource, "UPDATE_QUOTAS");
|
|
TaskManager.WriteParameter("itemId", itemId);
|
|
TaskManager.WriteParameter("mailboxesNumber", mailboxesNumber);
|
|
TaskManager.WriteParameter("contactsNumber", contactsNumber);
|
|
TaskManager.WriteParameter("distributionListsNumber", distributionListsNumber);
|
|
|
|
// 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
|
|
|
|
// check quotas
|
|
UpdateOrganizationQuotas(item);
|
|
|
|
if(item.MaxMailboxCountQuota > -1 && mailboxesNumber > item.MaxMailboxCountQuota)
|
|
return Error<ResultObject>(UpdateQuotasWrongQuotaError);
|
|
if (item.MaxContactCountQuota > -1 && contactsNumber > item.MaxContactCountQuota)
|
|
return Error<ResultObject>(UpdateQuotasWrongQuotaError);
|
|
if (item.MaxDistributionListCountQuota > -1 && distributionListsNumber > item.MaxDistributionListCountQuota)
|
|
return Error<ResultObject>(UpdateQuotasWrongQuotaError);
|
|
|
|
// get Exchange service
|
|
ExchangeServerHostedEdition exchange = GetExchangeService(item.ServiceId);
|
|
|
|
// update quotas
|
|
exchange.UpdateOrganizationQuotas(item.Name, mailboxesNumber, contactsNumber, distributionListsNumber);
|
|
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// log error
|
|
TaskManager.WriteError(ex);
|
|
|
|
// exit with error code
|
|
return Error<ResultObject>(UpdateQuotasError, ex.Message);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static ResultObject UpdateOrganizationCatchAllAddress(int itemId, string catchAllEmail)
|
|
{
|
|
ResultObject result = new ResultObject();
|
|
result.IsSuccess = true;
|
|
|
|
try
|
|
{
|
|
// initialize task manager
|
|
TaskManager.StartTask(TaskManagerSource, "UPDATE_CATCHALL");
|
|
TaskManager.WriteParameter("itemId", itemId);
|
|
TaskManager.WriteParameter("catchAllEmail", catchAllEmail);
|
|
|
|
// 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 Exchange service
|
|
ExchangeServerHostedEdition exchange = GetExchangeService(item.ServiceId);
|
|
|
|
// update catch-all
|
|
exchange.UpdateOrganizationCatchAllAddress(item.Name, catchAllEmail);
|
|
|
|
// save new catch-all in the item
|
|
item.CatchAllAddress = catchAllEmail;
|
|
PackageController.UpdatePackageItem(item);
|
|
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// log error
|
|
TaskManager.WriteError(ex);
|
|
|
|
// exit with error code
|
|
return Error<ResultObject>(UpdateCatchAllError, ex.Message);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static ResultObject UpdateOrganizationServicePlan(int itemId, int newServiceId)
|
|
{
|
|
ResultObject result = new ResultObject();
|
|
result.IsSuccess = true;
|
|
|
|
try
|
|
{
|
|
// initialize task manager
|
|
TaskManager.StartTask(TaskManagerSource, "UPDATE_SERVICE");
|
|
TaskManager.WriteParameter("itemId", itemId);
|
|
TaskManager.WriteParameter("newServiceId", newServiceId);
|
|
|
|
// 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.IsAdmin | 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 Exchange service
|
|
ExchangeServerHostedEdition exchange = GetExchangeService(item.ServiceId);
|
|
|
|
// load service settings to know ProgramID, OfferID
|
|
StringDictionary serviceSettings = ServerController.GetServiceSettings(newServiceId);
|
|
string programId = serviceSettings["programID"];
|
|
string offerId = serviceSettings["offerID"];
|
|
|
|
// check settings
|
|
if(String.IsNullOrEmpty(programId))
|
|
result.ErrorCodes.Add(ProgramIdIsNotSetError);
|
|
if (String.IsNullOrEmpty(offerId))
|
|
result.ErrorCodes.Add(OfferIdIsNotSetError);
|
|
|
|
// update service plan
|
|
exchange.UpdateOrganizationServicePlan(item.Name, programId, offerId);
|
|
|
|
// move item between services
|
|
int moveResult = PackageController.MovePackageItem(itemId, newServiceId);
|
|
if (moveResult < 0)
|
|
return Error<ResultObject>((-moveResult).ToString());
|
|
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// log error
|
|
TaskManager.WriteError(ex);
|
|
|
|
// exit with error code
|
|
return Error<ResultObject>(UpdateServicePlanError, ex.Message);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
public static ResultObject DeleteOrganization(int itemId)
|
|
{
|
|
ResultObject result = new ResultObject();
|
|
result.IsSuccess = true;
|
|
|
|
try
|
|
{
|
|
// initialize task manager
|
|
TaskManager.StartTask(TaskManagerSource, "DELETE_ORGANIZATION");
|
|
TaskManager.WriteParameter("itemId", itemId);
|
|
|
|
// 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 Exchange service
|
|
ExchangeServerHostedEdition exchange = GetExchangeService(item.ServiceId);
|
|
|
|
// delete organization
|
|
exchange.DeleteOrganization(item.Name);
|
|
|
|
// delete meta-item
|
|
PackageController.DeletePackageItem(itemId);
|
|
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// log error
|
|
TaskManager.WriteError(ex);
|
|
|
|
// exit with error code
|
|
return Error<ResultObject>(DeleteOrganizationError, ex.Message);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
#region Private helpers
|
|
public static ExchangeServerHostedEdition GetExchangeService(int serviceId)
|
|
{
|
|
ExchangeServerHostedEdition ws = new ExchangeServerHostedEdition();
|
|
ServiceProviderProxy.Init(ws, serviceId);
|
|
return ws;
|
|
}
|
|
#endregion
|
|
|
|
#region Result object routines
|
|
private static T Warning<T>(params string[] messageParts)
|
|
{
|
|
return Warning<T>(null, messageParts);
|
|
}
|
|
|
|
private static T Warning<T>(ResultObject innerResult, params string[] messageParts)
|
|
{
|
|
return Result<T>(innerResult, false, messageParts);
|
|
}
|
|
|
|
private static T Error<T>(params string[] messageParts)
|
|
{
|
|
return Error<T>(null, messageParts);
|
|
}
|
|
|
|
private static T Error<T>(ResultObject innerResult, params string[] messageParts)
|
|
{
|
|
return Result<T>(innerResult, true, messageParts);
|
|
}
|
|
|
|
private static T Result<T>(ResultObject innerResult, bool isError, params string[] messageParts)
|
|
{
|
|
object obj = Activator.CreateInstance<T>();
|
|
ResultObject result = (ResultObject)obj;
|
|
|
|
// set error
|
|
result.IsSuccess = !isError;
|
|
|
|
// add message
|
|
if (messageParts != null)
|
|
result.ErrorCodes.Add(String.Join(":", messageParts));
|
|
|
|
// copy errors from inner result
|
|
if (innerResult != null)
|
|
result.ErrorCodes.AddRange(innerResult.ErrorCodes);
|
|
|
|
return (T)obj;
|
|
}
|
|
#endregion
|
|
}
|
|
} |