/// <remarks/>
public System.IAsyncResult BeginRestoreSiteCollection(SharePointSiteCollection siteCollection, string filename, System.AsyncCallback callback, object asyncState)
{
return(this.BeginInvoke("RestoreSiteCollection", new object[] {
siteCollection,
filename
}, callback, asyncState));
}
public void RestoreSiteCollection(SharePointSiteCollection siteCollection, string filename)
{
this.Invoke("RestoreSiteCollection", new object[] {
siteCollection,
filename
});
}
/// <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;
}
/// <summary>
/// Restore backed up previously service provider item.
/// </summary>
/// <param name="tempFolder">Temporary directory path.</param>
/// <param name="itemNode">Serialized service provider item.</param>
/// <param name="itemId">Service provider item id.</param>
/// <param name="itemType">Service provider item type.</param>
/// <param name="itemName">Service provider item name.</param>
/// <param name="packageId">Service provider item package.</param>
/// <param name="serviceId">Service provider item service id.</param>
/// <param name="group">Service provider item resource group.</param>
/// <returns>Resulting code.</returns>
public int RestoreItem(string tempFolder, XmlNode itemNode, int itemId, Type itemType, string itemName, int packageId, int serviceId, ResourceGroupInfo group)
{
if (itemType == typeof(SharePointSiteCollection))
{
HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(serviceId);
// Deserialize item.
XmlSerializer serializer = new XmlSerializer(typeof(SharePointSiteCollection));
SharePointSiteCollection siteCollection = (SharePointSiteCollection)serializer.Deserialize(new XmlNodeReader(itemNode.SelectSingleNode("SharePointSiteCollection")));
siteCollection.PackageId = packageId;
siteCollection.ServiceId = serviceId;
// Create site collection if needed.
if (hostedSharePointServer.GetSiteCollection(siteCollection.Url) == null)
{
hostedSharePointServer.CreateSiteCollection(siteCollection);
}
// Add metabase record if needed.
SharePointSiteCollection metaSiteCollection = (SharePointSiteCollection)PackageController.GetPackageItemByName(packageId, itemName, typeof(SharePointSiteCollection));
if (metaSiteCollection == null)
{
PackageController.AddPackageItem(siteCollection);
}
}
return(0);
}
/// <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>
/// Calculates diskspace used by supplied service items.
/// </summary>
/// <param name="items">Service items to get diskspace usage for.</param>
/// <returns>Calculated disk space usage statistics.</returns>
public override ServiceProviderItemDiskSpace[] GetServiceItemsDiskSpace(ServiceProviderItem[] items)
{
List <ServiceProviderItemDiskSpace> itemsDiskspace = new List <ServiceProviderItemDiskSpace>();
// update items with diskspace
foreach (ServiceProviderItem item in items)
{
if (item is SharePointSiteCollection)
{
try
{
Log.WriteStart(String.Format("Calculating '{0}' site logs size", item.Name));
SharePointSiteCollection site = GetSiteCollection(item.Name);
ServiceProviderItemDiskSpace diskspace = new ServiceProviderItemDiskSpace();
diskspace.ItemId = item.Id;
diskspace.DiskSpace = site.Diskspace;
itemsDiskspace.Add(diskspace);
Log.WriteEnd(String.Format("Calculating '{0}' site logs size", item.Name));
}
catch (Exception ex)
{
Log.WriteError(ex);
}
}
}
return(itemsDiskspace.ToArray());
}
/// <summary>
/// Restores site collection under given url from backup.
/// </summary>
/// <param name="siteCollection">Site collection to be restored.</param>
/// <param name="filename">Backup file name to restore from.</param>
public void RestoreSiteCollection(SharePointSiteCollection siteCollection, string filename)
{
ExecuteSharePointAction <object>(delegate(HostedSharePointServerImpl impl)
{
impl.RestoreSiteCollection(RootWebApplicationUri, siteCollection, filename);
return(null);
});
}
/// <summary>
/// Creates site collection within predefined root web application.
/// </summary>
/// <param name="siteCollection">Information about site coolection to be created.</param>
public void CreateSiteCollection(SharePointSiteCollection siteCollection)
{
ExecuteSharePointAction <object>(delegate(HostedSharePointServerImpl impl)
{
impl.CreateSiteCollection(RootWebApplicationUri, siteCollection);
return(null);
});
}
public void DeleteSiteCollection(SharePointSiteCollection siteCollection)
{
ExecuteAction <object>(delegate
{
HostedSharePointServerProvider.DeleteSiteCollection(siteCollection);
return(new object());
}, "DeleteSiteCollection");
}
public void CreateSiteCollection(SharePointSiteCollection siteCollection)
{
siteCollection.OwnerLogin = AttachNetbiosDomainName(siteCollection.OwnerLogin);
ExecuteAction <object>(delegate
{
HostedSharePointServerProvider.CreateSiteCollection(siteCollection);
return(new object());
}, "CreateSiteCollection");
}
public void RestoreSiteCollection(SharePointSiteCollection siteCollection, string filename)
{
siteCollection.OwnerLogin = AttachNetbiosDomainName(siteCollection.OwnerLogin);
ExecuteAction <object>(delegate
{
HostedSharePointServerProvider.RestoreSiteCollection(siteCollection, filename);
return(new object());
}, "RestoreSiteCollection");
}
/// <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 void DeleteSiteCollectionAsync(SharePointSiteCollection siteCollection, object userState)
{
if ((this.DeleteSiteCollectionOperationCompleted == null))
{
this.DeleteSiteCollectionOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteSiteCollectionOperationCompleted);
}
this.InvokeAsync("DeleteSiteCollection", new object[] {
siteCollection
}, this.DeleteSiteCollectionOperationCompleted, userState);
}
/// <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>
/// Gets SharePoint site collection with given id.
/// </summary>
/// <param name="itemId">Site collection id within metabase.</param>
/// <returns>Site collection or null in case no such item exist.</returns>
public static SharePointSiteCollection GetSiteCollection(int itemId)
{
if (IsDemoMode)
{
return(GetSiteCollections(1, false)[itemId - 1]);
}
SharePointSiteCollection item = PackageController.GetPackageItem(itemId) as SharePointSiteCollection;
return(item);
}
/// <summary>
/// Appends supplied binary data chunk to file.
/// </summary>
/// <param name="itemId">Item id to obtain realted service id.</param>
/// <param name="fileName">Non existent file name to append to.</param>
/// <param name="path">Full path to existent file to append to.</param>
/// <param name="chunk">Binary data chunk to append to.</param>
/// <returns>Path to file that was appended with chunk.</returns>
public static string AppendBackupBinaryChunk(int itemId, string fileName, string path, byte[] chunk)
{
// Load original meta item.
SharePointSiteCollection item = (SharePointSiteCollection)PackageController.GetPackageItem(itemId);
if (item == null)
{
return(null);
}
HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(item.ServiceId);
return(hostedSharePointServer.AppendTempFileBinaryChunk(fileName, path, chunk));
}
/// <summary>
/// Gets binary data chunk of specified size from specified offset.
/// </summary>
/// <param name="itemId">Item id to obtain realted service id.</param>
/// <param name="path">Path to file to get bunary data chunk from.</param>
/// <param name="offset">Offset from which to start data reading.</param>
/// <param name="length">Binary data chunk length.</param>
/// <returns>Binary data chunk read from file.</returns>
public static byte[] GetBackupBinaryChunk(int itemId, string path, int offset, int length)
{
// Load original meta item.
SharePointSiteCollection item = (SharePointSiteCollection)PackageController.GetPackageItem(itemId);
if (item == null)
{
return(null);
}
HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(item.ServiceId);
return(hostedSharePointServer.GetTempFileBinaryChunk(path, offset, length));
}
/// <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 BindSite()
{
try
{
SharePointSiteCollection siteCollection = ES.Services.HostedSharePointServers.GetSiteCollection(this.SiteCollectionId);
litSiteCollectionName.Text = siteCollection.PhysicalAddress;
fileLookup.SelectedFile = String.Empty;
fileLookup.PackageId = siteCollection.PackageId;
ToggleControls();
}
catch (Exception ex)
{
ShowErrorMessage("SHAREPOINT_GET_SITE", ex);
return;
}
}
/// <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);
}
/// <summary>
/// Imports selected item into metabase.
/// </summary>
/// <param name="packageId">Package to which items must be imported.</param>
/// <param name="itemTypeId">Item type id.</param>
/// <param name="itemType">Item type.</param>
/// <param name="group">Item resource group.</param>
/// <param name="itemName">Item name to import.</param>
public void ImportItem(int packageId, int itemTypeId, Type itemType, ResourceGroupInfo group, string itemName)
{
// Get service id
int serviceId = PackageController.GetPackageServiceId(packageId, group.GroupName);
if (serviceId == 0)
{
return;
}
HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(serviceId);
if (itemType == typeof(SharePointSiteCollection))
{
SharePointSiteCollection siteCollection = hostedSharePointServer.GetSiteCollection(itemName);
PackageController.AddPackageItem(siteCollection);
}
}
private void BindSite()
{
try
{
SharePointSiteCollection siteCollection = ES.Services.HostedSharePointServers.GetSiteCollection(this.SiteCollectionId);
litSiteCollectionName.Text = siteCollection.PhysicalAddress;
txtBackupName.Text = siteCollection.Url + BACKUP_EXTENSION;
fileLookup.SelectedFile = "\\";
fileLookup.PackageId = siteCollection.PackageId;
BindBackupName();
ToggleControls();
}
catch (Exception ex)
{
ShowErrorMessage("SHAREPOINT_GET_SITE", ex);
return;
}
}
public static List <SharePointSiteCollection> GetSiteCollections(int organizationId)
{
Organization org = OrganizationController.GetOrganization(organizationId);
List <ServiceProviderItem> items = PackageController.GetPackageItemsByType(org.PackageId, typeof(SharePointSiteCollection), false);
items.ConvertAll <SharePointSiteCollection>(delegate(ServiceProviderItem item) { return((SharePointSiteCollection)item); });
List <SharePointSiteCollection> ret = new List <SharePointSiteCollection>();
foreach (ServiceProviderItem item in items)
{
SharePointSiteCollection siteCollection = item as SharePointSiteCollection;
if (siteCollection != null && siteCollection.OrganizationId == organizationId)
{
ret.Add(siteCollection);
}
}
return(ret);
}
/// <summary>
/// Backups service item by serializing it into supplied writer.
/// </summary>
/// <param name="tempFolder">Temporary directory path.</param>
/// <param name="writer">Xml wirter used to store backuped service provider items.</param>
/// <param name="item">Service provider item to be backed up..</param>
/// <param name="group">Service provider resource group.</param>
/// <returns>Resulting code.</returns>
public int BackupItem(string tempFolder, XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group)
{
SharePointSiteCollection siteCollection = item as SharePointSiteCollection;
if (siteCollection != null)
{
HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(siteCollection.ServiceId);
SharePointSiteCollection loadedSiteCollection = hostedSharePointServer.GetSiteCollection(siteCollection.Url);
// Update item
siteCollection.Url = loadedSiteCollection.Url;
siteCollection.OwnerLogin = loadedSiteCollection.OwnerLogin;
siteCollection.OwnerName = loadedSiteCollection.OwnerName;
siteCollection.OwnerEmail = loadedSiteCollection.OwnerEmail;
siteCollection.LocaleId = loadedSiteCollection.LocaleId;
siteCollection.Title = loadedSiteCollection.Title;
siteCollection.Description = loadedSiteCollection.Description;
// Serialize it.
XmlSerializer serializer = new XmlSerializer(typeof(SharePointSiteCollection));
serializer.Serialize(writer, siteCollection);
}
return(0);
}
/// <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)
{
HostedSolutionLog.LogStart("CreateSiteCollection");
WindowsImpersonationContext wic = null;
Runspace runspace = null;
try
{
wic = WindowsIdentity.GetCurrent().Impersonate();
runspace = OpenRunspace();
CreateCollection(runspace, rootWebApplicationUri, siteCollection);
}
finally
{
CloseRunspace(runspace);
HostedSolutionLog.LogEnd("CreateSiteCollection");
if (wic != null)
{
wic.Undo();
}
}
}
/// <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 static void UpdateQuota(int itemId, int siteCollectionId, int maxStorage, int warningStorage)
{
TaskManager.StartTask("HOSTED_SHAREPOINT", "UPDATE_QUOTA");
try
{
Organization org = (Organization)PackageController.GetPackageItem(itemId);
if (org == null)
{
return;
}
int serviceId = GetHostedSharePointServiceId(org.PackageId);
HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(serviceId);
SharePointSiteCollection sc = GetSiteCollection(siteCollectionId);
int maxSize = RecalculateMaxSize(org.MaxSharePointStorage, maxStorage);
int warningSize = warningStorage;
sc.MaxSiteStorage = maxSize;
sc.WarningStorage = maxSize == -1 ? -1 : Math.Min(warningSize, maxSize);
PackageController.UpdatePackageItem(sc);
hostedSharePointServer.UpdateQuotas(sc.PhysicalAddress, maxSize,
warningStorage);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
/// <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; }));
}
/// <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);
}
}
