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));
}
