public int MovePackageItem(int itemId, int destinationServiceId) { return(PackageController.MovePackageItem(itemId, destinationServiceId, false)); }
/// <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 SharePointSiteCollection origItem = (SharePointSiteCollection)PackageController.GetPackageItem(itemId); if (origItem == null) { return(null); } // Log operation. TaskManager.StartTask("HOSTEDSHAREPOINT", "BACKUP_SITE_COLLECTION", origItem.Name); TaskManager.ItemId = itemId; try { // Create site collection on server. HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(origItem.ServiceId); string backFile = hostedSharePointServer.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.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> /// 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); }
public ServiceProviderItemDiskSpace[] CalculateItems(int serviceId, List <ServiceProviderItem> items) { // convert items to SoapObjects List <SoapServiceProviderItem> objItems = new List <SoapServiceProviderItem>(); //hack for organization... Refactoring!!! List <ServiceProviderItemDiskSpace> organizationDiskSpaces = new List <ServiceProviderItemDiskSpace>(); foreach (ServiceProviderItem item in items) { long size = 0; if (item is Organization) { Organization org = (Organization)item; //Exchange DiskSpace if (!string.IsNullOrEmpty(org.GlobalAddressList)) { int exchangeServiceId = GetExchangeServiceID(org.PackageId); if (exchangeServiceId > 0) { ServiceProvider exchangeProvider = ExchangeServerController.GetExchangeServiceProvider(exchangeServiceId, item.ServiceId); SoapServiceProviderItem soapOrg = SoapServiceProviderItem.Wrap(org); ServiceProviderItemDiskSpace[] itemsDiskspace = exchangeProvider.GetServiceItemsDiskSpace(new SoapServiceProviderItem[] { soapOrg }); if (itemsDiskspace != null && itemsDiskspace.Length > 0) { size += itemsDiskspace[0].DiskSpace; } } } // Crm DiskSpace if (org.CrmOrganizationId != Guid.Empty) { //CalculateCrm DiskSpace } //SharePoint DiskSpace int res; PackageContext cntx = PackageController.GetPackageContext(org.PackageId); if (cntx.Groups.ContainsKey(ResourceGroups.SharepointFoundationServer)) { SharePointSiteDiskSpace[] sharePointSiteDiskSpaces = HostedSharePointServerController.CalculateSharePointSitesDiskSpace(org.Id, out res); if (res == 0) { foreach (SharePointSiteDiskSpace currecnt in sharePointSiteDiskSpaces) { size += currecnt.DiskSpace; } } } if (cntx.Groups.ContainsKey(ResourceGroups.SharepointEnterpriseServer)) { SharePointSiteDiskSpace[] sharePointSiteDiskSpaces = HostedSharePointServerEntController.CalculateSharePointSitesDiskSpace(org.Id, out res); if (res == 0) { foreach (SharePointSiteDiskSpace currecnt in sharePointSiteDiskSpaces) { size += currecnt.DiskSpace; } } } ServiceProviderItemDiskSpace tmp = new ServiceProviderItemDiskSpace(); tmp.ItemId = item.Id; tmp.DiskSpace = size; organizationDiskSpaces.Add(tmp); } else { objItems.Add(SoapServiceProviderItem.Wrap(item)); } } int attempt = 0; int ATTEMPTS = 3; while (attempt < ATTEMPTS) { // increment attempt attempt++; try { // send packet for calculation // invoke service provider //TaskManager.Write(String.Format("{0} - Invoke GetServiceItemsDiskSpace method ('{1}' items) - {2} attempt", // DateTime.Now, objItems.Count, attempt)); if (objItems.Count > 0) { ServiceProvider prov = new ServiceProvider(); ServiceProviderProxy.Init(prov, serviceId); ServiceProviderItemDiskSpace[] itemsDiskSpace = prov.GetServiceItemsDiskSpace(objItems.ToArray()); if (itemsDiskSpace != null && itemsDiskSpace.Length > 0) { organizationDiskSpaces.AddRange(itemsDiskSpace); } } return(organizationDiskSpaces.ToArray()); } catch (Exception ex) { TaskManager.WriteError(ex.ToString()); } } throw new Exception("The number of attemtps has been reached. The package calculation has been aborted."); }
/// <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(); } }
public int AddHostingPlan(HostingPlanInfo plan) { return(PackageController.AddHostingPlan(plan)); }
/// ----------------------------------------------------------------------------- /// <summary> /// The ReadManifest method reads the manifest file and parses it into components. /// </summary> /// ----------------------------------------------------------------------------- public override void ReadManifest(XPathNavigator manifestNav) { //Get Name Property Package.Name = Util.ReadAttribute(manifestNav, "name", Log, Util.EXCEPTION_NameMissing); //Get Type Package.PackageType = Util.ReadAttribute(manifestNav, "type", Log, Util.EXCEPTION_TypeMissing); //If Skin or Container then set PortalID if (Package.PackageType.Equals("Skin", StringComparison.OrdinalIgnoreCase) || Package.PackageType.Equals("Container", StringComparison.OrdinalIgnoreCase)) { Package.PortalID = Package.InstallerInfo.PortalID; } CheckSecurity(); if (!IsValid) { return; } //Get IsSystem Package.IsSystemPackage = bool.Parse(Util.ReadAttribute(manifestNav, "isSystem", false, Log, "", bool.FalseString)); //Get Version string strVersion = Util.ReadAttribute(manifestNav, "version", Log, Util.EXCEPTION_VersionMissing); if (string.IsNullOrEmpty(strVersion)) { IsValid = false; } if (IsValid) { Package.Version = new Version(strVersion); } else { return; } //Attempt to get the Package from the Data Store (see if its installed) var packageType = PackageController.Instance.GetExtensionPackageType(t => t.PackageType.Equals(Package.PackageType, StringComparison.OrdinalIgnoreCase)); if (packageType.SupportsSideBySideInstallation) { _installedPackage = PackageController.Instance.GetExtensionPackage(Package.PortalID, p => p.Name.Equals(Package.Name, StringComparison.OrdinalIgnoreCase) && p.PackageType.Equals(Package.PackageType, StringComparison.OrdinalIgnoreCase) && p.Version == Package.Version); } else { _installedPackage = PackageController.Instance.GetExtensionPackage(Package.PortalID, p => p.Name.Equals(Package.Name, StringComparison.OrdinalIgnoreCase) && p.PackageType.Equals(Package.PackageType, StringComparison.OrdinalIgnoreCase)); } if (_installedPackage != null) { Package.InstalledVersion = _installedPackage.Version; Package.InstallerInfo.PackageID = _installedPackage.PackageID; if (Package.InstalledVersion > Package.Version) { Log.AddFailure(Util.INSTALL_Version + " - " + Package.InstalledVersion.ToString(3)); IsValid = false; } else if (Package.InstalledVersion == Package.Version) { Package.InstallerInfo.Installed = true; Package.InstallerInfo.PortalID = _installedPackage.PortalID; } } Log.AddInfo(Util.DNN_ReadingPackage + " - " + Package.PackageType + " - " + Package.Name); Package.FriendlyName = Util.ReadElement(manifestNav, "friendlyName", Package.Name); Package.Description = Util.ReadElement(manifestNav, "description"); XPathNavigator foldernameNav = null; Package.FolderName = String.Empty; switch (Package.PackageType) { case "Module": //In Dynamics moduels, a component:type=File can have a basePath pointing to the App_Conde folder. This is not a correct FolderName //To ensure that FolderName is DesktopModules... var folderNameValue = PackageController.GetSpecificFolderName(manifestNav, "components/component/files|components/component/resourceFiles", "basePath", "DesktopModules"); if (!String.IsNullOrEmpty(folderNameValue)) { Package.FolderName = folderNameValue.Replace('\\', '/'); } break; case "Auth_System": foldernameNav = manifestNav.SelectSingleNode("components/component/files"); if (foldernameNav != null) { Package.FolderName = Util.ReadElement(foldernameNav, "basePath").Replace('\\', '/'); } break; case "Container": foldernameNav = manifestNav.SelectSingleNode("components/component/containerFiles"); if (foldernameNav != null) { Package.FolderName = Globals.glbContainersPath + Util.ReadElement(foldernameNav, "containerName").Replace('\\', '/'); } break; case "Skin": foldernameNav = manifestNav.SelectSingleNode("components/component/skinFiles"); if (foldernameNav != null) { Package.FolderName = Globals.glbSkinsPath + Util.ReadElement(foldernameNav, "skinName").Replace('\\', '/'); } break; default: //copied from "Module" without the extra OR condition folderNameValue = PackageController.GetSpecificFolderName(manifestNav, "components/component/resourceFiles", "basePath", "DesktopModules"); if (!String.IsNullOrEmpty(folderNameValue)) { Package.FolderName = folderNameValue.Replace('\\', '/'); } break; } _eventMessage = ReadEventMessageNode(manifestNav); //Get Icon XPathNavigator iconFileNav = manifestNav.SelectSingleNode("iconFile"); if (iconFileNav != null) { if (iconFileNav.Value != string.Empty) { if (iconFileNav.Value.StartsWith("~/")) { Package.IconFile = iconFileNav.Value; } else if (iconFileNav.Value.StartsWith("DesktopModules", StringComparison.InvariantCultureIgnoreCase)) { Package.IconFile = string.Format("~/{0}", iconFileNav.Value); } else { Package.IconFile = (String.IsNullOrEmpty(Package.FolderName) ? "" : Package.FolderName + "/") + iconFileNav.Value; Package.IconFile = (!Package.IconFile.StartsWith("~/")) ? "~/" + Package.IconFile : Package.IconFile; } } } //Get Author XPathNavigator authorNav = manifestNav.SelectSingleNode("owner"); if (authorNav != null) { Package.Owner = Util.ReadElement(authorNav, "name"); Package.Organization = Util.ReadElement(authorNav, "organization"); Package.Url = Util.ReadElement(authorNav, "url"); Package.Email = Util.ReadElement(authorNav, "email"); } //Get License XPathNavigator licenseNav = manifestNav.SelectSingleNode("license"); if (licenseNav != null) { string licenseSrc = Util.ReadAttribute(licenseNav, "src"); if (string.IsNullOrEmpty(licenseSrc)) { //Load from element Package.License = licenseNav.Value; } else { Package.License = ReadTextFromFile(licenseSrc); } } if (string.IsNullOrEmpty(Package.License)) { //Legacy Packages have no license Package.License = Util.PACKAGE_NoLicense; } //Get Release Notes XPathNavigator relNotesNav = manifestNav.SelectSingleNode("releaseNotes"); if (relNotesNav != null) { string relNotesSrc = Util.ReadAttribute(relNotesNav, "src"); if (string.IsNullOrEmpty(relNotesSrc)) { //Load from element Package.ReleaseNotes = relNotesNav.Value; } else { Package.ReleaseNotes = ReadTextFromFile(relNotesSrc); } } if (string.IsNullOrEmpty(Package.ReleaseNotes)) { //Legacy Packages have no Release Notes Package.ReleaseNotes = Util.PACKAGE_NoReleaseNotes; } //Parse the Dependencies var packageDependencies = Package.Dependencies; foreach (XPathNavigator dependencyNav in manifestNav.CreateNavigator().Select("dependencies/dependency")) { var dependency = DependencyFactory.GetDependency(dependencyNav); var packageDependecy = dependency as IManagedPackageDependency; if (packageDependecy != null) { packageDependencies.Add(packageDependecy.PackageDependency); } if (!dependency.IsValid) { Log.AddFailure(dependency.ErrorMessage); return; } } //Read Components ReadComponents(manifestNav); }
public DataSet GetPackagesDiskspacePaged(int userId, int packageId, string sortColumn, int startRow, int maximumRows) { return(PackageController.GetPackagesDiskspacePaged(userId, packageId, sortColumn, startRow, maximumRows)); }
public DataSet GetPackageBandwidth(int packageId, DateTime startDate, DateTime endDate) { return(PackageController.GetPackageBandwidth(packageId, startDate, endDate)); }
public string GetEvaluatedPackageTemplateBody(int packageId) { return(PackageController.GetEvaluatedPackageTemplateBody(packageId, false)); }
public string GetEvaluatedAccountTemplateBody(int userId) { return(PackageController.GetEvaluatedAccountTemplateBody(userId, false)); }
public int SendPackageSummaryLetter(int packageId, string to, string cc) { return(PackageController.SendPackageSummaryLetter(packageId, to, cc, false)); }
public int SendAccountSummaryLetter(int userId, string to, string cc) { return(PackageController.SendAccountSummaryLetter(userId, to, cc, false)); }
public QuotaValueInfo GetPackageQuota(int packageId, string quotaName) { return(PackageController.GetPackageQuota(packageId, quotaName)); }
public HostingPlanContext GetHostingPlanContext(int planId) { return(PackageController.GetHostingPlanContext(planId)); }
public DataSet GetPackageDiskspace(int packageId) { return(PackageController.GetPackageDiskspace(packageId)); }
public List <HostingPlanInfo> GetUserAvailableHostingAddons(int userId) { return(PackageController.GetUserAvailableHostingAddons(userId)); }
public DataSet GetOverusageSummaryReport(int userId, int packageId, DateTime startDate, DateTime endDate) { return(PackageController.GetOverusageSummaryReport(userId, packageId, startDate, endDate)); }
public override void DoWork() { // Input parameters: // - DISKSPACE_OVERUSED // - BANDWIDTH_OVERUSED BackgroundTask topTask = TaskManager.TopTask; // get the list of all packages List <PackageInfo> packages = PackageController.GetPackagePackages(topTask.PackageId, false); TaskManager.Write("Packages to verify: " + packages.Count.ToString()); bool checkMSSQL = (String.Compare((string)topTask.GetParamValue("MSSQL_OVERUSED"), "true", true) == 0); bool checkMySQL = (String.Compare((string)topTask.GetParamValue("MYSQL_OVERUSED"), "true", true) == 0); bool sendWarningEmail = Convert.ToBoolean(topTask.GetParamValue("SEND_WARNING_EMAIL")); bool sendOverusedEmail = Convert.ToBoolean(topTask.GetParamValue("SEND_OVERUSED_EMAIL")); int warningUsageThreshold = Convert.ToInt32(topTask.GetParamValue("WARNING_USAGE_THRESHOLD")); int overusedUsageThreshold = Convert.ToInt32(topTask.GetParamValue("OVERUSED_USAGE_THRESHOLD")); string warningMailFrom = Convert.ToString(topTask.GetParamValue("WARNING_MAIL_FROM")); string warningMailBcc = Convert.ToString(topTask.GetParamValue("WARNING_MAIL_BCC")); string warningMailSubject = Convert.ToString(topTask.GetParamValue("WARNING_MAIL_SUBJECT")); string warningMailBody = Convert.ToString(topTask.GetParamValue("WARNING_MAIL_BODY")); string overusedMailFrom = Convert.ToString(topTask.GetParamValue("OVERUSED_MAIL_FROM")); string overusedMailBcc = Convert.ToString(topTask.GetParamValue("OVERUSED_MAIL_BCC")); string overusedMailSubject = Convert.ToString(topTask.GetParamValue("OVERUSED_MAIL_SUBJECT")); string overusedMailBody = Convert.ToString(topTask.GetParamValue("OVERUSED_MAIL_BODY")); int overusedPackages = 0; foreach (PackageInfo package in packages) { UserInfo userInfo = UserController.GetUser(package.UserId); List <DatabaseQuota> quotaMSSQL = new List <DatabaseQuota>(); List <DatabaseQuota> quotaMYSQL = new List <DatabaseQuota>(); if (checkMSSQL || checkMySQL) { QuotaValueInfo dsQuota = null; DataSet Diskspace = PackageController.GetPackageDiskspace(package.PackageId); foreach (DataRow spaceRow in Diskspace.Tables[0].Rows) { string groupName = spaceRow["GroupName"].ToString(); if (checkMSSQL && groupName.ToUpper().Contains("MSSQL")) { dsQuota = PackageController.GetPackageQuota(package.PackageId, groupName + ".MaxDatabaseSize"); if (dsQuota.QuotaAllocatedValue > 0) { int databaseSpaceUsage = Convert.ToInt32(spaceRow["Diskspace"]) * 100 / dsQuota.QuotaAllocatedValue; quotaMSSQL.Add(new DatabaseQuota(groupName.ToUpper().Replace("MSSQL", "SQL Server "), Convert.ToInt32(spaceRow["Diskspace"]), dsQuota.QuotaAllocatedValue, databaseSpaceUsage < warningUsageThreshold, databaseSpaceUsage < overusedUsageThreshold)); } } if (checkMySQL && groupName.ToUpper().Contains("MYSQL")) { dsQuota = PackageController.GetPackageQuota(package.PackageId, groupName + ".MaxDatabaseSize"); if (dsQuota.QuotaAllocatedValue > 0) { int databaseSpaceUsage = Convert.ToInt32(spaceRow["Diskspace"]) * 100 / dsQuota.QuotaAllocatedValue; quotaMYSQL.Add(new DatabaseQuota(groupName.ToUpper().Replace("MYSQL", "MySQL "), Convert.ToInt32(spaceRow["Diskspace"]), dsQuota.QuotaAllocatedValue, databaseSpaceUsage < warningUsageThreshold, databaseSpaceUsage < overusedUsageThreshold)); } } } string userName = String.Format("{0} {1} ({2})/{3}", userInfo.FirstName, userInfo.LastName, userInfo.Username, userInfo.Email); bool notifyOverusedByMail = false; bool notifyWarningByMail = false; List <string> formatItems = new List <string>(); List <string> formatWarningThreshold = new List <string>(); List <string> formatOverusedThreshold = new List <string>(); // add Microsoft SQL usage if enabled if (checkMSSQL) { foreach (DatabaseQuota q in quotaMSSQL) { if (!q.BelowWarningThreshold || !q.BelowUsageThreshold) { formatItems.Add(String.Format(DISKSPACE_FORMAT_STRING, q.ProviderName, q.SpaceUsed, q.SpaceUsed * 100 / q.SpaceAllocated)); } if (!q.BelowWarningThreshold) { formatWarningThreshold.Add(String.Format(ALLOC_FORMAT_STRING, q.ProviderName, q.SpaceAllocated)); notifyWarningByMail = true; } if (!q.BelowUsageThreshold) { formatOverusedThreshold.Add(String.Format(ALLOC_FORMAT_STRING, q.ProviderName, q.SpaceAllocated)); notifyOverusedByMail = true; } } } // add MySQL usage if enabled if (checkMySQL) { foreach (DatabaseQuota q in quotaMYSQL) { if (!q.BelowWarningThreshold || !q.BelowUsageThreshold) { formatItems.Add(String.Format(DISKSPACE_FORMAT_STRING, q.ProviderName, q.SpaceUsed, (q.SpaceUsed * 100) / q.SpaceAllocated)); } if (!q.BelowWarningThreshold) { formatWarningThreshold.Add(String.Format(ALLOC_FORMAT_STRING, q.ProviderName, q.SpaceAllocated)); notifyWarningByMail = true; } if (!q.BelowUsageThreshold) { formatOverusedThreshold.Add(String.Format(ALLOC_FORMAT_STRING, q.ProviderName, q.SpaceAllocated)); notifyOverusedByMail = true; } } } // build usage strings string usage = String.Join("\n", formatItems.ToArray()); string usageWarning = String.Join("\n", formatWarningThreshold.ToArray()); string usageOverused = String.Join("\n", formatOverusedThreshold.ToArray()); string warningMailSubjectProcessed = ReplaceVariables(warningMailSubject, usageWarning, usage, package.PackageName, userName); string warningMailBodyProcessed = ReplaceVariables(warningMailBody, usageWarning, usage, package.PackageName, userName); string overusedMailSubjectProcessed = ReplaceVariables(overusedMailSubject, usageOverused, usage, package.PackageName, userName); string overusedMailBodyProcessed = ReplaceVariables(overusedMailBody, usageOverused, usage, package.PackageName, userName); // Send email notifications if (sendWarningEmail && notifyWarningByMail) { // Send warning email. this.SendEmail(warningMailFrom, userInfo.Email, warningMailBcc, warningMailSubjectProcessed, warningMailBodyProcessed, false); } if (sendOverusedEmail && notifyOverusedByMail) { // Send overused email. this.SendEmail(overusedMailFrom, userInfo.Email, overusedMailBcc, overusedMailSubjectProcessed, overusedMailBodyProcessed, false); } if (notifyOverusedByMail) { overusedPackages++; } } } // log results TaskManager.Write("Total packages overused: " + overusedPackages.ToString()); }
public DataSet GetDiskspaceOverusageDetailsReport(int userId, int packageId) { return(PackageController.GetDiskspaceOverusageDetailsReport(userId, packageId)); }
private static int GetExchangeServiceID(int packageId) { return(PackageController.GetPackageServiceId(packageId, ResourceGroups.Exchange)); }
public DataSet GetBandwidthOverusageDetailsReport(int userId, int packageId, DateTime startDate, DateTime endDate) { return(PackageController.GetBandwidthDetailsReport(userId, packageId, startDate, endDate)); }
public PackageInfoSlimDto(int portalId, PackageInfo package) { PackageId = package.PackageID; FriendlyName = package.FriendlyName; Name = package.Name; FileName = package.FileName; Description = package.Description; Version = package.Version.ToString(3); IsInUse = ExtensionsController.IsPackageInUse(package, portalId); UpgradeUrl = ExtensionsController.UpgradeRedirect(package.Version, package.PackageType, package.Name); UpgradeIndicator = ExtensionsController.UpgradeIndicator(package.Version, package.PackageType, package.Name); PackageIcon = ExtensionsController.GetPackageIcon(package); CanDelete = package.PackageID != Null.NullInteger && !package.IsSystemPackage && PackageController.CanDeletePackage(package, PortalSettings.Current); if (package.PackageID != Null.NullInteger) { var authService = AuthenticationController.GetAuthenticationServiceByPackageID(PackageId); ReadOnly = authService != null && authService.AuthenticationType == Constants.DnnAuthTypeName; } }
public DataSet GetHostingAddons(int userId) { return(PackageController.GetHostingAddons(userId)); }
/// <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 SharePointSiteCollection origItem = (SharePointSiteCollection)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 domainName = origItem.Name.Replace(String.Format("{0}://", rootWebApplicationUri.Scheme), String.Empty); // Log operation. TaskManager.StartTask("HOSTEDSHAREPOINT", "DELETE_SITE", origItem.Name); TaskManager.ItemId = itemId; try { // Delete site collection on server. HostedSharePointServer hostedSharePointServer = GetHostedSharePointServer(origItem.ServiceId); hostedSharePointServer.DeleteSiteCollection(origItem.Url); // Delete record in metabase. PackageController.DeletePackageItem(origItem.Id); int dnsServiceId = PackageController.GetPackageServiceId(origItem.PackageId, ResourceGroups.Dns); if (dnsServiceId > 0) { DomainInfo domain = ServerController.GetDomain(domainName); if (domain != null) { ServerController.DeleteDnsZoneRecord(domain.DomainId, String.Empty, DnsRecordType.A, hostedSharePointSettings["RootWebApplicationIpAddress"]); ServerController.DeleteDnsZoneRecord(domain.DomainId, "www", DnsRecordType.A, hostedSharePointSettings["RootWebApplicationIpAddress"]); if (!String.IsNullOrEmpty(domain.WebSiteName)) { DnsRecord[] records = ServerController.GetDnsZoneRecords(domain.DomainId); foreach (DnsRecord record in records) { if (record.RecordType.Equals(DnsRecordType.A) && record.RecordName.Equals("www", StringComparison.CurrentCultureIgnoreCase)) { ServerController.AddDnsZoneRecord(domain.DomainId, String.Empty, DnsRecordType.A, record.RecordData, 0); break; } } } } } return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public HostingPlanInfo GetHostingPlan(int planId) { return(PackageController.GetHostingPlan(planId)); }
/// <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. SharePointSiteCollection origItem = (SharePointSiteCollection)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("HOSTEDSHAREPOINT", "BACKUP_SITE_COLLECTION", origItem.Name); TaskManager.ItemId = itemId; try { // Create site collection on server. HostedSharePointServer 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.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.RestoreSiteCollection(origItem, backupFile); } return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public DataSet GetHostingPlanQuotas(int packageId, int planId, int serverId) { return(PackageController.GetHostingPlanQuotas(packageId, planId, serverId)); }
private static int GetHostedSharePointServiceId(int packageId) { return(PackageController.GetPackageServiceId(packageId, ResourceGroups.HostedSharePoint)); }
public int DetachPackageItem(int itemId) { return(PackageController.DetachPackageItem(itemId)); }