/// <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) { var itemsDiskspace = new List <ServiceProviderItemDiskSpace>(); foreach (ServiceProviderItem item in items) { if (item is SharePointEnterpriseSiteCollection) { try { Log.WriteStart(String.Format("Calculating '{0}' site logs size", item.Name)); SharePointEnterpriseSiteCollection site = Enterprise_GetSiteCollection(item.Name); var diskspace = new ServiceProviderItemDiskSpace { ItemId = item.Id, 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> Checks and sets disk quotas values.</summary> /// <param name="organization"> The organization.</param> /// <param name="collection"> The site collection.</param> private void SetStorageQuotas(Organization organization, SharePointEnterpriseSiteCollection collection) { var quotaValue = organization.MaxSharePointEnterpriseStorage; if (quotaValue != -1) { var spaceResrved = GetReservedDiskStorageSpace(); if (spaceResrved > quotaValue) { quotaValue = 0; } else { quotaValue -= spaceResrved; } if (collection != null) { quotaValue += (int)collection.MaxSiteStorage; } } maxStorage.ParentQuotaValue = quotaValue; maxStorage.QuotaValue = quotaValue; editMaxStorage.ParentQuotaValue = quotaValue; warningStorage.ParentQuotaValue = quotaValue; warningStorage.QuotaValue = quotaValue; editWarningStorage.ParentQuotaValue = quotaValue; btnUpdate.Enabled = quotaValue != 0; }
/// <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(SharePointEnterpriseSiteCollection)) { HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(serviceId); // Deserialize item. XmlSerializer serializer = new XmlSerializer(typeof(SharePointEnterpriseSiteCollection)); SharePointEnterpriseSiteCollection siteCollection = (SharePointEnterpriseSiteCollection)serializer.Deserialize(new XmlNodeReader(itemNode.SelectSingleNode("SharePointEnterpriseSiteCollection"))); siteCollection.PackageId = packageId; siteCollection.ServiceId = serviceId; // Create site collection if needed. if (hostedSharePointServer.Enterprise_GetSiteCollection(siteCollection.Url) == null) { hostedSharePointServer.Enterprise_CreateSiteCollection(siteCollection); } // Add metabase record if needed. SharePointEnterpriseSiteCollection metaSiteCollection = (SharePointEnterpriseSiteCollection)PackageController.GetPackageItemByName(packageId, itemName, typeof(SharePointEnterpriseSiteCollection)); if (metaSiteCollection == null) { PackageController.AddPackageItem(siteCollection); } } return(0); }
/// <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 Enterprise_RestoreSiteCollection(SharePointEnterpriseSiteCollection siteCollection, string filename) { ExecuteSharePointAction <object>(delegate(HostedSharePointServer2019Impl impl) { impl.RestoreSiteCollection(Enterprise_RootWebApplicationUri, siteCollection, filename); return(null); }); }
/// <summary>Deletes site collection under given url.</summary> /// <param name="siteCollection">The site collection to be deleted.</param> public void Enterprise_DeleteSiteCollection(SharePointEnterpriseSiteCollection siteCollection) { ExecuteSharePointAction <object>(delegate(HostedSharePointServer2019Impl impl) { impl.DeleteSiteCollection(Enterprise_RootWebApplicationUri, siteCollection); return(null); }); }
public void Enterprise_DeleteSiteCollection(SharePointEnterpriseSiteCollection siteCollection) { ExecuteAction <object>(delegate { HostedSharePointServerEntProvider.Enterprise_DeleteSiteCollection(siteCollection); return(new object()); }, "DeleteSiteCollection"); }
/// <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, SharePointEnterpriseSiteCollection 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); } }
public void Enterprise_RestoreSiteCollection(SharePointEnterpriseSiteCollection siteCollection, string filename) { siteCollection.OwnerLogin = AttachNetbiosDomainName(siteCollection.OwnerLogin); ExecuteAction <object>(delegate { HostedSharePointServerEntProvider.Enterprise_RestoreSiteCollection(siteCollection, filename); return(new object()); }, "RestoreSiteCollection"); }
/// <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 SharePointEnterpriseSiteCollection GetSiteCollection(int itemId) { if (IsDemoMode) { return(GetSiteCollections(1, false)[itemId - 1]); } SharePointEnterpriseSiteCollection item = PackageController.GetPackageItem(itemId) as SharePointEnterpriseSiteCollection; return(item); }
/// <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. SharePointEnterpriseSiteCollection item = (SharePointEnterpriseSiteCollection)PackageController.GetPackageItem(itemId); if (item == null) { return(null); } HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(item.ServiceId); return(hostedSharePointServer.Enterprise_GetTempFileBinaryChunk(path, offset, length)); }
/// <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. SharePointEnterpriseSiteCollection item = (SharePointEnterpriseSiteCollection)PackageController.GetPackageItem(itemId); if (item == null) { return(null); } HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(item.ServiceId); return(hostedSharePointServer.Enterprise_AppendTempFileBinaryChunk(fileName, path, chunk)); }
private void BindSite() { try { SharePointEnterpriseSiteCollection siteCollection = ES.Services.HostedSharePointServersEnt.Enterprise_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, SharePointEnterpriseSiteCollection 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; } HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(serviceId); if (itemType == typeof(SharePointEnterpriseSiteCollection)) { SharePointEnterpriseSiteCollection siteCollection = hostedSharePointServer.Enterprise_GetSiteCollection(itemName); PackageController.AddPackageItem(siteCollection); } }
public static List <SharePointEnterpriseSiteCollection> GetSiteCollections(int organizationId) { Organization org = OrganizationController.GetOrganization(organizationId); List <ServiceProviderItem> items = PackageController.GetPackageItemsByType(org.PackageId, typeof(SharePointEnterpriseSiteCollection), false); items.ConvertAll <SharePointEnterpriseSiteCollection>(delegate(ServiceProviderItem item) { return((SharePointEnterpriseSiteCollection)item); }); List <SharePointEnterpriseSiteCollection> ret = new List <SharePointEnterpriseSiteCollection>(); foreach (ServiceProviderItem item in items) { SharePointEnterpriseSiteCollection siteCollection = item as SharePointEnterpriseSiteCollection; 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) { SharePointEnterpriseSiteCollection siteCollection = item as SharePointEnterpriseSiteCollection; if (siteCollection != null) { HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(siteCollection.ServiceId); SharePointEnterpriseSiteCollection loadedSiteCollection = hostedSharePointServer.Enterprise_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(SharePointEnterpriseSiteCollection)); 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, SharePointEnterpriseSiteCollection 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, SharePointEnterpriseSiteCollection 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"); } }
/// <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 <SharePointEnterpriseSiteCollection> GetSiteCollections(int packageId, bool recursive) { if (IsDemoMode) { List <SharePointEnterpriseSiteCollection> demoResult = new List <SharePointEnterpriseSiteCollection>(); SharePointEnterpriseSiteCollection siteCollection1 = new SharePointEnterpriseSiteCollection(); 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); SharePointEnterpriseSiteCollection siteCollection2 = new SharePointEnterpriseSiteCollection(); 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(SharePointEnterpriseSiteCollection), recursive); return(items.ConvertAll <SharePointEnterpriseSiteCollection>(delegate(ServiceProviderItem item) { return (SharePointEnterpriseSiteCollection)item; })); }
public static void UpdateQuota(int itemId, int siteCollectionId, int maxStorage, int warningStorage) { TaskManager.StartTask("HOSTED_SHAREPOINT_ENTERPRISE", "UPDATE_QUOTA"); try { Organization org = (Organization)PackageController.GetPackageItem(itemId); if (org == null) { return; } int serviceId = GetHostedSharePointServiceId(org.PackageId); HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(serviceId); SharePointEnterpriseSiteCollection sc = GetSiteCollection(siteCollectionId); int maxSize = RecalculateMaxSize(org.MaxSharePointEnterpriseStorage, maxStorage); int warningSize = warningStorage; sc.MaxSiteStorage = maxSize; sc.WarningStorage = maxSize == -1 ? -1 : Math.Min(warningSize, maxSize); PackageController.UpdatePackageItem(sc); hostedSharePointServer.Enterprise_UpdateQuotas(sc.PhysicalAddress, maxSize, warningStorage); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
/// <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); } }
public static int SetStorageSettings(int itemId, int maxStorage, int warningStorage, bool applyToSiteCollections) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // place log record TaskManager.StartTask("HOSTED_SHAREPOINT_ENTERPRISE", "SET_ORG_LIMITS", itemId); try { Organization org = (Organization)PackageController.GetPackageItem(itemId); if (org == null) { return(0); } // set limits int realMaxSizeValue = RecalculateStorageMaxSize(maxStorage, org.PackageId); org.MaxSharePointEnterpriseStorage = realMaxSizeValue; org.WarningSharePointEnterpriseStorage = realMaxSizeValue == -1 ? -1 : Math.Min(warningStorage, realMaxSizeValue); // save organization UpdateOrganization(org); if (applyToSiteCollections) { int serviceId = GetHostedSharePointServiceId(org.PackageId); HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(serviceId); List <SharePointEnterpriseSiteCollection> currentOrgSiteCollection = GetOrganizationSharePointEnterpriseSiteCollections(org.Id); foreach (SharePointEnterpriseSiteCollection siteCollection in currentOrgSiteCollection) { try { SharePointEnterpriseSiteCollection sc = GetSiteCollection(siteCollection.Id); sc.MaxSiteStorage = realMaxSizeValue; sc.WarningStorage = realMaxSizeValue == -1 ? -1 : warningStorage; PackageController.UpdatePackageItem(sc); hostedSharePointServer.Enterprise_UpdateQuotas(siteCollection.PhysicalAddress, realMaxSizeValue, warningStorage); } catch (Exception ex) { TaskManager.WriteError(ex); } } } return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public int Enterprise_AddSiteCollection(SharePointEnterpriseSiteCollection item) { return(HostedSharePointServerEntController.AddSiteCollection(item)); }
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 { item = new SharePointEnterpriseSiteCollection(); if (!UseSharedSLL(PanelSecurity.PackageId)) { SharePointEnterpriseSiteCollectionListPaged existentSiteCollections = ES.Services.HostedSharePointServersEnt.Enterprise_GetSiteCollectionsPaged(PanelSecurity.PackageId, this.OrganizationId, "ItemName", String.Format("%{0}", this.domain.DomainName), String.Empty, 0, Int32.MaxValue); foreach (SharePointEnterpriseSiteCollection existentSiteCollection in existentSiteCollections.SiteCollections) { Uri existentSiteCollectionUri = new Uri(existentSiteCollection.Name); if (existentSiteCollection.Name == String.Format("{0}://{1}", existentSiteCollectionUri.Scheme, this.txtHostName.Text.ToLower() + "." + this.domain.DomainName)) { localMessageBox.ShowWarningMessage("HOSTEDSHAREPOINT_DOMAIN_IN_USE"); return; } } item.Name = this.txtHostName.Text.ToLower() + "." + this.domain.DomainName; } else { item.Name = string.Empty; } // get form data item.OrganizationId = this.OrganizationId; item.Id = this.SiteCollectionId; item.PackageId = PanelSecurity.PackageId; item.LocaleId = Int32.Parse(this.ddlLocaleID.SelectedValue); item.OwnerLogin = this.userSelector.GetSAMAccountName(); 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.HostedSharePointServersEnt.Enterprise_AddSiteCollection(item); if (result < 0) { localMessageBox.ShowResultMessage(result); return; } } catch (Exception ex) { localMessageBox.ShowErrorMessage("HOSTEDSHAREPOINT_ADD_SITECOLLECTION", ex); return; } } else { ES.Services.HostedSharePointServersEnt.Enterprise_UpdateQuota(PanelRequest.ItemID, SiteCollectionId, editMaxStorage.QuotaValue, editWarningStorage.QuotaValue); } // return RedirectToSiteCollectionsList(); }
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.HostedSharePointServersEnt.Enterprise_GetSiteCollection(this.SiteCollectionId); if (item != null) { // save package info ViewState["PackageId"] = item.PackageId; } else { RedirectToBrowsePage(); } } else { // new item ViewState["PackageId"] = PanelSecurity.PackageId; if (UseSharedSLL(PanelSecurity.PackageId)) { rowUrl.Visible = false; valRequireHostName.Enabled = false; valRequireCorrectHostName.Enabled = false; } } //this.gvUsers.DataBind(); List <CultureInfo> cultures = new List <CultureInfo>(); foreach (int localeId in ES.Services.HostedSharePointServersEnt.Enterprise_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) { SetStorageQuotas(org, item); } } //OrganizationDomainName[] domains = ES.Services.Organizations.GetOrganizationDomains(PanelRequest.ItemID); //DomainInfo[] domains = ES.Services.Servers.GetMyDomains(PanelSecurity.PackageId); EnterpriseServer.DomainInfo[] domains = ES.Services.Servers.GetDomains(PanelSecurity.PackageId); 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> /// Restores SharePoint site collection. /// </summary> /// <param name="itemId">Site collection id within metabase.</param> /// <param name="uploadedFile"></param> /// <param name="packageFile"></param> /// <returns></returns> public static int RestoreSiteCollection(int itemId, string uploadedFile, string packageFile) { // Check account. int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // Load original meta item. SharePointEnterpriseSiteCollection origItem = (SharePointEnterpriseSiteCollection)PackageController.GetPackageItem(itemId); if (origItem == null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_NOT_FOUND); } // Check package. int packageCheck = SecurityContext.CheckPackage(origItem.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // Log operation. TaskManager.StartTask("HOSTED_SHAREPOINT_ENTERPRISE", "BACKUP_SITE_COLLECTION", origItem.Name, itemId); try { // Create site collection on server. HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(origItem.ServiceId); string backupFile = null; if (!String.IsNullOrEmpty(packageFile)) { // Copy package files to the remote SharePoint Server. string path = null; byte[] buffer = null; int offset = 0; do { // Read package file. buffer = FilesController.GetFileBinaryChunk(origItem.PackageId, packageFile, offset, FILE_BUFFER_LENGTH); // Write remote backup file string tempPath = hostedSharePointServer.Enterprise_AppendTempFileBinaryChunk(Path.GetFileName(packageFile), path, buffer); if (path == null) { path = tempPath; backupFile = path; } offset += FILE_BUFFER_LENGTH; }while (buffer.Length == FILE_BUFFER_LENGTH); } else if (!String.IsNullOrEmpty(uploadedFile)) { // Upladed files. backupFile = uploadedFile; } // Restore. if (!String.IsNullOrEmpty(backupFile)) { hostedSharePointServer.Enterprise_RestoreSiteCollection(origItem, backupFile); } return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
/// <summary> /// Backups SharePoint site collection. /// </summary> /// <param name="itemId">Site collection id within metabase.</param> /// <param name="fileName">Backed up site collection file name.</param> /// <param name="zipBackup">A value which shows whether back up must be archived.</param> /// <param name="download">A value which shows whether created back up must be downloaded.</param> /// <param name="folderName">Local folder to store downloaded backup.</param> /// <returns>Created backup file name. </returns> public static string BackupSiteCollection(int itemId, string fileName, bool zipBackup, bool download, string folderName) { // Check account. int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(null); } // Load original meta item SharePointEnterpriseSiteCollection origItem = (SharePointEnterpriseSiteCollection)PackageController.GetPackageItem(itemId); if (origItem == null) { return(null); } // Log operation. TaskManager.StartTask("HOSTED_SHAREPOINT_ENTERPRISE", "BACKUP_SITE_COLLECTION", origItem.Name, itemId); try { // Create site collection on server. HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(origItem.ServiceId); string backFile = hostedSharePointServer.Enterprise_BackupSiteCollection(origItem.Name, fileName, zipBackup); if (!download) { // Copy backup files to space folder. string relFolderName = FilesController.CorrectRelativePath(folderName); if (!relFolderName.EndsWith("\\")) { relFolderName = relFolderName + "\\"; } // Create backup folder if not exists if (!FilesController.DirectoryExists(origItem.PackageId, relFolderName)) { FilesController.CreateFolder(origItem.PackageId, relFolderName); } string packageFile = relFolderName + Path.GetFileName(backFile); // Delete destination file if exists if (FilesController.FileExists(origItem.PackageId, packageFile)) { FilesController.DeleteFiles(origItem.PackageId, new string[] { packageFile }); } byte[] buffer = null; int offset = 0; do { // Read remote content. buffer = hostedSharePointServer.Enterprise_GetTempFileBinaryChunk(backFile, offset, FILE_BUFFER_LENGTH); // Write remote content. FilesController.AppendFileBinaryChunk(origItem.PackageId, packageFile, buffer); offset += FILE_BUFFER_LENGTH; }while (buffer.Length == FILE_BUFFER_LENGTH); } return(backFile); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
/// <summary> /// Deletes SharePoint site collection with given id. /// </summary> /// <param name="itemId">Site collection id within metabase.</param> /// <returns>?</returns> public static int DeleteSiteCollection(int itemId) { // Check account. int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // Load original meta item SharePointEnterpriseSiteCollection origItem = (SharePointEnterpriseSiteCollection)PackageController.GetPackageItem(itemId); if (origItem == null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_NOT_FOUND); } // Get service settings. StringDictionary hostedSharePointSettings = ServerController.GetServiceSettings(origItem.ServiceId); Uri rootWebApplicationUri = new Uri(hostedSharePointSettings["RootWebApplicationUri"]); string siteName = origItem.Name.Replace(String.Format("{0}://", rootWebApplicationUri.Scheme), String.Empty); // Log operation. TaskManager.StartTask("HOSTED_SHAREPOINT_ENTERPRISE", "DELETE_SITE", origItem.Name, itemId); try { // Delete site collection on server. HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(origItem.ServiceId); hostedSharePointServer.Enterprise_DeleteSiteCollection(origItem); // Delete record in metabase. PackageController.DeletePackageItem(origItem.Id); int dnsServiceId = PackageController.GetPackageServiceId(origItem.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(origItem.ServiceId); List <DnsRecord> resourceRecords = DnsServerController.BuildDnsResourceRecords(dnsRecords, hostName, domainName, ""); DNSServer dns = new DNSServer(); ServiceProviderProxy.Init(dns, dnsServiceId); // add new resource records dns.DeleteZoneRecords(domainName, resourceRecords.ToArray()); } return(0); } 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(SharePointEnterpriseSiteCollection 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.AllocatedSharePointEnterpriseSiteCollections > -1 && orgStats.CreatedSharePointEnterpriseSiteCollections >= orgStats.AllocatedSharePointEnterpriseSiteCollections) { return(BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_QUOTA_LIMIT); } // Check if stats resource is available int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.SharepointEnterpriseServer); if (serviceId == 0) { return(BusinessErrorCodes.ERROR_SHAREPOINT_RESOURCE_UNAVAILABLE); } StringDictionary hostedSharePointSettings = ServerController.GetServiceSettings(serviceId); QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.HOSTED_SHAREPOINT_ENTERPRISE_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.SharePointEnterpriseSiteCollection, 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.MaxSharePointEnterpriseStorage, (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(SharePointEnterpriseSiteCollection)) != null) { return(BusinessErrorCodes.ERROR_SHAREPOINT_PACKAGE_ITEM_EXISTS); } // Log operation. TaskManager.StartTask("HOSTED_SHAREPOINT_ENTERPRISE", "ADD_SITE_COLLECTION", item.Name); try { // Create site collection on server. HostedSharePointServerEnt hostedSharePointServer = GetHostedSharePointServer(serviceId); hostedSharePointServer.Enterprise_CreateSiteCollection(item); // Make record in metabase. item.ServiceId = serviceId; int itemId = PackageController.AddPackageItem(item); hostedSharePointServer.Enterprise_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(); } }