private void ShowCrmOrganizationDetails(string admin, Organization org)
{
btnCreate.Visible = false;
ddlCollation.Enabled = false;
ddlCurrency.Enabled = false;
administrator.Visible = false;
lblAdmin.Visible = true;
lblAdmin.Text = admin;
btnDelete.Visible = true;
hlOrganizationPage.Visible = true;
hlOrganizationPage.NavigateUrl = org.CrmUrl;
hlOrganizationPage.Text = org.CrmUrl;
}
public static string EvaluateMailboxTemplate(string template, Organization org, int? accountId, int itemId)
{
OrganizationUser user = null;
if (accountId.HasValue)
{
user = OrganizationController.GetAccount(itemId, accountId.Value);
}
Hashtable items = new Hashtable();
items["Organization"] = org;
if (user != null)
{
items["account"] = user;
}
return PackageController.EvaluateTemplate(template, items);
}
/// <summary>
/// Creates organization on Mail Server
/// </summary>
/// <param name="organizationId"></param>
/// <returns></returns>
internal override Organization ExtendToExchangeOrganizationInternal(string organizationId, string securityGroup, bool IsConsumer)
{
ExchangeLog.LogStart("CreateOrganizationInternal");
ExchangeLog.DebugInfo(" Organization Id: {0}", organizationId);
ExchangeTransaction transaction = StartTransaction();
Organization info = new Organization();
Runspace runSpace = null;
try
{
runSpace = OpenRunspace();
string server = GetServerName();
string securityGroupPath = AddADPrefix(securityGroup);
//Create mail enabled organization security group
EnableMailSecurityDistributionGroup(runSpace, securityGroup, organizationId);
transaction.RegisterMailEnabledDistributionGroup(securityGroup);
UpdateSecurityDistributionGroup(runSpace, securityGroup, organizationId, IsConsumer);
//create GAL
string galId = CreateGlobalAddressList(runSpace, organizationId);
transaction.RegisterNewGlobalAddressList(galId);
ExchangeLog.LogInfo(" Global Address List: {0}", galId);
UpdateGlobalAddressList(runSpace, galId, securityGroupPath);
//create AL
string alId = CreateAddressList(runSpace, organizationId);
transaction.RegisterNewAddressList(alId);
ExchangeLog.LogInfo(" Address List: {0}", alId);
UpdateAddressList(runSpace, alId, securityGroupPath);
//create RAL
string ralId = CreateRoomsAddressList(runSpace, organizationId);
transaction.RegisterNewRoomsAddressList(ralId);
ExchangeLog.LogInfo(" Rooms Address List: {0}", ralId);
UpdateAddressList(runSpace, ralId, securityGroupPath);
//create ActiveSync policy
string asId = CreateActiveSyncPolicy(runSpace, organizationId);
transaction.RegisterNewActiveSyncPolicy(asId);
ExchangeLog.LogInfo(" ActiveSync Policy: {0}", asId);
info.AddressList = alId;
info.GlobalAddressList = galId;
info.RoomsAddressList = ralId;
info.OrganizationId = organizationId;
}
catch (Exception ex)
{
ExchangeLog.LogError("CreateOrganizationInternal", ex);
RollbackTransaction(transaction);
throw;
}
finally
{
CloseRunspace(runSpace);
}
ExchangeLog.LogEnd("CreateOrganizationInternal");
return info;
}
public static Organization GetOrganization(int itemId)
{
#region Demo Mode
if (IsDemoMode)
{
// load package by user
Organization org = new Organization();
org.PackageId = 0;
org.Id = 1;
org.OrganizationId = "fabrikam";
org.Name = "Fabrikam Inc";
org.IssueWarningKB = 150000;
org.ProhibitSendKB = 170000;
org.ProhibitSendReceiveKB = 190000;
org.KeepDeletedItemsDays = 14;
org.GlobalAddressList = "FabrikamGAL";
return org;
}
#endregion
return (Organization)PackageController.GetPackageItem(itemId);
}
internal override Organization CreateOrganizationAddressBookPolicyInternal(string organizationId, string gal, string addressBook, string roomList, string oab)
{
ExchangeLog.LogStart("CreateOrganizationAddressBookPolicyInternal");
ExchangeLog.LogInfo(" Organization Id: {0}", organizationId);
ExchangeLog.LogInfo(" GAL: {0}", gal);
ExchangeLog.LogInfo(" AddressBook: {0}", addressBook);
ExchangeLog.LogInfo(" RoomList: {0}", roomList);
ExchangeLog.LogInfo(" OAB: {0}", oab);
ExchangeTransaction transaction = StartTransaction();
Organization info = new Organization();
string policyName = GetAddressBookPolicyName(organizationId);
Runspace runSpace = null;
try
{
runSpace = OpenRunspace();
Command cmd = new Command("New-AddressBookPolicy");
cmd.Parameters.Add("Name", policyName);
cmd.Parameters.Add("AddressLists", addressBook);
cmd.Parameters.Add("RoomList", roomList);
cmd.Parameters.Add("GlobalAddressList", gal);
cmd.Parameters.Add("OfflineAddressBook", oab);
Collection<PSObject> result = ExecuteShellCommand(runSpace, cmd);
info.AddressBookPolicy = GetResultObjectDN(result);
}
catch (Exception ex)
{
ExchangeLog.LogError("CreateOrganizationAddressBookPolicyInternal", ex);
RollbackTransaction(transaction);
throw;
}
finally
{
CloseRunspace(runSpace);
}
ExchangeLog.LogEnd("CreateOrganizationAddressBookPolicyInternal");
return info;
}
private static int ExtendToExchangeOrganization(ref Organization org)
{
// place log record
TaskManager.StartTask("EXCHANGE", "CREATE_ORG", org.Name);
TaskManager.TaskParameters["Organization ID"] = org.OrganizationId;
try
{
// provision organization in Exchange
int serviceId = GetExchangeServiceID(org.PackageId);
int[] hubTransportServiceIds;
int[] clientAccessServiceIds;
GetExchangeServices(serviceId, out hubTransportServiceIds, out clientAccessServiceIds);
ExchangeServer mailboxRole = GetExchangeServer(serviceId, org.ServiceId);
bool authDomainCreated = false;
int itemId = 0;
bool organizationExtended = false;
List<OrganizationDomainName> domains = null;
try
{
// 1) Create Organization (Mailbox)
// ================================
Organization exchangeOrganization = mailboxRole.ExtendToExchangeOrganization(org.OrganizationId, org.SecurityGroup);
organizationExtended = true;
exchangeOrganization.OrganizationId = org.OrganizationId;
exchangeOrganization.PackageId = org.PackageId;
exchangeOrganization.ServiceId = org.ServiceId;
exchangeOrganization.DefaultDomain = org.DefaultDomain;
exchangeOrganization.Name = org.Name;
exchangeOrganization.Id = org.Id;
exchangeOrganization.SecurityGroup = org.SecurityGroup;
exchangeOrganization.DistinguishedName = org.DistinguishedName;
exchangeOrganization.CrmAdministratorId = org.CrmAdministratorId;
exchangeOrganization.CrmCollation = org.CrmCollation;
exchangeOrganization.CrmCurrency = org.CrmCurrency;
exchangeOrganization.CrmLanguadgeCode = org.CrmLanguadgeCode;
exchangeOrganization.CrmOrganizationId = org.CrmOrganizationId;
exchangeOrganization.CrmOrgState = org.CrmOrgState;
exchangeOrganization.CrmUrl = org.CrmUrl;
org = exchangeOrganization;
// 2) Get OAB virtual directories from Client Access servers and
// create Create Organization OAB (Mailbox)
// ==========================================
List<string> oabVirtualDirs = new List<string>();
foreach (int id in clientAccessServiceIds)
{
ExchangeServer clientAccessRole = null;
try
{
clientAccessRole = GetExchangeServer(id, org.ServiceId);
}
catch(Exception ex)
{
TaskManager.WriteError(ex);
continue;
}
oabVirtualDirs.Add(clientAccessRole.GetOABVirtualDirectory());
}
Organization orgOAB = mailboxRole.CreateOrganizationOfflineAddressBook(org.OrganizationId, org.SecurityGroup, string.Join(",", oabVirtualDirs.ToArray()));
org.OfflineAddressBook = orgOAB.OfflineAddressBook;
// 3) Add organization domains (Hub Transport)
domains = OrganizationController.GetOrganizationDomains(org.Id);
foreach (int id in hubTransportServiceIds)
{
ExchangeServer hubTransportRole = null;
try
{
hubTransportRole = GetExchangeServer(id, org.ServiceId);
}
catch(Exception ex)
{
TaskManager.WriteError(ex);
continue;
}
string[] existingDomains = hubTransportRole.GetAuthoritativeDomains();
if (existingDomains != null)
Array.Sort(existingDomains);
foreach (OrganizationDomainName domain in domains)
{
if (existingDomains == null || Array.BinarySearch(existingDomains, domain.DomainName) < 0)
{
hubTransportRole.AddAuthoritativeDomain(domain.DomainName);
}
}
authDomainCreated = true;
break;
}
PackageContext cntx = PackageController.GetPackageContext(org.PackageId);
// organization limits
org.IssueWarningKB = cntx.Quotas[Quotas.EXCHANGE2007_DISKSPACE].QuotaAllocatedValue;
if (org.IssueWarningKB > 0)
org.IssueWarningKB *= Convert.ToInt32(1024*0.9); //90%
org.ProhibitSendKB = cntx.Quotas[Quotas.EXCHANGE2007_DISKSPACE].QuotaAllocatedValue;
if (org.ProhibitSendKB > 0)
org.ProhibitSendKB *= 1024; //100%
org.ProhibitSendReceiveKB = cntx.Quotas[Quotas.EXCHANGE2007_DISKSPACE].QuotaAllocatedValue;
if (org.ProhibitSendReceiveKB > 0)
org.ProhibitSendReceiveKB *= 1024; //100%
StringDictionary settings = ServerController.GetServiceSettings(serviceId);
org.KeepDeletedItemsDays = Utils.ParseInt(settings["KeepDeletedItemsDays"], 14);
}
catch (Exception ex)
{
// rollback organization creation
if (organizationExtended)
mailboxRole.DeleteOrganization(org.OrganizationId, org.DistinguishedName,
org.GlobalAddressList, org.AddressList, org.OfflineAddressBook, org.SecurityGroup);
// rollback domain
if (authDomainCreated)
foreach (int id in hubTransportServiceIds)
{
ExchangeServer hubTransportRole = null;
try
{
hubTransportRole = GetExchangeServer(id, org.ServiceId);
}
catch (Exception exe)
{
TaskManager.WriteError(exe);
continue;
}
foreach (OrganizationDomainName domain in domains)
{
hubTransportRole.DeleteAuthoritativeDomain(domain.DomainName);
}
break;
}
throw TaskManager.WriteError(ex);
}
return itemId;
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
private static int AddOrganizationToPackageItems(Organization org, int serviceId, int packageId, string organizationName, string organizationId, string domainName)
{
org.ServiceId = serviceId;
org.PackageId = packageId;
org.Name = organizationName;
org.OrganizationId = organizationId;
org.DefaultDomain = domainName;
int itemId = PackageController.AddPackageItem(org);
return itemId;
}
private static void PopulateOrganizationData(Organization org, EnterpriseSolutionStatisticsReport report, string topReseller)
{
TaskManager.Write("Stat populate organization data "+org.Name);
if (report.ExchangeReport != null)
{
try
{
TaskManager.Write("Populate exchange report items");
PopulateExchangeReportItems(org, report, topReseller);
}
catch(Exception ex)
{
TaskManager.WriteError(ex);
}
}
if (report.CRMReport != null)
{
try
{
TaskManager.Write("Populate populate CRM report items");
PopulateCRMReportItems(org, report, topReseller);
}
catch(Exception ex)
{
TaskManager.WriteError(ex);
}
}
if (report.SharePointReport != null)
{
try
{
TaskManager.Write("Populate SharePoint item ");
PopulateSharePointItem(org, report, topReseller);
}
catch(Exception ex)
{
TaskManager.WriteError(ex);
}
}
if (report.SharePointEnterpriseReport != null)
{
try
{
TaskManager.Write("Populate SharePoint Enterprise item ");
PopulateSharePointEnterpriseItem(org, report, topReseller);
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
}
}
if (report.LyncReport != null)
{
try
{
TaskManager.Write("Populate Lync report items");
PopulateLyncReportItems(org, report, topReseller);
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
}
}
if (report.OrganizationReport != null)
{
try
{
TaskManager.Write("Populate Organization statistics report");
PopulateOrganizationStatisticsReport(org, report, topReseller);
}
catch(Exception ex)
{
TaskManager.WriteError(ex);
}
}
TaskManager.Write("End populate organization data " + org.Name);
}
private static void PopulateBaseItem(BaseStatistics stats, Organization org, string topReseller)
{
PackageInfo package;
UserInfo user;
try
{
package = PackageController.GetPackage(org.PackageId);
}
catch(Exception ex)
{
throw new ApplicationException(string.Format("Could not get package {0}", org.PackageId), ex);
}
try
{
user = UserController.GetUser(package.UserId);
}
catch(Exception ex)
{
throw new ApplicationException(string.Format("Could not get user {0}", package.UserId), ex);
}
stats.HostingSpace = package.PackageName;
stats.OrganizationID = org.OrganizationId;
stats.OrganizationName = org.Name;
stats.CustomerName = UserController.GetUser(package.UserId).Username;
stats.CustomerCreated = user.Created;
stats.ResellerName = UserController.GetUser(user.OwnerId).Username;
stats.TopResellerName = topReseller;
stats.OrganizationCreated = org.CreatedDate;
stats.HostingSpaceCreated = package.PurchaseDate;
}
public static void FixOrganization(Organization organization)
{
if (String.IsNullOrEmpty(organization.OrganizationId))
return;
Log.WriteLine("Organization " + organization.OrganizationId);
string res = "";
try
{
res = ES.Services.ExchangeServer.SetDefaultPublicFolderMailbox(organization.Id);
}
catch(Exception ex)
{
Log.WriteError(ex.ToString());
}
Log.WriteLine(res);
}
private void ChangeOrganizationState(Organization org, bool enabled)
{
string path = GetOrganizationPath(org.OrganizationId);
DirectoryEntry entry = ActiveDirectoryUtils.GetADObject(path);
string filter =
string.Format(CultureInfo.InvariantCulture, "(&(objectClass=user)(!{0}=disabled))",
ADAttributes.CustomAttribute2);
using (DirectorySearcher searcher = new DirectorySearcher(entry, filter))
{
SearchResultCollection resCollection = searcher.FindAll();
foreach (SearchResult res in resCollection)
{
DirectoryEntry de = res.GetDirectoryEntry();
de.InvokeSet("AccountDisabled", !enabled);
de.CommitChanges();
}
}
}
private static void PopulateLyncReportItems(Organization org, EnterpriseSolutionStatisticsReport report, string topReseller)
{
//Check if lync organization
if (string.IsNullOrEmpty(org.LyncTenantId))
return;
LyncUser[] lyncUsers = null;
try
{
LyncUsersPagedResult res = LyncController.GetLyncUsers(org.Id);
if (res.IsSuccess) lyncUsers = res.Value.PageUsers;
}
catch (Exception ex)
{
throw new ApplicationException(
string.Format("Could not get lync users for current organization {0}", org.Id), ex);
}
if (lyncUsers == null)
return;
foreach (LyncUser lyncUser in lyncUsers)
{
try
{
LyncUserStatistics stats = new LyncUserStatistics();
try
{
stats.SipAddress = lyncUser.SipAddress;
if (string.IsNullOrEmpty(lyncUser.LineUri)) stats.PhoneNumber = string.Empty; else stats.PhoneNumber = lyncUser.LineUri;
LyncUserPlan plan = LyncController.GetLyncUserPlan(org.Id, lyncUser.LyncUserPlanId);
stats.Conferencing = plan.Conferencing;
stats.EnterpriseVoice = plan.EnterpriseVoice;
stats.Federation = plan.Federation;
stats.InstantMessaing = plan.IM;
stats.MobileAccess = plan.Mobility;
stats.LyncUserPlan = plan.LyncUserPlanName;
stats.DisplayName = lyncUser.DisplayName;
}
catch (Exception ex)
{
TaskManager.WriteError(ex, "Could not get lync statistics. AccountName: {0}",
lyncUser.DisplayName);
}
if (stats != null)
{
PopulateBaseItem(stats, org, topReseller);
report.LyncReport.Items.Add(stats);
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
}
}
}
private static Organization PopulateOrganization(int packageId, string organizationId, string addressListsContainer)
{
Organization org = new Organization();
org.OrganizationId = organizationId;
org.AddressList = string.Format("CN={0} Address List,CN=All Address Lists,{1}", organizationId, addressListsContainer);
org.GlobalAddressList = string.Format("CN={0} Global Address List,CN=All Global Address Lists,{1}", organizationId, addressListsContainer);
org.OfflineAddressBook = string.Format("CN={0} Offline Address Book,CN=Offline Address Lists,{1}", organizationId, addressListsContainer);
org.Database = GetDatabaseName();
org.DistinguishedName = ADUtils.RemoveADPrefix(Global.OrgDirectoryEntry.Path);
org.SecurityGroup = string.Format("CN={0},{1}", organizationId, org.DistinguishedName);
PackageContext cntx = PackageController.GetPackageContext(packageId);
// organization limits
org.IssueWarningKB = cntx.Quotas[Quotas.EXCHANGE2007_DISKSPACE].QuotaAllocatedValue;
if (org.IssueWarningKB > 0) org.IssueWarningKB *= 1024;
org.ProhibitSendKB = cntx.Quotas[Quotas.EXCHANGE2007_DISKSPACE].QuotaAllocatedValue;
if (org.ProhibitSendKB > 0) org.ProhibitSendKB *= 1024;
org.ProhibitSendReceiveKB = cntx.Quotas[Quotas.EXCHANGE2007_DISKSPACE].QuotaAllocatedValue;
if (org.ProhibitSendReceiveKB > 0) org.ProhibitSendReceiveKB *= 1024;
PackageSettings settings = PackageController.GetPackageSettings(packageId, PackageSettings.EXCHANGE_SERVER);
org.KeepDeletedItemsDays = Utils.ParseInt(settings["KeepDeletedItemsDays"], 14);
return org;
}
private static void PopulateExchangeReportItems(Organization org, EnterpriseSolutionStatisticsReport report, string topReseller)
{
TaskManager.Write("Exchange Report Items " + org.Name);
//Check if exchange organization
if (string.IsNullOrEmpty(org.GlobalAddressList))
return;
List<ExchangeAccount> mailboxes;
Providers.Exchange.ExchangeServer exchange;
try
{
mailboxes = ExchangeServerController.GetExchangeMailboxes(org.Id);
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
throw new ApplicationException(
string.Format("Could not get mailboxes for current organization {0}", org.Id), ex);
}
TaskManager.WriteParameter("mailboxes.Count", mailboxes.Count);
try
{
int exchangeServiceId = GetExchangeServiceID(org.PackageId);
exchange = ExchangeServerController.GetExchangeServer(exchangeServiceId, org.ServiceId);
}
catch(Exception ex)
{
TaskManager.WriteError(ex);
throw new ApplicationException(
string.Format("Could not get exchange server. PackageId: {0}", org.PackageId), ex);
}
ExchangeMailboxStatistics stats;
foreach (ExchangeAccount mailbox in mailboxes)
{
try
{
TaskManager.WriteParameter("mailbox", mailbox.UserPrincipalName);
stats = null;
try
{
stats = exchange.GetMailboxStatistics(mailbox.UserPrincipalName);
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
TaskManager.WriteError(ex, "Could not get mailbox statistics. AccountName: {0}",
mailbox.UserPrincipalName);
}
if (stats != null)
{
PopulateBaseItem(stats, org, topReseller);
stats.MailboxType = mailbox.AccountType;
if (mailbox.AccountType == ExchangeAccountType.Mailbox)
{
ExchangeAccount a = ExchangeServerController.GetAccount(mailbox.ItemId, mailbox.AccountId);
stats.MailboxPlan = a.MailboxPlan;
}
stats.BlackberryEnabled = BlackBerryController.CheckBlackBerryUserExists(mailbox.AccountId);
report.ExchangeReport.Items.Add(stats);
TaskManager.Write("Items.Add");
}
}
catch(Exception ex)
{
TaskManager.WriteError(ex);
}
}
TaskManager.Write("End Populate Exchange Report Items " + org.Name);
}
private static void PopulateSharePointEnterpriseItem(Organization org, EnterpriseSolutionStatisticsReport report, string topReseller)
{
List<SharePointEnterpriseSiteCollection> siteCollections;
try
{
siteCollections = HostedSharePointServerEntController.GetSiteCollections(org.Id);
}
catch (Exception ex)
{
throw new ApplicationException(string.Format("Could not get site collections. OrgId: {0}", org.Id), ex);
}
if (siteCollections == null || siteCollections.Count == 0)
return;
HostedSharePointServerEnt srvEnt;
try
{
int serviceId = GetHostedSharePointEntServiceId(org.PackageId);
srvEnt = GetHostedSharePointServerEnt(serviceId);
}
catch (Exception ex)
{
throw new ApplicationException(
string.Format("Could not get sharepoint enterprise server. PackageId: {0}", org.PackageId), ex);
}
foreach (SharePointEnterpriseSiteCollection siteCollection in siteCollections)
{
try
{
SharePointEnterpriseStatistics stats = new SharePointEnterpriseStatistics();
PopulateBaseItem(stats, org, topReseller);
stats.SiteCollectionUrl = siteCollection.PhysicalAddress;
stats.SiteCollectionOwner = siteCollection.OwnerName;
stats.SiteCollectionQuota = siteCollection.MaxSiteStorage;
stats.SiteCollectionCreated = siteCollection.CreatedDate;
stats.SiteCollectionSize = srvEnt.Enterprise_GetSiteCollectionSize(siteCollection.PhysicalAddress);
report.SharePointEnterpriseReport.Items.Add(stats);
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
}
}
}
private static void PopulateOrganizationStatisticsReport(Organization org, EnterpriseSolutionStatisticsReport report, string topReseller)
{
OrganizationStatisticsRepotItem item = new OrganizationStatisticsRepotItem();
PopulateBaseItem(item, org, topReseller);
if (report.ExchangeReport != null)
{
try
{
List<ExchangeMailboxStatistics> mailboxStats =
report.ExchangeReport.Items.FindAll(
delegate(ExchangeMailboxStatistics stats)
{ return stats.OrganizationID == org.OrganizationId; });
item.TotalMailboxes = mailboxStats.Count;
foreach (ExchangeMailboxStatistics current in mailboxStats)
{
item.TotalMailboxesSize += current.TotalSize;
}
Providers.Exchange.ExchangeServer exchange;
if (!string.IsNullOrEmpty(org.GlobalAddressList))
{
try
{
int exchangeServiceId = GetExchangeServiceID(org.PackageId);
exchange =
ExchangeServerController.GetExchangeServer(exchangeServiceId, org.ServiceId);
}
catch (Exception ex)
{
throw new ApplicationException(
string.Format("Could not get exchange server. PackageId: {0}", org.PackageId), ex);
}
try
{
item.TotalPublicFoldersSize = exchange.GetPublicFolderSize(org.OrganizationId, "\\" + org.OrganizationId);
}
catch (Exception ex)
{
throw new ApplicationException(
string.Format("Could not get public folder size. OrgId: {0}", org.OrganizationId), ex);
}
}
try
{
org.DiskSpace = (int)(item.TotalPublicFoldersSize + item.TotalMailboxesSize);
PackageController.UpdatePackageItem(org);
}
catch(Exception ex)
{
throw new ApplicationException(string.Format("Could not calcualate diskspace. Org Id: {0}", org.Id), ex);
}
}
catch(Exception ex)
{
TaskManager.WriteError(ex);
}
}
if (report.SharePointReport != null)
{
List<SharePointStatistics> sharePoints =
report.SharePointReport.Items.FindAll(
delegate(SharePointStatistics stats) { return stats.OrganizationID == org.OrganizationId; });
item.TotalSharePointSiteCollections = sharePoints.Count;
foreach (SharePointStatistics current in sharePoints)
{
item.TotalSharePointSiteCollectionsSize += current.SiteCollectionSize;
}
}
if (report.SharePointEnterpriseReport != null)
{
List<SharePointEnterpriseStatistics> sharePoints =
report.SharePointEnterpriseReport.Items.FindAll(
delegate(SharePointEnterpriseStatistics stats) { return stats.OrganizationID == org.OrganizationId; });
item.TotalSharePointEnterpriseSiteCollections = sharePoints.Count;
foreach (SharePointEnterpriseStatistics current in sharePoints)
{
item.TotalSharePointEnterpriseSiteCollectionsSize += current.SiteCollectionSize;
}
}
if (report.CRMReport != null)
{
List<CRMOrganizationStatistics> crmOrganizationStatistics =
report.CRMReport.Items.FindAll(
delegate(CRMOrganizationStatistics stats) { return stats.OrganizationID == org.OrganizationId; });
item.TotalCRMUsers = crmOrganizationStatistics.Count;
}
item.TotalLyncUsers = 0;
item.TotalLyncEVUsers = 0;
if (report.LyncReport != null)
{
List<LyncUserStatistics> lyncOrganizationStatistics =
report.LyncReport.Items.FindAll(
delegate(LyncUserStatistics stats) { return stats.OrganizationID == org.OrganizationId; });
foreach (LyncUserStatistics current in lyncOrganizationStatistics)
{
if (current.EnterpriseVoice) item.TotalLyncEVUsers++;
}
item.TotalLyncUsers = lyncOrganizationStatistics.Count;
}
report.OrganizationReport.Items.Add(item);
}
/// <summary> Checks and sets disk quotas values.</summary>
/// <param name="organization"> The organization.</param>
/// <param name="collection"> The site collection.</param>
private void SetStorageQuotas(Organization organization, SharePointEnterpriseSiteCollection collection)
{
var quotaValue = organization.MaxSharePointEnterpriseStorage;
if (quotaValue != -1)
{
var spaceResrved = GetReservedDiskStorageSpace();
if (spaceResrved > quotaValue)
{
quotaValue = 0;
}
else
{
quotaValue -= spaceResrved;
}
if (collection != null)
{
quotaValue += (int)collection.MaxSiteStorage;
}
}
maxStorage.ParentQuotaValue = quotaValue;
maxStorage.QuotaValue = quotaValue;
editMaxStorage.ParentQuotaValue = quotaValue;
warningStorage.ParentQuotaValue = quotaValue;
warningStorage.QuotaValue = quotaValue;
editWarningStorage.ParentQuotaValue = quotaValue;
btnUpdate.Enabled = quotaValue != 0;
}
public static Organization GetOrganization(int itemId, bool withLog = true)
{
#region Demo Mode
if (IsDemoMode)
{
// load package by user
Organization orgDemo = new Organization();
orgDemo.PackageId = 0;
orgDemo.Id = 1;
orgDemo.OrganizationId = "fabrikam";
orgDemo.Name = "Fabrikam Inc";
orgDemo.KeepDeletedItemsDays = 14;
// Log Extension
if (withLog)
LogExtension.WriteObject(orgDemo);
return orgDemo;
}
#endregion
var org = (Organization)PackageController.GetPackageItem(itemId);
// Log Extension
if (withLog)
LogExtension.WriteObject(org);
return org;
}
internal Organization CreateOrganizationInternal(string organizationId)
{
HostedSolutionLog.LogStart("CreateOrganizationInternal");
HostedSolutionLog.DebugInfo("OrganizationId : {0}", organizationId);
if (string.IsNullOrEmpty(organizationId))
throw new ArgumentNullException("organizationId");
bool ouCreated = false;
bool groupCreated = false;
Organization org;
try
{
string parentPath = GetRootOU();
string orgPath = GetOrganizationPath(organizationId);
//Create OU
ActiveDirectoryUtils.CreateOrganizationalUnit(organizationId, parentPath);
ouCreated = true;
//Create security group
ActiveDirectoryUtils.CreateGroup(orgPath, organizationId);
groupCreated = true;
org = new Organization();
org.OrganizationId = organizationId;
org.DistinguishedName = ActiveDirectoryUtils.RemoveADPrefix(orgPath);
org.SecurityGroup = ActiveDirectoryUtils.RemoveADPrefix(GetGroupPath(organizationId));
org.GroupName = organizationId;
}
catch (Exception ex)
{
HostedSolutionLog.LogError(ex);
try
{
if (groupCreated)
{
string groupPath = GetGroupPath(organizationId);
ActiveDirectoryUtils.DeleteADObject(groupPath);
}
}
catch (Exception e)
{
HostedSolutionLog.LogError(e);
}
try
{
if (ouCreated)
{
string orgPath = GetOrganizationPath(organizationId);
ActiveDirectoryUtils.DeleteADObject(orgPath);
}
}
catch (Exception e)
{
HostedSolutionLog.LogError(e);
}
throw;
}
HostedSolutionLog.LogEnd("CreateOrganizationInternal");
return org;
}
private static void PopulateCRMReportItems(Organization org, EnterpriseSolutionStatisticsReport report, string topReseller)
{
if (org.CrmOrganizationId == Guid.Empty)
return;
List<OrganizationUser> users;
try
{
users = CRMController.GetCRMOrganizationUsers(org.Id);
}
catch(Exception ex)
{
throw new ApplicationException(
string.Format("Could not get CRM Organization users. OrgId : {0}", org.Id), ex);
}
CRM crm;
try
{
crm = GetCRMProxy(org.PackageId);
}
catch(Exception ex)
{
throw new ApplicationException(string.Format("Could not get CRM Proxy. PackageId: {0}", org.PackageId),
ex);
}
foreach (OrganizationUser user in users)
{
try
{
CRMOrganizationStatistics stats = new CRMOrganizationStatistics();
PopulateBaseItem(stats, org, topReseller);
stats.CRMOrganizationId = org.CrmOrganizationId;
stats.CRMUserName = user.DisplayName;
Guid crmUserId = CRMController.GetCrmUserId(user.AccountId);
CrmUserResult res = crm.GetCrmUserById(crmUserId, org.OrganizationId);
if (res.IsSuccess && res.Value != null)
{
stats.ClientAccessMode = res.Value.ClientAccessMode;
stats.CRMDisabled = res.Value.IsDisabled;
}
else
{
StringBuilder sb = new StringBuilder("Could not get CRM user by id.");
foreach (string str in res.ErrorCodes)
{
sb.AppendFormat("\n{0};", str);
}
throw new ApplicationException(sb.ToString());
}
report.CRMReport.Items.Add(stats);
}
catch(Exception ex)
{
TaskManager.WriteError(ex);
}
}
}
private static void UpdateOrganization(Organization organization)
{
PackageController.UpdatePackageItem(organization);
}
private static ResultObject SetDriveMapsTargetingFilter(Organization org, ESPermission[] permissions, string folderName)
{
ResultObject result = TaskManager.StartResultTask<ResultObject>("ENTERPRISE_STORAGE", "SET_MAPPED_DRIVE_TARGETING_FILTER");
try
{
Organizations orgProxy = OrganizationController.GetOrganizationProxy(org.ServiceId);
List<ExchangeAccount> accounts = new List<ExchangeAccount>();
foreach (var permission in permissions)
{
accounts.Add(ObjectUtils.FillObjectFromDataReader<ExchangeAccount>(DataProvider.GetExchangeAccountByAccountName(org.Id, permission.Account)));
}
orgProxy.SetDriveMapsTargetingFilter(org.OrganizationId, accounts.ToArray(), folderName);
}
catch (Exception ex)
{
result.AddError("ENTERPRISE_STORAGE_SET_MAPPED_DRIVE_TARGETING_FILTER", ex);
}
finally
{
if (!result.IsSuccess)
{
TaskManager.CompleteResultTask(result);
}
else
{
TaskManager.CompleteResultTask();
}
}
return result;
}
private static int ExtendToExchangeOrganization(ref Organization org)
{
// place log record
TaskManager.StartTask("EXCHANGE", "CREATE_ORG", org.Name, new BackgroundTaskParameter("Organization ID", org.OrganizationId));
// Log Extension
LogExtension.WriteObject(org, o => o.DistinguishedName, o => o.OrganizationId);
try
{
// provision organization in Exchange
int serviceId = GetExchangeServiceID(org.PackageId);
int[] hubTransportServiceIds;
int[] clientAccessServiceIds;
GetExchangeServices(serviceId, out hubTransportServiceIds, out clientAccessServiceIds);
ExchangeServer mailboxRole = GetExchangeServer(serviceId, org.ServiceId);
bool authDomainCreated = false;
int itemId = 0;
bool organizationExtended = false;
List<OrganizationDomainName> domains = null;
try
{
PackageContext cntx = PackageController.GetPackageContext(org.PackageId);
// 1) Create Organization (Mailbox)
// ================================
Organization exchangeOrganization = mailboxRole.ExtendToExchangeOrganization(org.OrganizationId,
org.SecurityGroup,
Convert.ToBoolean(cntx.Quotas[Quotas.EXCHANGE2007_ISCONSUMER].QuotaAllocatedValue));
organizationExtended = true;
exchangeOrganization.OrganizationId = org.OrganizationId;
exchangeOrganization.PackageId = org.PackageId;
exchangeOrganization.ServiceId = org.ServiceId;
exchangeOrganization.DefaultDomain = org.DefaultDomain;
exchangeOrganization.Name = org.Name;
exchangeOrganization.Id = org.Id;
exchangeOrganization.SecurityGroup = org.SecurityGroup;
exchangeOrganization.DistinguishedName = org.DistinguishedName;
exchangeOrganization.CrmAdministratorId = org.CrmAdministratorId;
exchangeOrganization.CrmCollation = org.CrmCollation;
exchangeOrganization.CrmCurrency = org.CrmCurrency;
exchangeOrganization.CrmLanguadgeCode = org.CrmLanguadgeCode;
exchangeOrganization.CrmOrganizationId = org.CrmOrganizationId;
exchangeOrganization.CrmOrgState = org.CrmOrgState;
exchangeOrganization.CrmUrl = org.CrmUrl;
org = exchangeOrganization;
// 2) Get OAB virtual directories from Client Access servers and
// create Create Organization OAB (Mailbox)
// ==========================================
List<string> oabVirtualDirs = new List<string>();
foreach (int id in clientAccessServiceIds)
{
ExchangeServer clientAccessRole = null;
try
{
clientAccessRole = GetExchangeServer(id, org.ServiceId);
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
continue;
}
oabVirtualDirs.Add(clientAccessRole.GetOABVirtualDirectory());
}
Organization orgOAB = mailboxRole.CreateOrganizationOfflineAddressBook(org.OrganizationId, org.SecurityGroup, string.Join(",", oabVirtualDirs.ToArray()));
org.OfflineAddressBook = orgOAB.OfflineAddressBook;
// 3) Add organization domains (Hub Transport)
domains = OrganizationController.GetOrganizationDomains(org.Id);
foreach (int id in hubTransportServiceIds)
{
ExchangeServer hubTransportRole = null;
try
{
hubTransportRole = GetExchangeServer(id, org.ServiceId);
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
continue;
}
string[] existingDomains = hubTransportRole.GetAuthoritativeDomains();
if (existingDomains != null)
Array.Sort(existingDomains);
foreach (OrganizationDomainName domain in domains)
{
if (existingDomains == null || Array.BinarySearch(existingDomains, domain.DomainName) < 0)
{
hubTransportRole.AddAuthoritativeDomain(domain.DomainName);
}
if (domain.DomainType != ExchangeAcceptedDomainType.Authoritative)
{
hubTransportRole.ChangeAcceptedDomainType(domain.DomainName, domain.DomainType);
}
}
authDomainCreated = true;
break;
}
foreach (OrganizationDomainName d in domains)
{
DomainInfo domain = ServerController.GetDomain(d.DomainId);
//Add the service records
if (domain != null)
{
if (domain.ZoneItemId != 0)
{
ServerController.AddServiceDNSRecords(org.PackageId, ResourceGroups.Exchange, domain, "");
ServerController.AddServiceDNSRecords(org.PackageId, ResourceGroups.BlackBerry, domain, "");
ServerController.AddServiceDNSRecords(org.PackageId, ResourceGroups.OCS, domain, "");
}
}
}
// 4) Add the address book policy (Exchange 2010 SP2
//
// ==========================================
Organization OrgTmp = mailboxRole.CreateOrganizationAddressBookPolicy(org.OrganizationId,
org.GlobalAddressList,
org.AddressList,
org.RoomsAddressList,
org.OfflineAddressBook);
org.AddressBookPolicy = OrgTmp.AddressBookPolicy;
StringDictionary settings = ServerController.GetServiceSettings(serviceId);
org.KeepDeletedItemsDays = Utils.ParseInt(settings["KeepDeletedItemsDays"], 14);
}
catch (Exception ex)
{
// rollback organization creation
if (organizationExtended)
mailboxRole.DeleteOrganization(org.OrganizationId, org.DistinguishedName,
org.GlobalAddressList, org.AddressList, org.RoomsAddressList, org.OfflineAddressBook, org.SecurityGroup, org.AddressBookPolicy, null);
// rollback domain
if (authDomainCreated)
foreach (int id in hubTransportServiceIds)
{
ExchangeServer hubTransportRole = null;
try
{
hubTransportRole = GetExchangeServer(id, org.ServiceId);
}
catch (Exception exe)
{
TaskManager.WriteError(exe);
continue;
}
foreach (OrganizationDomainName domain in domains)
{
hubTransportRole.DeleteAuthoritativeDomain(domain.DomainName);
}
break;
}
throw TaskManager.WriteError(ex);
}
return itemId;
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
private static void PopulateOrganizationData(Organization org, EnterpriseSolutionStatisticsReport report, string topReseller)
{
if (report.ExchangeReport != null)
{
try
{
PopulateExchangeReportItems(org, report, topReseller);
}
catch(Exception ex)
{
TaskManager.WriteError(ex);
}
}
if (report.CRMReport != null)
{
try
{
PopulateCRMReportItems(org, report, topReseller);
}
catch(Exception ex)
{
TaskManager.WriteError(ex);
}
}
if (report.SharePointReport != null)
{
try
{
PopulateSharePointItem(org, report, topReseller);
}
catch(Exception ex)
{
TaskManager.WriteError(ex);
}
}
if (report.OrganizationReport != null)
{
try
{
PopulateOrganizationStatisticsReport(org, report, topReseller);
}
catch(Exception ex)
{
TaskManager.WriteError(ex);
}
}
}
