private void SetUserGeneralSettingsInternal(string instanceId, bool enabledForFederation, bool enabledForPublicIMConectivity, bool archiveInternalCommunications, bool archiveFederatedCommunications, bool enabledForEnhancedPresence)
{
HostedSolutionLog.LogStart("SetUserGeneralSettingsInternal");
try
{
if (string.IsNullOrEmpty(instanceId))
{
throw new ArgumentException("instanceId");
}
using (ManagementObject userObject = GetUserByInstanceId(instanceId))
{
if (userObject == null)
{
throw new Exception(string.Format("OCS user {0} not found", instanceId));
}
userObject["EnabledForFederation"] = enabledForFederation;
userObject["PublicNetworkEnabled"] = enabledForPublicIMConectivity;
userObject["ArchiveInternalCommunications"] = archiveInternalCommunications;
userObject["ArchiveFederatedCommunications"] = archiveFederatedCommunications;
if (enabledForEnhancedPresence)
{
userObject["EnabledForEnhancedPresence"] = true;
}
userObject.Put();
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError("SetUserGeneralSettingsInternal", ex);
throw;
}
HostedSolutionLog.LogEnd("SetUserGeneralSettingsInternal");
}
private void SetUserPrimaryUriInternal(string instanceId, string userUpn)
{
HostedSolutionLog.LogStart("SetUserPrimaryUriInternal");
try
{
if (string.IsNullOrEmpty(instanceId))
{
throw new ArgumentException("instanceId");
}
if (string.IsNullOrEmpty(userUpn))
{
throw new ArgumentException("userUpn");
}
using (ManagementObject userObject = GetUserByInstanceId(instanceId))
{
if (userObject == null)
{
throw new Exception(string.Format("OCS user {0} not found", instanceId));
}
string primaryUri = "sip:" + userUpn;
userObject["PrimaryURI"] = primaryUri;
userObject.Put();
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError("SetUserPrimaryUriInternal", ex);
throw;
}
HostedSolutionLog.LogEnd("SetUserPrimaryUriInternal");
}
/// <summary> Rollbacks the transaction.</summary>
/// <param name="transaction"> The transaction.</param>
internal void RollbackTransaction(LyncTransaction transaction)
{
HostedSolutionLog.LogStart("RollbackTransaction");
Runspace runspace = null;
try
{
runspace = OpenRunspace();
for (int i = transaction.Actions.Count - 1; i > -1; i--)
{
try
{
RollbackAction(transaction.Actions[i], runspace);
}
catch (Exception ex)
{
HostedSolutionLog.LogError("Rollback error", ex);
}
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError("Rollback error", ex);
}
finally
{
CloseRunspace(runspace);
}
HostedSolutionLog.LogEnd("RollbackTransaction");
}
public long GetSiteCollectionSize(Uri root, string url)
{
WindowsImpersonationContext wic = null;
try
{
wic = WindowsIdentity.GetCurrent().Impersonate();
SPWebApplication rootWebApplication = SPWebApplication.Lookup(root);
SPSite site = rootWebApplication.Sites[url];
if (site != null)
{
site.RecalculateStorageUsed();
}
else
{
throw new ApplicationException(string.Format("SiteCollection {0} does not exist", url));
}
return(site.Usage.Storage);
}
catch (Exception ex)
{
HostedSolutionLog.LogError(ex);
throw;
}
finally
{
if (wic != null)
{
wic.Undo();
}
}
}
private void DeleteDomainInternal(string domainName)
{
HostedSolutionLog.LogStart("DeleteDomainInternal");
HostedSolutionLog.DebugInfo("Domain Name: {0}", domainName);
try
{
if (string.IsNullOrEmpty(domainName))
{
throw new ArgumentException("domainName");
}
using (ManagementObject domainObj = GetDomain(domainName))
{
if (domainObj == null)
{
HostedSolutionLog.LogWarning("OCS internal domain '{0}' not found", domainName);
}
else
{
domainObj.Delete();
}
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError("DeleteDomainInternal", ex);
throw;
}
HostedSolutionLog.LogEnd("DeleteDomainInternal");
}
/// <summary> Gets allowed domains.</summary>
/// <param name="organizationId"> The organization identifier.</param>
/// <returns> Allowed domains.</returns>
internal override LyncFederationDomain[] GetFederationDomainsInternal(string organizationId)
{
HostedSolutionLog.LogStart("GetFederationDomainsInternal");
HostedSolutionLog.DebugInfo("organizationId: {0}", organizationId);
LyncFederationDomain[] domains;
Runspace runspace = null;
try
{
runspace = OpenRunspace();
domains = GetFederationDomainsInternal(runspace);
}
catch (Exception ex)
{
HostedSolutionLog.LogError("GetFederationDomainsInternal", ex);
throw;
}
finally
{
CloseRunspace(runspace);
}
HostedSolutionLog.LogEnd("GetFederationDomainsInternal");
return(domains);
}
public SharePointSiteDiskSpace[] CalculateSiteCollectionDiskSpace(Uri root, string[] urls)
{
WindowsImpersonationContext wic = null;
try
{
wic = WindowsIdentity.GetCurrent().Impersonate();
SPWebApplication rootWebApplication = SPWebApplication.Lookup(root);
List <SharePointSiteDiskSpace> ret = new List <SharePointSiteDiskSpace>();
foreach (string url in urls)
{
SharePointSiteDiskSpace siteDiskSpace = new SharePointSiteDiskSpace();
rootWebApplication.Sites[url].RecalculateStorageUsed();
siteDiskSpace.Url = url;
siteDiskSpace.DiskSpace = (long)Math.Round(rootWebApplication.Sites[url].Usage.Storage / 1024.0 / 1024.0);
ret.Add(siteDiskSpace);
}
return(ret.ToArray());
}
catch (Exception ex)
{
HostedSolutionLog.LogError(ex);
throw;
}
finally
{
if (wic != null)
{
wic.Undo();
}
}
}
private void AddDomainInternal(string domainName)
{
HostedSolutionLog.LogStart("AddDomainInternal");
HostedSolutionLog.DebugInfo("Domain Name: {0}", domainName);
try
{
if (string.IsNullOrEmpty(domainName))
{
throw new ArgumentException("domainName");
}
if (GetDomain(domainName) != null)
{
HostedSolutionLog.LogWarning("OCS internal domain '{0}' already exists", domainName);
}
else
{
using (ManagementObject newDomain = Wmi.CreateInstance("MSFT_SIPFederationInternalDomainData"))
{
newDomain["SupportedInternalDomain"] = domainName;
newDomain.Put();
}
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError("AddDomainInternal", ex);
throw;
}
HostedSolutionLog.LogEnd("AddDomainInternal");
}
/// <summary> Removes domain from allowed list.</summary>
/// <param name="organizationId"> The organization identifier.</param>
/// <param name="domainName"> The domain name.</param>
/// <returns> The result.</returns>
internal override bool RemoveFederationDomainInternal(string organizationId, string domainName)
{
HostedSolutionLog.LogStart("RemoveFederationDomainInternal");
HostedSolutionLog.DebugInfo("organizationId: {0}", organizationId);
HostedSolutionLog.DebugInfo("domainName: {0}", domainName);
Runspace runspace = null;
try
{
runspace = OpenRunspace();
var command = new Command("Remove-CsAllowedDomain");
command.Parameters.Add("Identity", domainName);
ExecuteShellCommand(runspace, command, false);
}
catch (Exception ex)
{
HostedSolutionLog.LogError("RemoveFederationDomainInternal", ex);
throw;
}
finally
{
CloseRunspace(runspace);
}
HostedSolutionLog.LogEnd("RemoveFederationDomainInternal");
return(true);
}
private void DeleteUserInternal(string instanceId)
{
HostedSolutionLog.LogStart("DeleteUserInternal");
try
{
if (string.IsNullOrEmpty(instanceId))
{
throw new ArgumentException("instanceId");
}
using (ManagementObject userObject = GetUserByInstanceId(instanceId))
{
if (userObject == null)
{
HostedSolutionLog.LogWarning("OCS user {0} not found", instanceId);
}
else
{
userObject.Delete();
}
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError("DeleteUserInternal", ex);
throw;
}
HostedSolutionLog.LogEnd("DeleteUserInternal");
}
/// <summary> Deletes user.</summary>
/// <param name="userUpn"> The user UPN.</param>
/// <returns> The result.</returns>
internal override bool DeleteUserInternal(string userUpn)
{
HostedSolutionLog.LogStart("DeleteUserInternal");
HostedSolutionLog.DebugInfo("userUpn: {0}", userUpn);
Runspace runspace = null;
try
{
runspace = OpenRunspace();
DeleteUser(runspace, userUpn);
var command = new Command("Get-CsAdUser");
command.Parameters.Add("Identity", userUpn);
ExecuteShellCommand(runspace, command, false);
command = new Command("Update-CsAddressBook");
ExecuteShellCommand(runspace, command, false);
command = new Command("Update-CsUserDatabase");
ExecuteShellCommand(runspace, command, false);
}
catch (Exception ex)
{
HostedSolutionLog.LogError("DeleteUserInternal", ex);
throw;
}
finally
{
CloseRunspace(runspace);
}
HostedSolutionLog.LogEnd("DeleteUserInternal");
return(true);
}
/// <summary>Closes runspace.</summary>
/// <param name="runspace">The runspace.</param>
private void CloseRunspace(Runspace runspace)
{
try
{
if (runspace != null && runspace.RunspaceStateInfo.State == RunspaceState.Opened)
{
runspace.Close();
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError("Runspace error", ex);
}
}
public void UpdateQuotas(Uri root, string url, long maxStorage, long warningStorage)
{
WindowsImpersonationContext wic = null;
try
{
wic = WindowsIdentity.GetCurrent().Impersonate();
SPWebApplication rootWebApplication = SPWebApplication.Lookup(root);
SPQuota quota = new SPQuota();
if (maxStorage != -1)
{
quota.StorageMaximumLevel = maxStorage * 1024 * 1024;
}
else
{
quota.StorageMaximumLevel = 0;
}
if (warningStorage != -1 && maxStorage != -1)
{
quota.StorageWarningLevel = Math.Min(warningStorage, maxStorage) * 1024 * 1024;
}
else
{
quota.StorageWarningLevel = 0;
}
rootWebApplication.GrantAccessToProcessIdentity(WindowsIdentity.GetCurrent().Name);
rootWebApplication.Sites[url].Quota = quota;
}
catch (Exception ex)
{
HostedSolutionLog.LogError(ex);
throw;
}
finally
{
if (wic != null)
{
wic.Undo();
}
}
}
public override void DeleteServiceItems(ServiceProviderItem[] items)
{
foreach (ServiceProviderItem item in items)
{
try
{
if (item is Organization)
{
Organization org = item as Organization;
DeleteOrganizationInternal(org.OrganizationId);
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError(String.Format("Error deleting '{0}' {1}", item.Name, item.GetType().Name), ex);
}
}
}
public override void ChangeServiceItemsState(ServiceProviderItem[] items, bool enabled)
{
foreach (ServiceProviderItem item in items)
{
try
{
if (item is Organization)
{
Organization org = item as Organization;
ChangeOrganizationState(org, enabled);
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError(
String.Format("Error deleting '{0}' {1}", item.Name, item.GetType().Name), ex);
}
}
}
internal PasswordPolicyResult GetPasswordPolicyInternal()
{
HostedSolutionLog.LogStart("GetPasswordPolicyInternal");
PasswordPolicyResult res = new PasswordPolicyResult {
IsSuccess = true
};
string[] policyAttributes = new[] { "minPwdLength",
"pwdProperties",
"objectClass" };
try
{
DirectoryEntry domainRoot = new DirectoryEntry(ActiveDirectoryUtils.ConvertDomainName(RootDomain));
DirectorySearcher ds = new DirectorySearcher(
domainRoot,
"(objectClass=domainDNS)",
policyAttributes,
SearchScope.Base
);
SearchResult result = ds.FindOne();
PasswordPolicy ret = new PasswordPolicy
{
MinLength = ((int)result.Properties["minPwdLength"][0]),
IsComplexityEnable = ((int)result.Properties["pwdProperties"][0] == 1)
};
res.Value = ret;
}
catch (Exception ex)
{
HostedSolutionLog.LogError(ex);
res.IsSuccess = false;
res.ErrorCodes.Add(ErrorCodes.CANNOT_GET_PASSWORD_COMPLEXITY);
}
HostedSolutionLog.LogEnd("GetPasswordPolicyInternal");
return(res);
}
/// <summary> Gets users general settings.</summary>
/// <param name="organizationId"> The organization identifier.</param>
/// <param name="userUpn"> The user UPN.</param>
/// <returns> User settings.</returns>
internal override LyncUser GetLyncUserGeneralSettingsInternal(string organizationId, string userUpn)
{
HostedSolutionLog.LogStart("GetLyncUserGeneralSettingsInternal");
HostedSolutionLog.DebugInfo("organizationId: {0}", organizationId);
HostedSolutionLog.DebugInfo("userUpn: {0}", userUpn);
var lyncUser = new LyncUser();
Runspace runspace = null;
try
{
runspace = OpenRunspace();
var command = new Command("Get-CsUser");
command.Parameters.Add("Identity", userUpn);
Collection <PSObject> result = ExecuteShellCommand(runspace, command, false);
PSObject user = result[0];
lyncUser.DisplayName = (string)GetPSObjectProperty(user, "DisplayName");
lyncUser.SipAddress = (string)GetPSObjectProperty(user, "SipAddress");
lyncUser.LineUri = (string)GetPSObjectProperty(user, "LineURI");
lyncUser.SipAddress = lyncUser.SipAddress.ToLower().Replace("sip:", "");
lyncUser.LineUri = lyncUser.LineUri.ToLower().Replace("tel:+", "");
lyncUser.LineUri = lyncUser.LineUri.ToLower().Replace("tel:", "");
}
catch (Exception ex)
{
HostedSolutionLog.LogError("GetLyncUserGeneralSettingsInternal", ex);
throw;
}
finally
{
CloseRunspace(runspace);
}
HostedSolutionLog.LogEnd("GetLyncUserGeneralSettingsInternal");
return(lyncUser);
}
private OCSUser GetUserGeneralSettingsInternal(string instanceId)
{
HostedSolutionLog.LogStart("GetUserGeneralSettingsInternal");
try
{
if (string.IsNullOrEmpty(instanceId))
{
throw new ArgumentException("instanceId");
}
using (ManagementObject userObject = GetUserByInstanceId(instanceId))
{
if (userObject == null)
{
throw new Exception(string.Format("OCS user {0} not found", instanceId));
}
OCSUser user = new OCSUser();
user.InstanceId = instanceId;
user.PrimaryUri = (string)userObject["PrimaryURI"];
user.DisplayName = (string)userObject["DisplayName"];
user.EnabledForFederation = (bool)userObject["EnabledForFederation"];
user.EnabledForPublicIMConectivity = (bool)userObject["PublicNetworkEnabled"];
user.ArchiveInternalCommunications = (bool)userObject["ArchiveInternalCommunications"];
user.ArchiveFederatedCommunications = (bool)userObject["ArchiveFederatedCommunications"];
user.EnabledForEnhancedPresence = (bool)userObject["EnabledForEnhancedPresence"];
HostedSolutionLog.LogEnd("GetUserGeneralSettingsInternal");
return(user);
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError("GetUserGeneralSettingsInternal", ex);
throw;
}
}
/// <summary>Gets SharePoint site collection.</summary>
/// <param name="rootWebApplicationUri">The root web application uri.</param>
/// <param name="url">The required site url.</param>
/// <returns>The SharePoint sites.</returns>
private SPSite GetSPSiteCollection(Uri rootWebApplicationUri, string url)
{
Runspace runspace = null;
try
{
string siteCollectionUrl = String.Format("{0}:{1}", url, rootWebApplicationUri.Port);
runspace = OpenRunspace();
var cmd = new Command("Get-SPSite");
cmd.Parameters.Add("Identity", siteCollectionUrl);
Collection <PSObject> result = ExecuteShellCommand(runspace, cmd);
if (result != null && result.Count() == 1)
{
var spSite = result.First().BaseObject as SPSite;
if (spSite == null)
{
throw new ApplicationException(string.Format("SiteCollection {0} does not exist", url));
}
return(result.First().BaseObject as SPSite);
}
else
{
throw new ApplicationException(string.Format("SiteCollection {0} does not exist", url));
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError(ex);
throw;
}
finally
{
CloseRunspace(runspace);
}
}
/// <summary> Adds domain to allowed list.</summary>
/// <param name="organizationId"> The organization identifier.</param>
/// <param name="domainName"> The domain name.</param>
/// <param name="proxyFqdn"> The ProxyFQDN.</param>
/// <returns> The result.</returns>
internal override bool AddFederationDomainInternal(string organizationId, string domainName, string proxyFqdn)
{
domainName = domainName.ToLower();
Runspace runspace = null;
try
{
runspace = OpenRunspace();
var command = new Command("Get-CsAllowedDomain");
command.Parameters.Add("Identity", domainName);
Collection <PSObject> result = ExecuteShellCommand(runspace, command, false);
if (result != null && !result.Any())
{
command = new Command("New-CsAllowedDomain");
command.Parameters.Add("Identity", domainName);
ExecuteShellCommand(runspace, command, false);
command = new Command("Set-CsAllowedDomain");
command.Parameters.Add("Identity", domainName);
command.Parameters.Add("ProxyFQDN", PoolFQDN);
ExecuteShellCommand(runspace, command, false);
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError("AddFederationDomainInternal", ex);
throw;
}
finally
{
CloseRunspace(runspace);
}
HostedSolutionLog.LogEnd("AddFederationDomainInternal");
return(true);
}
/// <summary> Refreshes configuration.</summary>
internal override void ReloadConfigurationInternal()
{
HostedSolutionLog.LogStart("ReloadConfigurationInternal");
Runspace runspace = null;
try
{
runspace = OpenRunspace();
var command = new Command("Enable-CsComputer");
ExecuteShellCommand(runspace, command, false);
}
catch (Exception ex)
{
HostedSolutionLog.LogError("ReloadConfigurationInternal", ex);
throw;
}
finally
{
CloseRunspace(runspace);
}
HostedSolutionLog.LogEnd("ReloadConfigurationInternal");
}
/// <summary> Sets users general settings.</summary>
/// <param name="organizationId"> The organization identifier.</param>
/// <param name="userUpn"> The user UPN.</param>
/// <param name="lyncUser"> The lync user settings.</param>
/// <returns> The result.</returns>
internal override bool SetLyncUserGeneralSettingsInternal(string organizationId, string userUpn, LyncUser lyncUser)
{
HostedSolutionLog.LogStart("SetLyncUserGeneralSettingsInternal");
HostedSolutionLog.DebugInfo("organizationId: {0}", organizationId);
HostedSolutionLog.DebugInfo("userUpn: {0}", userUpn);
bool ret = true;
Runspace runspace = null;
LyncTransaction transaction = StartTransaction();
try
{
runspace = OpenRunspace();
Guid tenantId = GetObjectGuid(organizationId, runspace);
string[] tmp = userUpn.Split('@');
if (tmp.Length < 2)
{
return(false);
}
var command = new Command("Get-CsSipDomain");
Collection <PSObject> sipDomains = ExecuteShellCommand(runspace, command, false);
bool bSipDomainExists = sipDomains.Select(domain => (string)GetPSObjectProperty(domain, "Name")).Any(d => d.ToLower() == tmp[1].ToLower());
if (!bSipDomainExists)
{
command = new Command("New-CsSipDomain");
command.Parameters.Add("Identity", tmp[1].ToLower());
ExecuteShellCommand(runspace, command, false);
transaction.RegisterNewSipDomain(tmp[1].ToLower());
string path = AddADPrefix(GetOrganizationPath(organizationId));
DirectoryEntry ou = ActiveDirectoryUtils.GetADObject(path);
string[] sipDs = ActiveDirectoryUtils.GetADObjectPropertyMultiValue(ou, "Url");
var listSipDs = new List <string>();
listSipDs.AddRange(sipDs);
listSipDs.Add(tmp[1]);
ActiveDirectoryUtils.SetADObjectPropertyValue(ou, "Url", listSipDs.ToArray());
ou.CommitChanges();
CreateSimpleUrl(runspace, tenantId);
transaction.RegisterNewSimpleUrl(tmp[1].ToLower(), tenantId.ToString());
path = AddADPrefix(GetResultObjectDN(organizationId, runspace));
DirectoryEntry user = ActiveDirectoryUtils.GetADObject(path);
if (tmp.Length > 0)
{
string Url = SimpleUrlRoot + tmp[1];
ActiveDirectoryUtils.SetADObjectPropertyValue(user, "msRTCSIP-BaseSimpleUrl", Url.ToLower());
}
user.CommitChanges();
}
command = new Command("Set-CsUser");
command.Parameters.Add("Identity", userUpn);
if (!string.IsNullOrEmpty(lyncUser.SipAddress))
{
command.Parameters.Add("SipAddress", "SIP:" + lyncUser.SipAddress);
}
if (!string.IsNullOrEmpty(lyncUser.LineUri))
{
command.Parameters.Add("LineUri", "TEL:+" + lyncUser.LineUri);
}
else
{
command.Parameters.Add("LineUri", null);
}
ExecuteShellCommand(runspace, command, false);
if (!String.IsNullOrEmpty(lyncUser.PIN))
{
command = new Command("Set-CsClientPin");
command.Parameters.Add("Identity", userUpn);
command.Parameters.Add("Pin", lyncUser.PIN);
ExecuteShellCommand(runspace, command, false);
}
command = new Command("Update-CsAddressBook");
ExecuteShellCommand(runspace, command, false);
command = new Command("Update-CsUserDatabase");
ExecuteShellCommand(runspace, command, false);
}
catch (Exception ex)
{
ret = false;
HostedSolutionLog.LogError("SetLyncUserGeneralSettingsInternal", ex);
RollbackTransaction(transaction);
}
finally
{
CloseRunspace(runspace);
}
HostedSolutionLog.LogEnd("SetLyncUserGeneralSettingsInternal");
return(ret);
}
/// <summary>
/// Creates site collection within predefined root web application.
/// </summary>
/// <param name="rootWebApplicationUri">Root web application uri.</param>
/// <param name="siteCollection">Information about site coolection to be created.</param>
/// <exception cref="InvalidOperationException">Is thrown in case requested operation fails for any reason.</exception>
public void CreateSiteCollection(Uri rootWebApplicationUri, SharePointSiteCollection siteCollection)
{
WindowsImpersonationContext wic = null;
try
{
wic = WindowsIdentity.GetCurrent().Impersonate();
SPWebApplication rootWebApplication = SPWebApplication.Lookup(rootWebApplicationUri);
string siteCollectionUrl = String.Format("{0}:{1}", siteCollection.Url, rootWebApplicationUri.Port);
SPQuota spQuota;
SPSite spSite = rootWebApplication.Sites.Add(siteCollectionUrl,
siteCollection.Title, siteCollection.Description,
(uint)siteCollection.LocaleId, String.Empty,
siteCollection.OwnerLogin, siteCollection.OwnerName,
siteCollection.OwnerEmail,
null, null, null, true);
try
{
spQuota = new SPQuota();
if (siteCollection.MaxSiteStorage != -1)
{
spQuota.StorageMaximumLevel = siteCollection.MaxSiteStorage * 1024 * 1024;
}
if (siteCollection.WarningStorage != -1 && siteCollection.MaxSiteStorage != -1)
{
spQuota.StorageWarningLevel = Math.Min(siteCollection.WarningStorage, siteCollection.MaxSiteStorage) * 1024 * 1024;
}
}
catch (Exception)
{
rootWebApplication.Sites.Delete(siteCollectionUrl);
throw;
}
try
{
rootWebApplication.GrantAccessToProcessIdentity(WindowsIdentity.GetCurrent().Name);
spSite.Quota = spQuota;
}
catch (Exception)
{
rootWebApplication.Sites.Delete(siteCollectionUrl);
DeleteQuotaTemplate(siteCollection.Title);
throw;
}
rootWebApplication.Update(true);
}
catch (Exception ex)
{
HostedSolutionLog.LogError(ex);
throw;
}
finally
{
if (wic != null)
{
wic.Undo();
}
}
}
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));
}
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);
}
internal int CreateUserInternal(string organizationId, string loginName, string displayName, string upn, string password, bool enabled)
{
HostedSolutionLog.LogStart("CreateUserInternal");
HostedSolutionLog.DebugInfo("organizationId : {0}", organizationId);
HostedSolutionLog.DebugInfo("loginName : {0}", loginName);
HostedSolutionLog.DebugInfo("displayName : {0}", displayName);
if (string.IsNullOrEmpty(organizationId))
{
throw new ArgumentNullException("organizationId");
}
if (string.IsNullOrEmpty(loginName))
{
throw new ArgumentNullException("loginName");
}
if (string.IsNullOrEmpty(password))
{
throw new ArgumentNullException("password");
}
bool userCreated = false;
string userPath = null;
try
{
string path = GetOrganizationPath(organizationId);
userPath = GetUserPath(organizationId, loginName);
if (!ActiveDirectoryUtils.AdObjectExists(userPath))
{
userPath = ActiveDirectoryUtils.CreateUser(path, loginName, displayName, password, enabled);
DirectoryEntry entry = new DirectoryEntry(userPath);
ActiveDirectoryUtils.SetADObjectProperty(entry, ADAttributes.UserPrincipalName, upn);
entry.CommitChanges();
userCreated = true;
}
else
{
return(Errors.AD_OBJECT_ALREADY_EXISTS);
}
string groupPath = GetGroupPath(organizationId);
ActiveDirectoryUtils.AddUserToGroup(userPath, groupPath);
}
catch (Exception e)
{
HostedSolutionLog.LogError(e);
try
{
if (userCreated)
{
ActiveDirectoryUtils.DeleteADObject(userPath);
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError(ex);
}
}
HostedSolutionLog.LogEnd("CreateUserInternal");
return(Errors.OK);
}
/// <summary>Removes record from hosts file.</summary>
/// <param name="siteCollection">The site collection object.</param>
private void RemoveHostsRecord(SharePointEnterpriseSiteCollection siteCollection)
{
try
{
if (siteCollection.RootWebApplicationInteralIpAddress != string.Empty)
{
string dirPath = FileUtils.EvaluateSystemVariables(@"%windir%\system32\drivers\etc");
string path = dirPath + "\\hosts";
if (FileUtils.FileExists(path))
{
string content = FileUtils.GetFileTextContent(path);
content = content.Replace("\r\n", "\n").Replace("\n\r", "\n");
string[] contentArr = content.Split(new[] { '\n' });
string outPut = string.Empty;
foreach (string s in contentArr)
{
if (s != string.Empty)
{
string hostName = string.Empty;
if (s[0] != '#')
{
bool bSeperator = false;
foreach (char c in s)
{
if ((c != ' ') & (c != '\t'))
{
if (bSeperator)
{
hostName += c;
}
}
else
{
bSeperator = true;
}
}
if (hostName.ToLower() != siteCollection.RootWebApplicationFQDN.ToLower())
{
outPut += s + "\r\n";
}
}
else
{
outPut += s + "\r\n";
}
}
}
FileUtils.UpdateFileTextContent(path, outPut);
}
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError(ex);
}
}
/// <summary> Deletes organization.</summary>
/// <param name="organizationId"> The organization identifier.</param>
/// <param name="sipDomain"> The sip domain.</param>
/// <returns> The result.</returns>
internal override bool DeleteOrganizationInternal(string organizationId, string sipDomain)
{
HostedSolutionLog.LogStart("DeleteOrganizationInternal");
HostedSolutionLog.DebugInfo("organizationId: {0}", organizationId);
HostedSolutionLog.DebugInfo("sipDomain: {0}", sipDomain);
Runspace runspace = null;
try
{
runspace = OpenRunspace();
string path = AddADPrefix(GetOrganizationPath(organizationId));
DirectoryEntry ou = ActiveDirectoryUtils.GetADObject(path);
string[] sipDs = ActiveDirectoryUtils.GetADObjectPropertyMultiValue(ou, "Url");
foreach (string sipD in sipDs)
{
DeleteSipDomain(runspace, sipD);
}
try
{
DeleteConferencingPolicy(runspace, organizationId);
}
catch (Exception)
{
}
try
{
DeleteExternalAccessPolicy(runspace, organizationId);
}
catch (Exception)
{
}
try
{
DeleteMobilityPolicy(runspace, organizationId + " EnableOutSideVoice");
}
catch (Exception)
{
}
try
{
DeleteMobilityPolicy(runspace, organizationId + " DisableOutSideVoice");
}
catch (Exception)
{
}
var command = new Command("Invoke-CsManagementStoreReplication");
ExecuteShellCommand(runspace, command, false);
}
catch (Exception ex)
{
HostedSolutionLog.LogError("DeleteOrganizationInternal", ex);
throw;
}
finally
{
CloseRunspace(runspace);
}
HostedSolutionLog.LogEnd("DeleteOrganizationInternal");
return(true);
}
/// <summary> Creates the user.</summary>
/// <param name="organizationId"> The organization identifier.</param>
/// <param name="userUpn"> The user UPN.</param>
/// <param name="plan"> The Lync user plan.</param>
/// <returns> The result.</returns>
internal override bool CreateUserInternal(string organizationId, string userUpn, LyncUserPlan plan)
{
HostedSolutionLog.LogStart("CreateUserInternal");
HostedSolutionLog.DebugInfo("organizationId: {0}", organizationId);
HostedSolutionLog.DebugInfo("userUpn: {0}", userUpn);
LyncTransaction transaction = StartTransaction();
Runspace runspace = null;
try
{
runspace = OpenRunspace();
Guid guid = GetObjectGuid(organizationId, runspace);
string[] tmp = userUpn.Split('@');
if (tmp.Length < 2)
{
return(false);
}
var command = new Command("Get-CsSipDomain");
Collection <PSObject> sipDomains = ExecuteShellCommand(runspace, command, false);
bool bSipDomainExists = sipDomains.Select(domain => (string)GetPSObjectProperty(domain, "Name")).Any(d => d.ToLower() == tmp[1].ToLower());
if (!bSipDomainExists)
{
command = new Command("New-CsSipDomain");
command.Parameters.Add("Identity", tmp[1].ToLower());
ExecuteShellCommand(runspace, command, false);
transaction.RegisterNewSipDomain(tmp[1].ToLower());
AddAdDomainName(organizationId, tmp[1].ToLower());
CreateSimpleUrl(runspace, guid);
transaction.RegisterNewSimpleUrl(tmp[1].ToLower(), guid.ToString());
}
command = new Command("Enable-CsUser");
command.Parameters.Add("Identity", userUpn);
command.Parameters.Add("RegistrarPool", PoolFQDN);
command.Parameters.Add("SipAddressType", "UserPrincipalName");
ExecuteShellCommand(runspace, command, false);
transaction.RegisterNewCsUser(userUpn);
command = new Command("Get-CsAdUser");
command.Parameters.Add("Identity", userUpn);
ExecuteShellCommand(runspace, command, false);
command = new Command("Update-CsAddressBook");
ExecuteShellCommand(runspace, command, false);
command = new Command("Update-CsUserDatabase");
ExecuteShellCommand(runspace, command, false);
int trySleep = 2000; int tryMaxCount = 10; bool PlanSet = false;
for (int tryCount = 0; (tryCount < tryMaxCount) && (!PlanSet); tryCount++)
{
try
{
PlanSet = SetLyncUserPlanInternal(organizationId, userUpn, plan, runspace);
}
catch { }
if (!PlanSet)
{
System.Threading.Thread.Sleep(trySleep);
}
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError("CreateUserInternal", ex);
RollbackTransaction(transaction);
throw;
}
finally
{
CloseRunspace(runspace);
}
HostedSolutionLog.LogEnd("CreateUserInternal");
return(true);
}
/// <summary> Creates organization. </summary>
/// <param name="organizationId"> The organization identifier. </param>
/// <param name="sipDomain"> The sip domain. </param>
/// <param name="enableConferencingVideo"> True - if conferencing video should be enabled.</param>
/// <param name="maxConferenceSize"> The max conference size.</param>
/// <param name="enabledFederation"> True - if federations should be enabled.</param>
/// <param name="enabledEnterpriseVoice"> True - if enterprise voice should be enabled.</param>
/// <returns> The tenant identifier. </returns>
internal override string CreateOrganizationInternal(string organizationId, string sipDomain, bool enableConferencingVideo, int maxConferenceSize, bool enabledFederation, bool enabledEnterpriseVoice)
{
sipDomain = sipDomain.ToLower();
HostedSolutionLog.LogStart("CreateOrganizationInternal");
HostedSolutionLog.DebugInfo("organizationId: {0}", organizationId);
HostedSolutionLog.DebugInfo("sipDomain: {0}", sipDomain);
string tenantId;
LyncTransaction transaction = StartTransaction();
Runspace runspace = null;
try
{
runspace = OpenRunspace();
var command = new Command("New-CsSipDomain");
command.Parameters.Add("Identity", sipDomain);
ExecuteShellCommand(runspace, command, false);
transaction.RegisterNewSipDomain(sipDomain);
Guid id = Guid.NewGuid();
AddAdDomainName(organizationId, sipDomain);
CreateSimpleUrl(runspace, id);
transaction.RegisterNewSimpleUrl(sipDomain, id.ToString());
command = new Command("New-CsConferencingPolicy");
command.Parameters.Add("Identity", organizationId);
command.Parameters.Add("MaxMeetingSize", ((maxConferenceSize == -1) | (maxConferenceSize > 250)) ? 250 : maxConferenceSize);
command.Parameters.Add("AllowIPVideo", enableConferencingVideo);
ExecuteShellCommand(runspace, command, false);
transaction.RegisterNewConferencingPolicy(organizationId);
command = new Command("New-CsExternalAccessPolicy");
command.Parameters.Add("Identity", organizationId);
command.Parameters.Add("EnableFederationAccess", true);
command.Parameters.Add("EnableOutsideAccess", true);
command.Parameters.Add("EnablePublicCloudAccess", false);
command.Parameters.Add("EnablePublicCloudAudioVideoAccess", false);
ExecuteShellCommand(runspace, command, false);
transaction.RegisterNewCsExternalAccessPolicy(organizationId);
var allowList = new AllowList();
var domain = new DomainPattern(sipDomain);
allowList.AllowedDomain.Add(domain);
AddFederationDomainInternal("", domain.Domain, PoolFQDN);
command = new Command("New-CsMobilityPolicy");
command.Parameters.Add("Identity", organizationId + " EnableOutSideVoice");
command.Parameters.Add("EnableMobility", true);
command.Parameters.Add("EnableOutsideVoice", true);
ExecuteShellCommand(runspace, command, false);
transaction.RegisterNewCsMobilityPolicy(organizationId + " EnableOutSideVoice");
command = new Command("New-CsMobilityPolicy");
command.Parameters.Add("Identity", organizationId + " DisableOutSideVoice");
command.Parameters.Add("EnableMobility", true);
command.Parameters.Add("EnableOutsideVoice", false);
ExecuteShellCommand(runspace, command, false);
transaction.RegisterNewCsMobilityPolicy(organizationId + " DisableOutSideVoice");
command = new Command("Invoke-CsManagementStoreReplication");
ExecuteShellCommand(runspace, command, false);
tenantId = id.ToString();
}
catch (Exception ex)
{
HostedSolutionLog.LogError("CreateOrganizationInternal", ex);
RollbackTransaction(transaction);
throw;
}
finally
{
CloseRunspace(runspace);
}
HostedSolutionLog.LogEnd("CreateOrganizationInternal");
return(tenantId);
}
/// <summary> Sets users lync plan.</summary>
/// <param name="organizationId"> The organization identifier.</param>
/// <param name="userUpn"> The user UPN.</param>
/// <param name="plan"> The lync plan.</param>
/// <param name="runspace"> The runspace.</param>
/// <returns> The result.</returns>
internal override bool SetLyncUserPlanInternal(string organizationId, string userUpn, LyncUserPlan plan, Runspace runspace)
{
HostedSolutionLog.LogStart("SetLyncUserPlanInternal");
HostedSolutionLog.DebugInfo("organizationId: {0}", organizationId);
HostedSolutionLog.DebugInfo("userUpn: {0}", userUpn);
bool bCloseRunSpace = false;
bool ret = true;
try
{
if (runspace == null)
{
runspace = OpenRunspace();
bCloseRunSpace = true;
}
// EnterpriseVoice
var command = new Command("Set-CsUser");
command.Parameters.Add("Identity", userUpn);
command.Parameters.Add("EnterpriseVoiceEnabled", plan.EnterpriseVoice);
ExecuteShellCommand(runspace, command, false);
command = new Command("Grant-CsExternalAccessPolicy");
command.Parameters.Add("Identity", userUpn);
command.Parameters.Add("PolicyName", plan.Federation ? organizationId : null);
ExecuteShellCommand(runspace, command, false);
command = new Command("Grant-CsConferencingPolicy");
command.Parameters.Add("Identity", userUpn);
command.Parameters.Add("PolicyName", plan.Federation ? organizationId : null);
ExecuteShellCommand(runspace, command, false);
command = new Command("Grant-CsMobilityPolicy");
command.Parameters.Add("Identity", userUpn);
if (plan.Mobility)
{
command.Parameters.Add("PolicyName", plan.MobilityEnableOutsideVoice ? organizationId + " EnableOutSideVoice" : organizationId + " DisableOutSideVoice");
}
else
{
command.Parameters.Add("PolicyName", null);
}
ExecuteShellCommand(runspace, command, false);
// ArchivePolicy
command = new Command("Grant-CsArchivingPolicy");
command.Parameters.Add("Identity", userUpn);
command.Parameters.Add("PolicyName", string.IsNullOrEmpty(plan.ArchivePolicy) ? null : plan.ArchivePolicy);
ExecuteShellCommand(runspace, command, false);
// DialPlan
command = new Command("Grant-CsDialPlan");
command.Parameters.Add("Identity", userUpn);
command.Parameters.Add("PolicyName", string.IsNullOrEmpty(plan.TelephonyDialPlanPolicy) ? null : plan.TelephonyDialPlanPolicy);
ExecuteShellCommand(runspace, command, false);
// VoicePolicy
command = new Command("Grant-CsVoicePolicy");
command.Parameters.Add("Identity", userUpn);
command.Parameters.Add("PolicyName", string.IsNullOrEmpty(plan.TelephonyVoicePolicy) ? null : plan.TelephonyVoicePolicy);
ExecuteShellCommand(runspace, command, false);
command = new Command("Update-CsUserDatabase");
ExecuteShellCommand(runspace, command, false);
ret = false;
}
catch (Exception ex)
{
HostedSolutionLog.LogError("SetLyncUserPlanInternal", ex);
throw;
}
finally
{
if (bCloseRunSpace)
{
CloseRunspace(runspace);
}
}
HostedSolutionLog.LogEnd("SetLyncUserPlanInternal");
return(ret);
}
