/// <summary>Deletes site collection under given url.</summary>
/// <param name="rootWebApplicationUri">Root web application uri.</param>
/// <param name="siteCollection">The site collection to be deleted.</param>
/// <exception cref="InvalidOperationException">Is thrown in case requested operation fails for any reason.</exception>
public void DeleteSiteCollection(Uri rootWebApplicationUri, SharePointSiteCollection siteCollection)
{
HostedSolutionLog.LogStart("DeleteSiteCollection");
Runspace runspace = null;
try
{
string siteCollectionUrl = String.Format("{0}:{1}", siteCollection.Url, rootWebApplicationUri.Port);
HostedSolutionLog.DebugInfo("siteCollectionUrl: {0}", siteCollectionUrl);
runspace = OpenRunspace();
DeleteSiteCollection(runspace, siteCollectionUrl, false);
RemoveHostsRecord(siteCollection);
}
catch (Exception ex)
{
throw new InvalidOperationException("Failed to delete site collection.", ex);
}
finally
{
CloseRunspace(runspace);
HostedSolutionLog.LogEnd("DeleteSiteCollection");
}
}
public int AddSiteCollection(SharePointSiteCollection item) {
object[] results = this.Invoke("AddSiteCollection", new object[] {
item});
return ((int)(results[0]));
}
/// <remarks/>
public void AddSiteCollectionAsync(SharePointSiteCollection item) {
this.AddSiteCollectionAsync(item, null);
}
private void SaveItem()
{
if (!Page.IsValid)
{
return;
}
if (this.SiteCollectionId == 0)
{
if (this.userSelector.GetAccount() == null)
{
localMessageBox.ShowWarningMessage("HOSTEDSHAREPOINT_NO_USERS");
return;
}
// new item
try
{
SharePointSiteCollectionListPaged existentSiteCollections = ES.Services.HostedSharePointServers.GetSiteCollectionsPaged(PanelSecurity.PackageId, this.OrganizationId, "ItemName", String.Format("%{0}", this.domain.DomainName), String.Empty, 0, Int32.MaxValue);
foreach (SharePointSiteCollection existentSiteCollection in existentSiteCollections.SiteCollections)
{
Uri existentSiteCollectionUri = new Uri(existentSiteCollection.Name);
if (existentSiteCollection.Name == String.Format("{0}://{1}", existentSiteCollectionUri.Scheme, this.domain.DomainName))
{
localMessageBox.ShowWarningMessage("HOSTEDSHAREPOINT_DOMAIN_IN_USE");
return;
}
}
// get form data
item = new SharePointSiteCollection();
item.OrganizationId = this.OrganizationId;
item.Id = this.SiteCollectionId;
item.PackageId = PanelSecurity.PackageId;
item.Name = this.domain.DomainName;
item.LocaleId = Int32.Parse(this.ddlLocaleID.SelectedValue);
item.OwnerLogin = this.userSelector.GetAccount();
item.OwnerEmail = this.userSelector.GetPrimaryEmailAddress();
item.OwnerName = this.userSelector.GetDisplayName();
item.Title = txtTitle.Text;
item.Description = txtDescription.Text;
item.MaxSiteStorage = maxStorage.QuotaValue;
item.WarningStorage = warningStorage.QuotaValue;
int result = ES.Services.HostedSharePointServers.AddSiteCollection(item);
if (result < 0)
{
localMessageBox.ShowResultMessage(result);
return;
}
}
catch (Exception ex)
{
localMessageBox.ShowErrorMessage("HOSTEDSHAREPOINT_ADD_SITECOLLECTION", ex);
return;
}
}
else
{
ES.Services.HostedSharePointServers.UpdateQuota(PanelRequest.ItemID, SiteCollectionId, editMaxStorage.QuotaValue, editWarningStorage.QuotaValue);
}
// return
RedirectToSiteCollectionsList();
}
/// <summary>
/// Gets list of SharePoint site collections that belong to the package.
/// </summary>
/// <param name="packageId">Package that owns site collections.</param>
/// <param name="recursive">A value which shows whether nested spaces must be searched as well.</param>
/// <returns>List of found site collections.</returns>
public static List<SharePointSiteCollection> GetSiteCollections(int packageId, bool recursive)
{
if (IsDemoMode)
{
List<SharePointSiteCollection> demoResult = new List<SharePointSiteCollection>();
SharePointSiteCollection siteCollection1 = new SharePointSiteCollection();
siteCollection1.Id = 1;
siteCollection1.OrganizationId = 1;
siteCollection1.LocaleId = 1033;
siteCollection1.Name = "http://john.fabrikam.com";
siteCollection1.OwnerEmail = "*****@*****.**";
siteCollection1.OwnerLogin = "******";
siteCollection1.OwnerName = "John Smith";
siteCollection1.PhysicalAddress = "http://john.fabrikam.com";
siteCollection1.Title = "John Smith's Team Site";
siteCollection1.Url = "http://john.fabrikam.com";
demoResult.Add(siteCollection1);
SharePointSiteCollection siteCollection2 = new SharePointSiteCollection();
siteCollection2.Id = 2;
siteCollection1.OrganizationId = 1;
siteCollection2.LocaleId = 1033;
siteCollection2.Name = "http://mark.contoso.com";
siteCollection2.OwnerEmail = "*****@*****.**";
siteCollection2.OwnerLogin = "******";
siteCollection2.OwnerName = "Mark Jonsons";
siteCollection2.PhysicalAddress = "http://mark.contoso.com";
siteCollection2.Title = "Mark Jonsons' Blog";
siteCollection2.Url = "http://mark.contoso.com";
demoResult.Add(siteCollection2);
return demoResult;
}
List<ServiceProviderItem> items = PackageController.GetPackageItemsByType(packageId, typeof(SharePointSiteCollection), recursive);
return items.ConvertAll<SharePointSiteCollection>(delegate(ServiceProviderItem item) { return (SharePointSiteCollection)item; });
}
public void RestoreSiteCollection(SharePointSiteCollection siteCollection, string filename)
{
this.Invoke("RestoreSiteCollection", new object[] {
siteCollection,
filename});
}
/// <remarks/>
public void RestoreSiteCollectionAsync(SharePointSiteCollection siteCollection, string filename)
{
this.RestoreSiteCollectionAsync(siteCollection, filename, null);
}
/// <summary>
/// Gets list of SharePoint collections within root web application.
/// </summary>
/// <param name="rootWebApplicationUri">Root web application uri.</param>
/// <returns>List of SharePoint collections within root web application.</returns>
public SharePointSiteCollection[] GetSiteCollections(Uri rootWebApplicationUri)
{
try
{
WindowsImpersonationContext wic = WindowsIdentity.GetCurrent().Impersonate();
try
{
SPWebApplication rootWebApplication = SPWebApplication.Lookup(rootWebApplicationUri);
List<SharePointSiteCollection> siteCollections = new List<SharePointSiteCollection>();
foreach (SPSite site in rootWebApplication.Sites)
{
SharePointSiteCollection loadedSiteCollection = new SharePointSiteCollection();
FillSiteCollection(loadedSiteCollection, site);
siteCollections.Add(loadedSiteCollection);
}
return siteCollections.ToArray();
}
finally
{
wic.Undo();
}
}
catch (Exception ex)
{
throw new InvalidOperationException("Failed to create site collection.", ex);
}
}
/// <summary>
/// Gets SharePoint collection within root web application with given name.
/// </summary>
/// <param name="rootWebApplicationUri">Root web application uri.</param>
/// <param name="url">Url that uniquely identifies site collection to be loaded.</param>
/// <returns>SharePoint collection within root web application with given name.</returns>
public SharePointSiteCollection GetSiteCollection(Uri rootWebApplicationUri, string url)
{
try
{
WindowsImpersonationContext wic = WindowsIdentity.GetCurrent().Impersonate();
try
{
SPWebApplication rootWebApplication = SPWebApplication.Lookup(rootWebApplicationUri);
string siteCollectionUrl = String.Format("{0}:{1}", url, rootWebApplicationUri.Port);
SPSite site = rootWebApplication.Sites[siteCollectionUrl];
if (site != null)
{
SharePointSiteCollection loadedSiteCollection = new SharePointSiteCollection();
FillSiteCollection(loadedSiteCollection, site);
return loadedSiteCollection;
}
return null;
}
finally
{
wic.Undo();
}
}
catch (Exception ex)
{
throw new InvalidOperationException("Failed to create site collection.", ex);
}
}
/// <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, SharePointSiteCollection collection)
{
var quotaValue = organization.MaxSharePointStorage;
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 int AddSiteCollection(SharePointSiteCollection item)
{
return HostedSharePointServerController.AddSiteCollection(item);
}
/// <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();
}
}
/// <summary>Removes record from hosts file.</summary>
/// <param name="siteCollection">The site collection object.</param>
private void RemoveHostsRecord(SharePointSiteCollection 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>Restores site collection under given url from backup.</summary>
/// <param name="rootWebApplicationUri">Root web application uri.</param>
/// <param name="siteCollection">Site collection to be restored.</param>
/// <param name="filename">Backup file name to restore from.</param>
/// <exception cref="InvalidOperationException">Is thrown in case requested operation fails for any reason.</exception>
public void RestoreSiteCollection(Uri rootWebApplicationUri, SharePointSiteCollection siteCollection, string filename)
{
string url = siteCollection.Url;
try
{
string siteCollectionUrl = String.Format("{0}:{1}", url, rootWebApplicationUri.Port);
HostedSolutionLog.LogStart("RestoreSiteCollection");
HostedSolutionLog.DebugInfo("siteCollectionUrl: {0}", siteCollectionUrl);
HostedSolutionLog.DebugInfo("backupFilePath: {0}", filename);
Runspace runspace = null;
try
{
string tempPath = Path.GetTempPath();
string expandedFile = filename;
if (Path.GetExtension(filename).ToLower() == ".zip")
{
expandedFile = FileUtils.UnzipFiles(filename, tempPath)[0];
// Delete zip archive.
FileUtils.DeleteFile(filename);
}
runspace = OpenRunspace();
DeleteSiteCollection(runspace, siteCollectionUrl, false);
var command = new Command("Restore-SPSite");
command.Parameters.Add("Identity", siteCollectionUrl);
command.Parameters.Add("Path", filename);
ExecuteShellCommand(runspace, command);
command = new Command("Set-SPSite");
command.Parameters.Add("Identity", siteCollectionUrl);
command.Parameters.Add("OwnerAlias", siteCollection.OwnerLogin);
ExecuteShellCommand(runspace, command);
command = new Command("Set-SPUser");
command.Parameters.Add("Identity", siteCollection.OwnerLogin);
command.Parameters.Add("Email", siteCollection.OwnerEmail);
command.Parameters.Add("DisplayName", siteCollection.Name);
ExecuteShellCommand(runspace, command);
FileUtils.DeleteFile(expandedFile);
}
finally
{
CloseRunspace(runspace);
HostedSolutionLog.LogEnd("RestoreSiteCollection");
}
}
catch (Exception ex)
{
throw new InvalidOperationException("Failed to restore site collection.", ex);
}
}
/// <remarks/>
public System.IAsyncResult BeginDeleteSiteCollection(SharePointSiteCollection siteCollection, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("DeleteSiteCollection", new object[] {
siteCollection}, callback, asyncState);
}
/// <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;
HostedSolutionLog.LogStart("CreateSiteCollection");
try
{
wic = WindowsIdentity.GetCurrent().Impersonate();
SPWebApplication rootWebApplication = SPWebApplication.Lookup(rootWebApplicationUri);
string siteCollectionUrl = String.Format("{0}:{1}", siteCollection.Url, rootWebApplicationUri.Port);
HostedSolutionLog.DebugInfo("rootWebApplicationUri: {0}", rootWebApplicationUri);
HostedSolutionLog.DebugInfo("siteCollectionUrl: {0}", siteCollectionUrl);
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);
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 char[] { '\n' });
bool bRecordExist = false;
foreach (string s in contentArr)
{
if (s != string.Empty)
{
string IPAddr = 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
IPAddr += c;
}
else
bSeperator = true;
}
if (hostName.ToLower() == siteCollection.RootWebApplicationFQDN.ToLower())
{
bRecordExist = true;
break;
}
}
}
}
if (!bRecordExist)
{
string outPut = string.Empty;
foreach (string o in contentArr)
{
if (o != string.Empty)
outPut += o + "\r\n";
}
outPut += siteCollection.RootWebApplicationInteralIpAddress + '\t' + siteCollection.RootWebApplicationFQDN + "\r\n";
FileUtils.UpdateFileTextContent(path, outPut);
}
}
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError(ex);
}
}
catch (Exception ex)
{
HostedSolutionLog.LogError(ex);
throw;
}
finally
{
if (wic != null)
wic.Undo();
HostedSolutionLog.LogEnd("CreateSiteCollection");
}
}
/// <remarks/>
public void DeleteSiteCollectionAsync(SharePointSiteCollection siteCollection)
{
this.DeleteSiteCollectionAsync(siteCollection, null);
}
/// <summary>
/// Deletes site collection under given url.
/// </summary>
/// <param name="rootWebApplicationUri">Root web application uri.</param>
/// <param name="url">Url that uniquely identifies site collection to be deleted.</param>
/// <exception cref="InvalidOperationException">Is thrown in case requested operation fails for any reason.</exception>
public void DeleteSiteCollection(Uri rootWebApplicationUri, SharePointSiteCollection siteCollection)
{
try
{
WindowsIdentity identity = WindowsIdentity.GetCurrent();
WindowsImpersonationContext wic = identity.Impersonate();
try
{
SPWebApplication rootWebApplication = SPWebApplication.Lookup(rootWebApplicationUri);
string siteCollectionUrl = String.Format("{0}:{1}", siteCollection.Url, rootWebApplicationUri.Port);
//string args = String.Format("-o deletesite -url {0}", siteCollectionUrl);
//string stsadm = @"c:\Program Files\Common Files\Microsoft Shared\web server extensions\12\BIN\STSADM.EXE";
//// launch system process
//ProcessStartInfo startInfo = new ProcessStartInfo(stsadm, args);
//startInfo.WindowStyle = ProcessWindowStyle.Hidden;
//startInfo.RedirectStandardOutput = true;
//startInfo.UseShellExecute = false;
//Process proc = Process.Start(startInfo);
//// analyze results
//StreamReader reader = proc.StandardOutput;
//string output = reader.ReadToEnd();
//int exitCode = proc.ExitCode;
//reader.Close();
rootWebApplication.Sites.Delete(siteCollectionUrl, true);
rootWebApplication.Update(true);
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 char[] { '\n' });
string outPut = string.Empty;
foreach (string s in contentArr)
{
if (s != string.Empty)
{
string IPAddr = 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
IPAddr += 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);
}
}
finally
{
wic.Undo();
}
}
catch (Exception ex)
{
throw new InvalidOperationException("Failed to delete site collection.", ex);
}
}
/// <remarks/>
public System.IAsyncResult BeginRestoreSiteCollection(SharePointSiteCollection siteCollection, string filename, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("RestoreSiteCollection", new object[] {
siteCollection,
filename}, callback, asyncState);
}
/// <summary>
/// Restores site collection under given url from backup.
/// </summary>
/// <param name="rootWebApplicationUri">Root web application uri.</param>
/// <param name="siteCollection">Site collection to be restored.</param>
/// <param name="filename">Backup file name to restore from.</param>
/// <exception cref="InvalidOperationException">Is thrown in case requested operation fails for any reason.</exception>
public void RestoreSiteCollection(Uri rootWebApplicationUri, SharePointSiteCollection siteCollection, string filename)
{
string url = siteCollection.Url;
try
{
WindowsImpersonationContext wic = WindowsIdentity.GetCurrent().Impersonate();
try
{
SPWebApplication rootWebApplication = SPWebApplication.Lookup(rootWebApplicationUri);
string siteCollectionUrl = String.Format("{0}:{1}", url, rootWebApplicationUri.Port);
string tempPath = Path.GetTempPath();
// Unzip uploaded files if required.
string expandedFile = filename;
if (Path.GetExtension(filename).ToLower() == ".zip")
{
// Unpack file.
expandedFile = FileUtils.UnzipFiles(filename, tempPath)[0];
// Delete zip archive.
FileUtils.DeleteFile(filename);
}
// Delete existent site and restore new one.
rootWebApplication.Sites.Delete(siteCollectionUrl, false);
rootWebApplication.Sites.Restore(siteCollectionUrl, expandedFile, true, true);
SPSite restoredSite = rootWebApplication.Sites[siteCollectionUrl];
SPWeb web = restoredSite.OpenWeb();
SPUser owner = null;
try
{
owner = web.SiteUsers[siteCollection.OwnerLogin];
}
catch
{
// Ignore this error.
}
if (owner == null)
{
web.SiteUsers.Add(siteCollection.OwnerLogin, siteCollection.OwnerEmail, siteCollection.OwnerName, String.Empty);
owner = web.SiteUsers[siteCollection.OwnerLogin];
}
restoredSite.Owner = owner;
web.Close();
rootWebApplication.Update();
// Delete expanded file.
FileUtils.DeleteFile(expandedFile);
}
finally
{
wic.Undo();
}
}
catch (Exception ex)
{
throw new InvalidOperationException("Failed to restore site collection.", ex);
}
}
/// <remarks/>
public void RestoreSiteCollectionAsync(SharePointSiteCollection siteCollection, string filename, object userState)
{
if ((this.RestoreSiteCollectionOperationCompleted == null))
{
this.RestoreSiteCollectionOperationCompleted = new System.Threading.SendOrPostCallback(this.OnRestoreSiteCollectionOperationCompleted);
}
this.InvokeAsync("RestoreSiteCollection", new object[] {
siteCollection,
filename}, this.RestoreSiteCollectionOperationCompleted, userState);
}
/// <summary>
/// Fills custom site collection with information from administration object.
/// </summary>
/// <param name="customSiteCollection">Custom site collection to fill.</param>
/// <param name="site">Administration object.</param>
private static void FillSiteCollection(SharePointSiteCollection customSiteCollection, SPSite site)
{
Uri siteUri = new Uri(site.Url);
string url = (siteUri.Port > 0) ? site.Url.Replace(String.Format(":{0}", siteUri.Port), String.Empty) : site.Url;
customSiteCollection.Url = url;
customSiteCollection.OwnerLogin = site.Owner.LoginName;
customSiteCollection.OwnerName = site.Owner.Name;
customSiteCollection.OwnerEmail = site.Owner.Email;
customSiteCollection.LocaleId = site.RootWeb.Locale.LCID;
customSiteCollection.Title = site.RootWeb.Title;
customSiteCollection.Description = site.RootWeb.Description;
customSiteCollection.Bandwidth = site.Usage.Bandwidth;
customSiteCollection.Diskspace = site.Usage.Storage;
customSiteCollection.MaxSiteStorage = site.Quota.StorageMaximumLevel;
customSiteCollection.WarningStorage = site.Quota.StorageWarningLevel;
}
private void BindItem()
{
try
{
if (!IsPostBack)
{
if (!this.IsDnsServiceAvailable())
{
localMessageBox.ShowWarningMessage("HOSTEDSHAREPOINT_NO_DNS");
}
// load item if required
if (this.SiteCollectionId > 0)
{
// existing item
item = ES.Services.HostedSharePointServers.GetSiteCollection(this.SiteCollectionId);
if (item != null)
{
// save package info
ViewState["PackageId"] = item.PackageId;
}
else
RedirectToBrowsePage();
}
else
{
// new item
ViewState["PackageId"] = PanelSecurity.PackageId;
}
//this.gvUsers.DataBind();
List<CultureInfo> cultures = new List<CultureInfo>();
foreach (int localeId in ES.Services.HostedSharePointServers.GetSupportedLanguages(PanelSecurity.PackageId))
{
cultures.Add(new CultureInfo(localeId, false));
}
this.ddlLocaleID.DataSource = cultures;
this.ddlLocaleID.DataBind();
}
if (!IsPostBack)
{
// bind item to controls
if (item != null)
{
// bind item to controls
lnkUrl.Text = item.PhysicalAddress;
lnkUrl.NavigateUrl = item.PhysicalAddress;
litSiteCollectionOwner.Text = String.Format("{0} ({1})", item.OwnerName, item.OwnerEmail);
litLocaleID.Text = new CultureInfo(item.LocaleId, false).DisplayName;
litTitle.Text = item.Title;
litDescription.Text = item.Description;
editWarningStorage.QuotaValue = (int)item.WarningStorage;
editMaxStorage.QuotaValue = (int)item.MaxSiteStorage;
}
Organization org = ES.Services.Organizations.GetOrganization(OrganizationId);
if (org != null)
{
maxStorage.ParentQuotaValue = org.MaxSharePointStorage;
maxStorage.QuotaValue = org.MaxSharePointStorage;
editMaxStorage.ParentQuotaValue = org.MaxSharePointStorage;
warningStorage.ParentQuotaValue = org.WarningSharePointStorage;
warningStorage.QuotaValue = org.WarningSharePointStorage;
editWarningStorage.ParentQuotaValue = org.WarningSharePointStorage;
}
}
OrganizationDomainName[] domains = ES.Services.Organizations.GetOrganizationDomains(PanelRequest.ItemID);
if (domains.Length == 0)
{
localMessageBox.ShowWarningMessage("HOSTEDSHAREPOINT_NO_DOMAINS");
DisableFormControls(this, btnCancel);
return;
}
//if (this.gvUsers.Rows.Count == 0)
//{
// localMessageBox.ShowWarningMessage("HOSTEDSHAREPOINT_NO_USERS");
// DisableFormControls(this, btnCancel);
// return;
//}
}
catch
{
localMessageBox.ShowWarningMessage("INIT_SERVICE_ITEM_FORM");
DisableFormControls(this, btnCancel);
return;
}
}
/// <summary>
/// Adds SharePoint site collection.
/// </summary>
/// <param name="item">Site collection description.</param>
/// <returns>Created site collection id within metabase.</returns>
public static int AddSiteCollection(SharePointSiteCollection item)
{
string domainName = item.Name;
// Check account.
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return accountCheck;
}
// Check package.
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return packageCheck;
}
// Check quota.
OrganizationStatistics orgStats = OrganizationController.GetOrganizationStatistics(item.OrganizationId);
//QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.HOSTED_SHAREPOINT_SITES);
if (orgStats.AllocatedSharePointSiteCollections > -1
&& orgStats.CreatedSharePointSiteCollections >= orgStats.AllocatedSharePointSiteCollections)
{
return BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_QUOTA_LIMIT;
}
// Check if stats resource is available
int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.HostedSharePoint);
if (serviceId == 0)
{
return BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_UNAVAILABLE;
}
StringDictionary hostedSharePointSettings = ServerController.GetServiceSettings(serviceId);
Uri rootWebApplicationUri = new Uri(hostedSharePointSettings["RootWebApplicationUri"]);
item.Name = String.Format("{0}://{1}", rootWebApplicationUri.Scheme, item.Name);
if (rootWebApplicationUri.Port > 0 && rootWebApplicationUri.Port != 80 && rootWebApplicationUri.Port != 443)
{
item.PhysicalAddress = String.Format("{0}:{1}", item.Name, rootWebApplicationUri.Port);
}
else
{
item.PhysicalAddress = item.Name;
}
Organization org = OrganizationController.GetOrganization(item.OrganizationId);
item.MaxSiteStorage = RecalculateMaxSize(org.MaxSharePointStorage, (int)item.MaxSiteStorage);
item.WarningStorage = item.MaxSiteStorage == -1 ? -1 : Math.Min((int)item.WarningStorage, item.MaxSiteStorage) ;
// Check package item with given name already exists.
if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(SharePointSiteCollection)) != null)
{
return BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_EXISTS;
}
// Log operation.
TaskManager.StartTask("HOSTEDSHAREPOINT", "ADD_SITE_COLLECTION", item.Name);
try
{
// Create site collection on server.
HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(serviceId);
hostedSharePointServer.CreateSiteCollection(item);
// Make record in metabase.
item.ServiceId = serviceId;
int itemId = PackageController.AddPackageItem(item);
int dnsServiceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Dns);
if (dnsServiceId > 0)
{
DomainInfo domain = ServerController.GetDomain(domainName);
if (domain != null)
{
string website = domain.WebSiteName;
if (!String.IsNullOrEmpty(domain.WebSiteName))
{
DnsRecord[] records = ServerController.GetDnsZoneRecords(domain.DomainId);
foreach (DnsRecord record in records)
{
if (record.RecordType.Equals(DnsRecordType.A) && String.IsNullOrEmpty(record.RecordName))
{
ServerController.DeleteDnsZoneRecord(domain.DomainId, String.Empty, DnsRecordType.A, record.RecordData);
break;
}
}
}
ServerController.AddDnsZoneRecord(domain.DomainId, String.Empty, DnsRecordType.A, hostedSharePointSettings["RootWebApplicationIpAddress"], 0);
}
}
TaskManager.ItemId = itemId;
return itemId;
}
catch(Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
/// <summary>
/// Adds SharePoint site collection.
/// </summary>
/// <param name="item">Site collection description.</param>
/// <returns>Created site collection id within metabase.</returns>
public static int AddSiteCollection(SharePointSiteCollection item)
{
// Check account.
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return accountCheck;
}
// Check package.
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return packageCheck;
}
// Check quota.
OrganizationStatistics orgStats = OrganizationController.GetOrganizationStatistics(item.OrganizationId);
//QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.HOSTED_SHAREPOINT_SITES);
if (orgStats.AllocatedSharePointSiteCollections > -1
&& orgStats.CreatedSharePointSiteCollections >= orgStats.AllocatedSharePointSiteCollections)
{
return BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_QUOTA_LIMIT;
}
// Check if stats resource is available
int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.SharepointFoundationServer);
if (serviceId == 0)
{
return BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_UNAVAILABLE;
}
StringDictionary hostedSharePointSettings = ServerController.GetServiceSettings(serviceId);
QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.HOSTED_SHAREPOINT_USESHAREDSSL);
Uri rootWebApplicationUri = new Uri(hostedSharePointSettings["RootWebApplicationUri"]);
Organization org = OrganizationController.GetOrganization(item.OrganizationId);
string siteName = item.Name;
if (quota.QuotaAllocatedValue == 1)
{
string sslRoot = hostedSharePointSettings["SharedSSLRoot"];
string defaultDomain = org.DefaultDomain;
string hostNameBase = string.Empty;
string[] tmp = defaultDomain.Split('.');
if (tmp.Length == 2)
{
hostNameBase = tmp[0];
}
else
{
if (tmp.Length > 2)
{
hostNameBase = tmp[0] + tmp[1];
}
}
int counter = 0;
item.Name = String.Format("{0}://{1}", rootWebApplicationUri.Scheme, hostNameBase + "-" + counter.ToString() + "." + sslRoot);
siteName = String.Format("{0}", hostNameBase + "-" + counter.ToString() + "." + sslRoot);
while ( DataProvider. CheckServiceItemExists( serviceId, item. Name, "WebsitePanel.Providers.SharePoint.SharePointSiteCollection, WebsitePanel.Providers.Base"))
{
counter++;
item.Name = String.Format("{0}://{1}", rootWebApplicationUri.Scheme, hostNameBase + "-" + counter.ToString() + "." + sslRoot);
siteName = String.Format("{0}", hostNameBase + "-" + counter.ToString() + "." + sslRoot);
}
}
else
item.Name = String.Format("{0}://{1}", rootWebApplicationUri.Scheme, item.Name);
if (rootWebApplicationUri.Port > 0 && rootWebApplicationUri.Port != 80 && rootWebApplicationUri.Port != 443)
{
item.PhysicalAddress = String.Format("{0}:{1}", item.Name, rootWebApplicationUri.Port);
}
else
{
item.PhysicalAddress = item.Name;
}
if (Utils.ParseBool(hostedSharePointSettings["LocalHostFile"], false))
{
item.RootWebApplicationInteralIpAddress = hostedSharePointSettings["RootWebApplicationInteralIpAddress"];
item.RootWebApplicationFQDN = item.Name.Replace(rootWebApplicationUri.Scheme + "://", "");
}
item.MaxSiteStorage = RecalculateMaxSize(org.MaxSharePointStorage, (int)item.MaxSiteStorage);
item.WarningStorage = item.MaxSiteStorage == -1 ? -1 : Math.Min((int)item.WarningStorage, item.MaxSiteStorage);
// Check package item with given name already exists.
if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(SharePointSiteCollection)) != null)
{
return BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_EXISTS;
}
// Log operation.
TaskManager.StartTask("HOSTEDSHAREPOINT", "ADD_SITE_COLLECTION", item.Name);
try
{
// Create site collection on server.
HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(serviceId);
hostedSharePointServer.CreateSiteCollection(item);
// Make record in metabase.
item.ServiceId = serviceId;
int itemId = PackageController.AddPackageItem(item);
hostedSharePointServer.SetPeoplePickerOu(item.Name, org.DistinguishedName);
int dnsServiceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Dns);
if (dnsServiceId > 0)
{
string[] tmpStr = siteName.Split('.');
string hostName = tmpStr[0];
string domainName = siteName.Substring(hostName.Length + 1, siteName.Length - (hostName.Length + 1));
List<GlobalDnsRecord> dnsRecords = ServerController.GetDnsRecordsByService(serviceId);
List<DnsRecord> resourceRecords = DnsServerController.BuildDnsResourceRecords(dnsRecords, hostName, domainName, "");
DNSServer dns = new DNSServer();
ServiceProviderProxy.Init(dns, dnsServiceId);
// add new resource records
dns.AddZoneRecords(domainName, resourceRecords.ToArray());
}
TaskManager.ItemId = itemId;
return itemId;
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
/// <remarks/>
public void CreateSiteCollectionAsync(SharePointSiteCollection siteCollection)
{
this.CreateSiteCollectionAsync(siteCollection, null);
}
/// <remarks/>
public System.IAsyncResult BeginAddSiteCollection(SharePointSiteCollection item, System.AsyncCallback callback, object asyncState) {
return this.BeginInvoke("AddSiteCollection", new object[] {
item}, callback, asyncState);
}
public void DeleteSiteCollection(SharePointSiteCollection siteCollection)
{
this.Invoke("DeleteSiteCollection", new object[] {
siteCollection});
}
/// <remarks/>
public void AddSiteCollectionAsync(SharePointSiteCollection item, object userState) {
if ((this.AddSiteCollectionOperationCompleted == null)) {
this.AddSiteCollectionOperationCompleted = new System.Threading.SendOrPostCallback(this.OnAddSiteCollectionOperationCompleted);
}
this.InvokeAsync("AddSiteCollection", new object[] {
item}, this.AddSiteCollectionOperationCompleted, userState);
}
/// <summary> Creates site collection within predefined root web application.</summary>
/// <param name="runspace"> The runspace.</param>
/// <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>
private void CreateCollection(Runspace runspace, Uri rootWebApplicationUri, SharePointSiteCollection siteCollection)
{
string siteCollectionUrl = String.Format("{0}:{1}", siteCollection.Url, rootWebApplicationUri.Port);
HostedSolutionLog.DebugInfo("siteCollectionUrl: {0}", siteCollectionUrl);
try
{
SPWebApplication rootWebApplication = SPWebApplication.Lookup(rootWebApplicationUri);
rootWebApplication.Sites.Add(siteCollectionUrl, siteCollection.Title, siteCollection.Description, (uint) siteCollection.LocaleId, String.Empty, siteCollection.OwnerLogin, siteCollection.OwnerName, siteCollection.OwnerEmail, null, null, null, true);
rootWebApplication.Update();
}
catch (Exception)
{
DeleteSiteCollection(runspace, siteCollectionUrl, true);
throw;
}
try
{
GrantAccess(runspace, rootWebApplicationUri);
var command = new Command("Set-SPSite");
command.Parameters.Add("Identity", siteCollectionUrl);
if (siteCollection.MaxSiteStorage != -1)
{
command.Parameters.Add("MaxSize", siteCollection.MaxSiteStorage*1024*1024);
}
if (siteCollection.WarningStorage != -1 && siteCollection.MaxSiteStorage != -1)
{
command.Parameters.Add("WarningSize", Math.Min(siteCollection.WarningStorage, siteCollection.MaxSiteStorage)*1024*1024);
}
ExecuteShellCommand(runspace, command);
}
catch (Exception)
{
DeleteQuotaTemplate(siteCollection.Title);
DeleteSiteCollection(runspace, siteCollectionUrl, true);
throw;
}
AddHostsRecord(siteCollection);
}
