2486 lines
104 KiB
C#
2486 lines
104 KiB
C#
// Copyright (c) 2012, Outercurve Foundation.
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// - Redistributions of source code must retain the above copyright notice, this
|
|
// list of conditions and the following disclaimer.
|
|
//
|
|
// - Redistributions in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// - Neither the name of the Outercurve Foundation nor the names of its
|
|
// contributors may be used to endorse or promote products derived from this
|
|
// software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
|
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Web;
|
|
using System.Data;
|
|
using System.Reflection;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Collections.Generic;
|
|
using System.Xml;
|
|
using System.Net.Mail;
|
|
|
|
using WebsitePanel.Providers;
|
|
using WebsitePanel.Providers.Web;
|
|
using WebsitePanel.Providers.FTP;
|
|
using WebsitePanel.Providers.Mail;
|
|
using WebsitePanel.Providers.OS;
|
|
using OS = WebsitePanel.Providers.OS;
|
|
using Reports = WebsitePanel.EnterpriseServer.Base.Reports;
|
|
using System.Diagnostics;
|
|
using WebsitePanel.Templates;
|
|
|
|
namespace WebsitePanel.EnterpriseServer
|
|
{
|
|
/// <summary>
|
|
/// Summary description for Packages.
|
|
/// </summary>
|
|
public class PackageController
|
|
{
|
|
#region Hosting Plans
|
|
public static DataSet GetHostingPlans(int userId)
|
|
{
|
|
return DataProvider.GetHostingPlans(SecurityContext.User.UserId, userId);
|
|
}
|
|
|
|
public static DataSet GetHostingAddons(int userId)
|
|
{
|
|
return DataProvider.GetHostingAddons(SecurityContext.User.UserId, userId);
|
|
}
|
|
|
|
public static HostingPlanInfo GetHostingPlan(int planId)
|
|
{
|
|
return ObjectUtils.FillObjectFromDataReader<HostingPlanInfo>(
|
|
DataProvider.GetHostingPlan(SecurityContext.User.UserId, planId));
|
|
}
|
|
|
|
public static DataSet GetHostingPlanQuotas(int packageId, int planId, int serverId)
|
|
{
|
|
return DataProvider.GetHostingPlanQuotas(SecurityContext.User.UserId, packageId,
|
|
planId, serverId);
|
|
}
|
|
|
|
public static HostingPlanContext GetHostingPlanContext(int planId)
|
|
{
|
|
HostingPlanContext context = new HostingPlanContext();
|
|
|
|
// load hosting plan
|
|
context.HostingPlan = GetHostingPlan(planId);
|
|
if (context.HostingPlan == null)
|
|
return null;
|
|
|
|
// load groups and quotas
|
|
DataSet ds = GetHostingPlanQuotas(0, planId, 0);
|
|
|
|
List<HostingPlanGroupInfo> groups = new List<HostingPlanGroupInfo>();
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
HostingPlanGroupInfo group = new HostingPlanGroupInfo();
|
|
group.GroupId = (int)dr["GroupID"];
|
|
group.GroupName = (string)dr["GroupName"];
|
|
|
|
bool enabled = (bool)dr["Enabled"];
|
|
group.Enabled = enabled;
|
|
group.CalculateBandwidth = (bool)dr["CalculateBandwidth"];
|
|
group.CalculateDiskSpace = (bool)dr["CalculateDiskSpace"];
|
|
|
|
if (enabled)
|
|
{
|
|
groups.Add(group);
|
|
context.Groups.Add(group.GroupName, group);
|
|
}
|
|
}
|
|
|
|
List<QuotaValueInfo> quotas = new List<QuotaValueInfo>();
|
|
foreach (DataRow dr in ds.Tables[1].Rows)
|
|
{
|
|
QuotaValueInfo quota = new QuotaValueInfo();
|
|
quota.QuotaId = (int)dr["QuotaId"];
|
|
quota.GroupId = (int)dr["GroupId"];
|
|
quota.QuotaName = (string)dr["QuotaName"];
|
|
quota.QuotaTypeId = (int)dr["QuotaTypeId"];
|
|
quota.QuotaAllocatedValue = (int)dr["QuotaValue"];
|
|
quotas.Add(quota);
|
|
context.Quotas.Add(quota.QuotaName, quota);
|
|
}
|
|
|
|
context.GroupsArray = groups.ToArray();
|
|
context.QuotasArray = quotas.ToArray();
|
|
|
|
return context;
|
|
}
|
|
|
|
private static string BuildPlanQuotasXml(HostingPlanGroupInfo[] groups, HostingPlanQuotaInfo[] quotas)
|
|
{
|
|
// build xml
|
|
/*
|
|
XML Format:
|
|
|
|
<plan>
|
|
<groups>
|
|
<group id="16" enabled="1" calculateDiskSpace="1" calculateBandwidth="1"/>
|
|
</groups>
|
|
<quotas>
|
|
<quota id="2" value="2"/>
|
|
</quotas>
|
|
</plan>
|
|
|
|
*/
|
|
|
|
if (groups == null || quotas == null)
|
|
return null;
|
|
|
|
XmlDocument doc = new XmlDocument();
|
|
XmlElement nodePlan = doc.CreateElement("plan");
|
|
|
|
XmlElement nodeGroups = doc.CreateElement("groups");
|
|
nodePlan.AppendChild(nodeGroups);
|
|
XmlElement nodeQuotas = doc.CreateElement("quotas");
|
|
nodePlan.AppendChild(nodeQuotas);
|
|
|
|
// groups
|
|
if (groups != null)
|
|
{
|
|
foreach (HostingPlanGroupInfo group in groups)
|
|
{
|
|
XmlElement nodeGroup = doc.CreateElement("group");
|
|
nodeGroups.AppendChild(nodeGroup);
|
|
nodeGroup.SetAttribute("id", group.GroupId.ToString());
|
|
nodeGroup.SetAttribute("enabled", group.Enabled ? "1" : "0");
|
|
nodeGroup.SetAttribute("calculateDiskSpace", group.CalculateDiskSpace ? "1" : "0");
|
|
nodeGroup.SetAttribute("calculateBandwidth", group.CalculateBandwidth ? "1" : "0");
|
|
}
|
|
}
|
|
|
|
// quotas
|
|
if (quotas != null)
|
|
{
|
|
foreach (HostingPlanQuotaInfo quota in quotas)
|
|
{
|
|
XmlElement nodeQuota = doc.CreateElement("quota");
|
|
nodeQuotas.AppendChild(nodeQuota);
|
|
nodeQuota.SetAttribute("id", quota.QuotaId.ToString());
|
|
nodeQuota.SetAttribute("value", quota.QuotaValue.ToString());
|
|
}
|
|
}
|
|
|
|
return nodePlan.OuterXml;
|
|
}
|
|
|
|
public static List<HostingPlanInfo> GetUserAvailableHostingPlans(int userId)
|
|
{
|
|
return ObjectUtils.CreateListFromDataSet<HostingPlanInfo>(
|
|
DataProvider.GetUserAvailableHostingPlans(SecurityContext.User.UserId, userId));
|
|
}
|
|
|
|
public static List<HostingPlanInfo> GetUserAvailableHostingAddons(int userId)
|
|
{
|
|
return ObjectUtils.CreateListFromDataSet<HostingPlanInfo>(
|
|
DataProvider.GetUserAvailableHostingAddons(SecurityContext.User.UserId, userId));
|
|
}
|
|
|
|
public static int AddHostingPlan(HostingPlanInfo plan)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsReseller);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
string quotasXml = BuildPlanQuotasXml(plan.Groups, plan.Quotas);
|
|
|
|
return DataProvider.AddHostingPlan(SecurityContext.User.UserId, plan.UserId, plan.PackageId, plan.PlanName,
|
|
plan.PlanDescription, plan.Available, plan.ServerId, plan.SetupPrice, plan.RecurringPrice,
|
|
plan.RecurrenceUnit, plan.RecurrenceLength, plan.IsAddon, quotasXml);
|
|
}
|
|
|
|
public static PackageResult UpdateHostingPlan(HostingPlanInfo plan)
|
|
{
|
|
PackageResult result = new PackageResult();
|
|
|
|
// check account
|
|
result.Result = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsReseller);
|
|
if (result.Result < 0) return result;
|
|
|
|
string quotasXml = BuildPlanQuotasXml(plan.Groups, plan.Quotas);
|
|
|
|
result.ExceedingQuotas = DataProvider.UpdateHostingPlan(SecurityContext.User.UserId,
|
|
plan.PlanId, plan.PackageId, plan.ServerId, plan.PlanName,
|
|
plan.PlanDescription, plan.Available, plan.SetupPrice, plan.RecurringPrice,
|
|
plan.RecurrenceUnit, plan.RecurrenceLength, quotasXml);
|
|
|
|
if (result.ExceedingQuotas.Tables[0].Rows.Count > 0)
|
|
result.Result = BusinessErrorCodes.ERROR_PACKAGE_QUOTA_EXCEED;
|
|
|
|
return result;
|
|
}
|
|
|
|
public static int DeleteHostingPlan(int planId)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsReseller);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
int result = DataProvider.DeleteHostingPlan(SecurityContext.User.UserId, planId);
|
|
if (result == -1)
|
|
return BusinessErrorCodes.ERROR_HOSTING_PLAN_USED_IN_PACKAGE;
|
|
else if (result == -2)
|
|
return BusinessErrorCodes.ERROR_HOSTING_ADDON_USED_IN_PACKAGE;
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Packages
|
|
public static List<PackageInfo> GetMyPackages(int userId)
|
|
{
|
|
List<PackageInfo> packages = new List<PackageInfo>();
|
|
ObjectUtils.FillCollectionFromDataSet<PackageInfo>(packages,
|
|
GetRawMyPackages(userId));
|
|
return packages;
|
|
}
|
|
|
|
public static List<PackageInfo> GetPackages(int userId)
|
|
{
|
|
List<PackageInfo> packages = new List<PackageInfo>();
|
|
ObjectUtils.FillCollectionFromDataSet<PackageInfo>(
|
|
packages, GetRawPackages(userId));
|
|
return packages;
|
|
}
|
|
|
|
public static DataSet GetNestedPackagesSummary(int packageId)
|
|
{
|
|
return DataProvider.GetNestedPackagesSummary(SecurityContext.User.UserId, packageId);
|
|
}
|
|
|
|
public static List<PackageInfo> GetPackagePackages(int packageId, bool recursive)
|
|
{
|
|
List<PackageInfo> packages = new List<PackageInfo>();
|
|
ObjectUtils.FillCollectionFromDataSet<PackageInfo>(
|
|
packages, GetRawPackagePackages(packageId, recursive));
|
|
return packages;
|
|
}
|
|
|
|
public static DataSet GetRawMyPackages(int userId)
|
|
{
|
|
return DataProvider.GetMyPackages(SecurityContext.User.UserId, userId);
|
|
}
|
|
|
|
public static DataSet GetRawPackages(int userId)
|
|
{
|
|
return DataProvider.GetPackages(SecurityContext.User.UserId, userId);
|
|
}
|
|
|
|
public static DataSet GetRawPackagePackages(int packageId, bool recursive)
|
|
{
|
|
return DataProvider.GetPackagePackages(SecurityContext.User.UserId, packageId, recursive);
|
|
}
|
|
|
|
public static DataSet GetPackagesPaged(int userId, string filterColumn, string filterValue,
|
|
string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
return DataProvider.GetPackagesPaged(SecurityContext.User.UserId, userId,
|
|
filterColumn, filterValue, sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static DataSet GetNestedPackagesPaged(int packageId, string filterColumn, string filterValue,
|
|
int statusId, int planId, int serverId, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
return DataProvider.GetNestedPackagesPaged(SecurityContext.User.UserId, packageId,
|
|
filterColumn, filterValue, statusId, planId, serverId, sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static DataSet SearchServiceItemsPaged(int userId, int itemTypeId, string filterValue,
|
|
string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
return DataProvider.SearchServiceItemsPaged(SecurityContext.User.UserId, userId, itemTypeId, filterValue,
|
|
sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static DataSet GetPackageQuotas(int packageId)
|
|
{
|
|
return DataProvider.GetPackageQuotas(SecurityContext.User.UserId, packageId);
|
|
}
|
|
|
|
public static DataSet GetPackageQuotasForEdit(int packageId)
|
|
{
|
|
return DataProvider.GetPackageQuotasForEdit(SecurityContext.User.UserId, packageId);
|
|
}
|
|
|
|
public static PackageInfo GetPackage(int packageId)
|
|
{
|
|
return ObjectUtils.FillObjectFromDataReader<PackageInfo>(
|
|
DataProvider.GetPackage(SecurityContext.User.UserId, packageId));
|
|
}
|
|
|
|
public static PackageContext GetPackageContext(int packageId)
|
|
{
|
|
PackageContext context = new PackageContext();
|
|
|
|
// load package
|
|
context.Package = GetPackage(packageId);
|
|
if (context.Package == null)
|
|
return null;
|
|
|
|
// load groups and quotas
|
|
DataSet ds = GetPackageQuotas(packageId);
|
|
|
|
List<HostingPlanGroupInfo> groups = new List<HostingPlanGroupInfo>();
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
HostingPlanGroupInfo group = new HostingPlanGroupInfo();
|
|
group.GroupId = (int)dr["GroupID"];
|
|
group.GroupName = (string)dr["GroupName"];
|
|
group.Enabled = true;
|
|
group.CalculateBandwidth = (bool)dr["CalculateBandwidth"];
|
|
group.CalculateDiskSpace = (bool)dr["CalculateDiskSpace"];
|
|
groups.Add(group);
|
|
context.Groups.Add(group.GroupName, group);
|
|
}
|
|
|
|
List<QuotaValueInfo> quotas = new List<QuotaValueInfo>();
|
|
foreach (DataRow dr in ds.Tables[1].Rows)
|
|
{
|
|
QuotaValueInfo quota = new QuotaValueInfo();
|
|
quota.QuotaId = (int)dr["QuotaId"];
|
|
quota.GroupId = (int)dr["GroupId"];
|
|
quota.QuotaName = (string)dr["QuotaName"];
|
|
quota.QuotaTypeId = (int)dr["QuotaTypeId"];
|
|
quota.QuotaAllocatedValue = (int)dr["QuotaValue"];
|
|
quota.QuotaUsedValue = (int)dr["QuotaUsedValue"];
|
|
quota.QuotaExhausted = (packageId < 2) || (quota.QuotaAllocatedValue != -1 && quota.QuotaUsedValue >= quota.QuotaAllocatedValue);
|
|
quotas.Add(quota);
|
|
context.Quotas.Add(quota.QuotaName, quota);
|
|
}
|
|
|
|
context.GroupsArray = groups.ToArray();
|
|
context.QuotasArray = quotas.ToArray();
|
|
|
|
return context;
|
|
}
|
|
|
|
public static UserInfo GetPackageOwner(int packageId)
|
|
{
|
|
PackageInfo package = GetPackage(packageId);
|
|
if (package == null)
|
|
return null;
|
|
|
|
return UserController.GetUser(package.UserId);
|
|
}
|
|
|
|
public static PackageResult AddPackageWithResources(int userId, int planId, string spaceName,
|
|
int statusId, bool sendLetter,
|
|
bool createResources, string domainName, bool createInstantAlias, bool createWebSite,
|
|
bool createFtpAccount, string ftpAccountName, bool createMailAccount, string hostName)
|
|
{
|
|
try
|
|
{
|
|
TaskManager.StartTask("HOSTING_SPACE_WR", "ADD", spaceName);
|
|
|
|
PackageResult result = new PackageResult();
|
|
|
|
// check account
|
|
result.Result = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsResellerCSR);
|
|
if (result.Result < 0) return result;
|
|
|
|
// check if domain exists
|
|
result.Result = ServerController.CheckDomain(domainName);
|
|
if (result.Result < 0)
|
|
return result;
|
|
|
|
// load user info
|
|
UserInfo user = UserController.GetUser(userId);
|
|
|
|
if (createFtpAccount)
|
|
{
|
|
// check if FTP account exists
|
|
if (String.IsNullOrEmpty(ftpAccountName))
|
|
ftpAccountName = user.Username;
|
|
|
|
if (FtpServerController.FtpAccountExists(ftpAccountName))
|
|
{
|
|
result.Result = BusinessErrorCodes.ERROR_ACCOUNT_WIZARD_FTP_ACCOUNT_EXISTS;
|
|
return result;
|
|
}
|
|
}
|
|
|
|
// load hosting plan
|
|
HostingPlanInfo plan = PackageController.GetHostingPlan(planId);
|
|
|
|
string packageName = spaceName;
|
|
if (String.IsNullOrEmpty(packageName) || packageName.Trim() == "")
|
|
packageName = plan.PlanName;
|
|
|
|
// create package
|
|
int packageId = -1;
|
|
try
|
|
{
|
|
result = PackageController.AddPackage(
|
|
userId, planId, packageName, "", statusId, DateTime.Now, false);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// error while adding package
|
|
throw ex;
|
|
}
|
|
|
|
if (result.Result < 0)
|
|
return result;
|
|
|
|
packageId = result.Result;
|
|
|
|
// create domain
|
|
if (createResources)
|
|
{
|
|
int domainId = 0;
|
|
if (!String.IsNullOrEmpty(domainName))
|
|
{
|
|
try
|
|
{
|
|
DomainInfo domain = new DomainInfo();
|
|
domain.PackageId = packageId;
|
|
domain.DomainName = domainName;
|
|
domain.HostingAllowed = false;
|
|
domainId = ServerController.AddDomain(domain, false, true);
|
|
if (domainId < 0)
|
|
{
|
|
result.Result = domainId;
|
|
DeletePackage(packageId);
|
|
return result;
|
|
}
|
|
|
|
domain = ServerController.GetDomain(domainId);
|
|
if (domain != null)
|
|
{
|
|
if (domain.ZoneItemId != 0)
|
|
{
|
|
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.Os, domain, "");
|
|
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.Dns, domain, "");
|
|
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.Ftp, domain, "");
|
|
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.MsSql2000, domain, "");
|
|
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.MsSql2005, domain, "");
|
|
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.MsSql2008, domain, "");
|
|
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.MsSql2012, domain, "");
|
|
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.MySql4, domain, "");
|
|
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.MySql5, domain, "");
|
|
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.Statistics, domain, "");
|
|
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.VPS, domain, "");
|
|
ServerController.AddServiceDNSRecords(packageId, ResourceGroups.VPSForPC, domain, "");
|
|
}
|
|
}
|
|
|
|
if (createInstantAlias)
|
|
ServerController.CreateDomainInstantAlias("", domainId);
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// error while adding domain
|
|
DeletePackage(packageId);
|
|
throw new Exception("Could not add domain", ex);
|
|
}
|
|
}
|
|
|
|
if (createWebSite && !String.IsNullOrEmpty(domainName))
|
|
{
|
|
// create web site
|
|
try
|
|
{
|
|
int webSiteId = WebServerController.AddWebSite(packageId, hostName, domainId, 0, createInstantAlias, false);
|
|
if (webSiteId < 0)
|
|
{
|
|
result.Result = webSiteId;
|
|
DeletePackage(packageId);
|
|
return result;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// error while creating web site
|
|
DeletePackage(packageId);
|
|
throw new Exception("Could not create web site", ex);
|
|
}
|
|
}
|
|
|
|
// create FTP account
|
|
if (createFtpAccount)
|
|
{
|
|
try
|
|
{
|
|
FtpAccount ftpAccount = new FtpAccount();
|
|
ftpAccount.PackageId = packageId;
|
|
ftpAccount.Name = ftpAccountName;
|
|
ftpAccount.Password = user.Password;
|
|
ftpAccount.Folder = "\\";
|
|
ftpAccount.CanRead = true;
|
|
ftpAccount.CanWrite = true;
|
|
|
|
int ftpAccountId = FtpServerController.AddFtpAccount(ftpAccount);
|
|
if (ftpAccountId < 0)
|
|
{
|
|
result.Result = ftpAccountId;
|
|
DeletePackage(packageId);
|
|
return result;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// error while creating ftp account
|
|
DeletePackage(packageId);
|
|
throw new Exception("Could not create FTP account", ex);
|
|
}
|
|
}
|
|
|
|
if (createMailAccount && !String.IsNullOrEmpty(domainName))
|
|
{
|
|
// create default mailbox
|
|
try
|
|
{
|
|
// load mail policy
|
|
UserSettings settings = UserController.GetUserSettings(userId, UserSettings.MAIL_POLICY);
|
|
string catchAllName = !String.IsNullOrEmpty(settings["CatchAllName"])
|
|
? settings["CatchAllName"] : "mail";
|
|
|
|
MailAccount mailbox = new MailAccount();
|
|
mailbox.Name = catchAllName + "@" + domainName;
|
|
mailbox.PackageId = packageId;
|
|
|
|
// gather information from the form
|
|
mailbox.Enabled = true;
|
|
|
|
mailbox.ResponderEnabled = false;
|
|
mailbox.ReplyTo = "";
|
|
mailbox.ResponderSubject = "";
|
|
mailbox.ResponderMessage = "";
|
|
|
|
// password
|
|
mailbox.Password = user.Password;
|
|
|
|
// redirection
|
|
mailbox.ForwardingAddresses = new string[] { };
|
|
mailbox.DeleteOnForward = false;
|
|
mailbox.MaxMailboxSize = 0;
|
|
|
|
int mailAccountId = MailServerController.AddMailAccount(mailbox);
|
|
|
|
if (mailAccountId < 0)
|
|
{
|
|
result.Result = mailAccountId;
|
|
DeletePackage(packageId);
|
|
return result;
|
|
}
|
|
|
|
// set catch-all account
|
|
MailDomain mailDomain = MailServerController.GetMailDomain(packageId, domainName);
|
|
mailDomain.CatchAllAccount = catchAllName;
|
|
mailDomain.PostmasterAccount = "mail";
|
|
mailDomain.AbuseAccount = "mail";
|
|
MailServerController.UpdateMailDomain(mailDomain);
|
|
|
|
int mailDomainId = mailDomain.Id;
|
|
|
|
// set mail domain pointer
|
|
// load domain instant alias
|
|
string instantAlias = ServerController.GetDomainAlias(packageId, domainName);
|
|
DomainInfo instantDomain = ServerController.GetDomain(instantAlias);
|
|
if (instantDomain == null || instantDomain.MailDomainId > 0)
|
|
instantAlias = "";
|
|
|
|
if (!String.IsNullOrEmpty(instantAlias))
|
|
MailServerController.AddMailDomainPointer(mailDomainId, instantDomain.DomainId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// error while creating mail account
|
|
DeletePackage(packageId);
|
|
throw new Exception("Could not create mail account", ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
BackgroundTask topTask = TaskController.GetTopTask();
|
|
|
|
topTask.ItemId = userId;
|
|
topTask.UpdateParamValue("SendLetter", sendLetter);
|
|
|
|
TaskController.UpdateTask(topTask);
|
|
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw TaskManager.WriteError(ex);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds hosting package(space) to the user.
|
|
/// </summary>
|
|
/// <remarks>Added as a part of #1084 item fix.</remarks>
|
|
/// <param name="userId">User id</param>
|
|
/// <param name="planId">Hosting plan id</param>
|
|
/// <param name="packageName">Hosting package(space) name</param>
|
|
/// <param name="packageComments">Hosting package(space) comments</param>
|
|
/// <param name="statusId">Hosting package(space) initial status</param>
|
|
/// <param name="purchaseDate">Date purchased</param>
|
|
/// <param name="sendLetter">Inidicates whether to send e-mail notification or not</param>
|
|
/// <returns>Hosting package(space) creation result</returns>
|
|
public static PackageResult AddPackage(int userId, int planId, string packageName,
|
|
string packageComments, int statusId, DateTime purchaseDate, bool sendLetter)
|
|
{
|
|
return AddPackage(userId, planId, packageName, packageComments, statusId, purchaseDate,
|
|
sendLetter, false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds hosting package(space) to the user.
|
|
/// </summary>
|
|
/// <remarks>Modified as a fix for #1084 item.</remarks>
|
|
/// <param name="userId">User id</param>
|
|
/// <param name="planId">Hosting plan id</param>
|
|
/// <param name="packageName">Hosting package(space) name</param>
|
|
/// <param name="packageComments">Hosting package(space) comments</param>
|
|
/// <param name="statusId">Hosting package(space) initial status</param>
|
|
/// <param name="purchaseDate">Date purchased</param>
|
|
/// <param name="sendLetter">Inidicates whether to send e-mail notification or not</param>
|
|
/// <param name="signup">Used for external clients to set #Signup# variable in e-mail notification template</param>
|
|
/// <returns>Hosting package(space) creation result</returns>
|
|
public static PackageResult AddPackage(int userId, int planId, string packageName,
|
|
string packageComments, int statusId, DateTime purchaseDate, bool sendLetter, bool signup)
|
|
{
|
|
TaskManager.StartTask("HOSTING_SPACE", "ADD", packageName);
|
|
|
|
PackageResult result = new PackageResult();
|
|
|
|
try
|
|
{
|
|
// check account
|
|
result.Result = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsResellerCSR);
|
|
if (result.Result < 0) return result;
|
|
|
|
int packageId = -1;
|
|
|
|
result.ExceedingQuotas = DataProvider.AddPackage(SecurityContext.User.UserId, out packageId,
|
|
userId, planId, packageName, packageComments, statusId, purchaseDate);
|
|
|
|
if (result.ExceedingQuotas.Tables[0].Rows.Count > 0)
|
|
{
|
|
result.Result = BusinessErrorCodes.ERROR_PACKAGE_QUOTA_EXCEED;
|
|
return result;
|
|
}
|
|
|
|
result.Result = packageId;
|
|
|
|
// allocate "Web Sites" IP addresses
|
|
int webServiceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.Web);
|
|
StringDictionary webSettings = ServerController.GetServiceSettings(webServiceId);
|
|
if (Utils.ParseBool(webSettings["AutoAssignDedicatedIP"], true))
|
|
ServerController.AllocateMaximumPackageIPAddresses(packageId, ResourceGroups.Web, IPAddressPool.WebSites);
|
|
|
|
// allocate "VPS" IP addresses
|
|
int vpsServiceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.VPS);
|
|
StringDictionary vpsSettings = ServerController.GetServiceSettings(vpsServiceId);
|
|
if (Utils.ParseBool(vpsSettings["AutoAssignExternalIP"], true))
|
|
ServerController.AllocateMaximumPackageIPAddresses(packageId, ResourceGroups.VPS, IPAddressPool.VpsExternalNetwork);
|
|
|
|
|
|
// allocate "VPSForPC" IP addresses
|
|
int vpsfcpServiceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.VPSForPC);
|
|
StringDictionary vpfcpsSettings = ServerController.GetServiceSettings(vpsfcpServiceId);
|
|
if (Utils.ParseBool(vpfcpsSettings["AutoAssignExternalIP"], true))
|
|
ServerController.AllocateMaximumPackageIPAddresses(packageId, ResourceGroups.VPSForPC, IPAddressPool.VpsExternalNetwork);
|
|
|
|
// load hosting plan
|
|
HostingPlanInfo plan = GetHostingPlan(planId);
|
|
|
|
// create home folder
|
|
int homeId = CreatePackageHome(plan.PackageId, packageId, userId);
|
|
if (homeId < 0)
|
|
result.Result = homeId;
|
|
|
|
BackgroundTask topTask = TaskController.GetTopTask();
|
|
|
|
topTask.ItemId = userId;
|
|
topTask.UpdateParamValue("Signup", signup);
|
|
topTask.UpdateParamValue("UserId", userId);
|
|
topTask.UpdateParamValue("SendLetter", sendLetter);
|
|
|
|
TaskController.UpdateTask(topTask);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static PackageResult UpdatePackage(PackageInfo package)
|
|
{
|
|
TaskManager.StartTask("HOSTING_SPACE", "UPDATE", package.PackageName);
|
|
|
|
PackageResult result = new PackageResult();
|
|
|
|
try
|
|
{
|
|
// check account
|
|
result.Result = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsReseller);
|
|
|
|
if (result.Result < 0)
|
|
result.Result = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsPlatformCSR);
|
|
|
|
if (result.Result < 0)
|
|
result.Result = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsResellerCSR);
|
|
|
|
if (result.Result < 0) return result;
|
|
|
|
// load package
|
|
PackageInfo originalPackage = GetPackage(package.PackageId);
|
|
if (originalPackage == null)
|
|
{
|
|
result.Result = BusinessErrorCodes.ERROR_PACKAGE_NOT_FOUND;
|
|
return result;
|
|
}
|
|
|
|
string quotasXml = BuildPlanQuotasXml(package.Groups, package.Quotas);
|
|
|
|
// update package
|
|
result.ExceedingQuotas = DataProvider.UpdatePackage(SecurityContext.User.UserId,
|
|
package.PackageId, package.PlanId, package.PackageName, package.PackageComments, package.StatusId,
|
|
package.PurchaseDate, package.OverrideQuotas, quotasXml);
|
|
|
|
if (result.ExceedingQuotas.Tables[0].Rows.Count > 0)
|
|
result.Result = BusinessErrorCodes.ERROR_PACKAGE_QUOTA_EXCEED;
|
|
|
|
// Update the Hard quota on home folder in case it was enabled and in case there was a change in disk space
|
|
UpdatePackageHardQuota(package.PackageId);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static int UpdatePackageName(int packageId, string packageName,
|
|
string packageComments)
|
|
{
|
|
int result = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (result < 0) return result;
|
|
|
|
DataProvider.UpdatePackageName(SecurityContext.User.UserId, packageId, packageName, packageComments);
|
|
|
|
return 0;
|
|
}
|
|
|
|
public static int DeletePackage(int packageId)
|
|
{
|
|
return DeletePackage(null, packageId);
|
|
}
|
|
|
|
public static int DeletePackage(string taskId, int packageId)
|
|
{
|
|
TaskManager.StartTask(taskId, "HOSTING_SPACE", "DELETE", packageId);
|
|
|
|
try
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsReseller);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// check if package has child packages
|
|
if (GetPackagePackages(packageId, true).Count > 0)
|
|
return BusinessErrorCodes.ERROR_PACKAGE_HAS_PACKAGES;
|
|
|
|
// load "root" package
|
|
PackageInfo package = GetPackage(packageId);
|
|
if (package == null)
|
|
return BusinessErrorCodes.ERROR_PACKAGE_NOT_FOUND;
|
|
|
|
// add "root" package
|
|
List<PackageInfo> packages = new List<PackageInfo>();
|
|
packages.Add(package);
|
|
|
|
// delete packages
|
|
DeletePackages(packages);
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
public static int DeletePackages(List<PackageInfo> packages)
|
|
{
|
|
// delete packages asynchronously
|
|
PackageAsyncWorker packageWorker = new PackageAsyncWorker();
|
|
packageWorker.UserId = SecurityContext.User.UserId;
|
|
packageWorker.Packages = packages;
|
|
|
|
// invoke worker
|
|
packageWorker.DeletePackagesServiceItemsAsync();
|
|
|
|
return 0;
|
|
}
|
|
|
|
public static int ChangePackageStatus(int packageId, PackageStatus status, bool async)
|
|
{
|
|
return ChangePackageStatus(null, packageId, status, async);
|
|
}
|
|
|
|
public static int ChangePackageStatus(string taskId, int packageId, PackageStatus status, bool async)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsResellerCSR);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
List<PackageInfo> packages = new List<PackageInfo>();
|
|
|
|
// load package
|
|
PackageInfo package = GetPackage(packageId);
|
|
if (package == null)
|
|
return -1;
|
|
|
|
// add "root" package
|
|
packages.Add(package);
|
|
|
|
// add "child" packages
|
|
packages.AddRange(GetPackagePackages(packageId, true));
|
|
|
|
// change packages status
|
|
ChangePackagesStatus(packages, status, async);
|
|
|
|
return 0;
|
|
}
|
|
|
|
public static int ChangePackagesStatus(List<PackageInfo> packages, PackageStatus status, bool async)
|
|
{
|
|
int statusId = (int)status;
|
|
|
|
List<PackageInfo> changedPackages = new List<PackageInfo>();
|
|
foreach (PackageInfo p in packages)
|
|
{
|
|
// get package details
|
|
PackageInfo package = GetPackage(p.PackageId);
|
|
if (package != null && package.StatusId != statusId)
|
|
{
|
|
bool currEnabled = (package.StatusId == (int)PackageStatus.Active);
|
|
bool enabled = (statusId == (int)PackageStatus.Active);
|
|
|
|
// change package status
|
|
package.StatusId = statusId;
|
|
|
|
// save package
|
|
UpdatePackage(package);
|
|
|
|
// add to the list of affected packages
|
|
if (currEnabled != enabled)
|
|
changedPackages.Add(package);
|
|
}
|
|
}
|
|
|
|
// change service items state asynchronously
|
|
PackageAsyncWorker packageWorker = new PackageAsyncWorker();
|
|
packageWorker.UserId = SecurityContext.User.UserId;
|
|
packageWorker.Packages = changedPackages;
|
|
packageWorker.ItemsStatus = status;
|
|
|
|
// invoke worker
|
|
if (async)
|
|
packageWorker.ChangePackagesServiceItemsStateAsync();
|
|
else
|
|
packageWorker.ChangePackagesServiceItemsState();
|
|
|
|
return 0;
|
|
}
|
|
|
|
private static int CreatePackageHome(int resellerPackageId, int packageId, int userId)
|
|
{
|
|
// request OS service
|
|
int osId = GetPackageServiceId(packageId, ResourceGroups.Os);
|
|
if (osId == 0)
|
|
return 0;
|
|
//return BusinessErrorCodes.ERROR_OS_RESOURCE_UNAVAILABLE;
|
|
|
|
// load user details
|
|
UserInfo user = UserController.GetUser(userId);
|
|
|
|
// load package
|
|
string initialPath = null;
|
|
|
|
// load package settings
|
|
PackageSettings packageSettings = PackageController.GetPackageSettings(packageId,
|
|
PackageSettings.SPACES_FOLDER);
|
|
|
|
if (!String.IsNullOrEmpty(packageSettings["ChildSpacesFolder"]))
|
|
{
|
|
initialPath = Path.Combine(
|
|
FilesController.GetFullPackagePath(resellerPackageId, packageSettings["ChildSpacesFolder"]),
|
|
user.Username);
|
|
|
|
}
|
|
else
|
|
{
|
|
// load service settings
|
|
StringDictionary osSesstings = ServerController.GetServiceSettings(osId);
|
|
|
|
// build initial path
|
|
string usersHome = osSesstings["UsersHome"];
|
|
if (!usersHome.EndsWith("\\"))
|
|
usersHome += '\\';
|
|
|
|
initialPath = Path.Combine(usersHome, user.Username);
|
|
}
|
|
|
|
OS.OperatingSystem os = new OS.OperatingSystem();
|
|
ServiceProviderProxy.Init(os, osId);
|
|
string path = os.CreatePackageFolder(initialPath);
|
|
|
|
// store home folder info
|
|
HomeFolder homeFolder = new HomeFolder();
|
|
homeFolder.ServiceId = osId;
|
|
homeFolder.PackageId = packageId;
|
|
homeFolder.Name = path;
|
|
|
|
// Added By Haya
|
|
UpdatePackageHardQuota(packageId);
|
|
|
|
// save package item
|
|
return AddPackageItem(homeFolder);
|
|
}
|
|
|
|
public static DateTime GetPackageBandwidthUpdate(int packageId)
|
|
{
|
|
return DataProvider.GetPackageBandwidthUpdate(packageId);
|
|
}
|
|
|
|
public static void UpdatePackageBandwidthUpdate(int packageId, DateTime updateDate)
|
|
{
|
|
DataProvider.UpdatePackageBandwidthUpdate(packageId, updateDate);
|
|
}
|
|
|
|
// This gets the system quota and updates the home folder with the value
|
|
public static void UpdatePackageHardQuota(int packageId)
|
|
{
|
|
// request OS service
|
|
int osId = GetPackageServiceId(packageId, ResourceGroups.Os);
|
|
if (osId == 0)
|
|
return;
|
|
|
|
OS.OperatingSystem os = new OS.OperatingSystem();
|
|
ServiceProviderProxy.Init(os, osId);
|
|
|
|
//Get operating system settings
|
|
StringDictionary osSesstings = ServerController.GetServiceSettings(osId);
|
|
bool diskQuotaEnabled = (osSesstings["EnableHardQuota"] != null) ? bool.Parse(osSesstings["EnableHardQuota"]) : false;
|
|
string driveName = osSesstings["LocationDrive"];
|
|
|
|
if (!diskQuotaEnabled)
|
|
return;
|
|
|
|
string homeFolder = FilesController.GetHomeFolder(packageId);
|
|
FilesController.SetFolderQuota(packageId, homeFolder, driveName);
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Package Add-ons
|
|
public static DataSet GetPackageAddons(int packageId)
|
|
{
|
|
return DataProvider.GetPackageAddons(SecurityContext.User.UserId, packageId);
|
|
}
|
|
|
|
public static PackageAddonInfo GetPackageAddon(int packageAddonId)
|
|
{
|
|
return ObjectUtils.FillObjectFromDataReader<PackageAddonInfo>(
|
|
DataProvider.GetPackageAddon(SecurityContext.User.UserId, packageAddonId));
|
|
}
|
|
|
|
public static PackageResult AddPackageAddonById(int packageId, int addonPlanId, int quantity)
|
|
{
|
|
PackageAddonInfo addon = new PackageAddonInfo();
|
|
addon.PackageId = packageId;
|
|
addon.PlanId = addonPlanId;
|
|
addon.Quantity = quantity;
|
|
addon.PurchaseDate = DateTime.Now;
|
|
addon.StatusId = 1; // active
|
|
addon.Comments = "";
|
|
|
|
return AddPackageAddon(addon);
|
|
}
|
|
|
|
public static PackageResult AddPackageAddon(PackageAddonInfo addon)
|
|
{
|
|
PackageResult result = new PackageResult();
|
|
|
|
// check account
|
|
result.Result = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsReseller);
|
|
|
|
if (result.Result < 0)
|
|
result.Result = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsPlatformCSR);
|
|
|
|
if (result.Result < 0)
|
|
result.Result = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsResellerCSR);
|
|
|
|
if (result.Result < 0) return result;
|
|
|
|
int addonId = 0;
|
|
|
|
result.ExceedingQuotas = DataProvider.AddPackageAddon(SecurityContext.User.UserId, out addonId, addon.PackageId,
|
|
addon.PlanId, addon.Quantity, addon.StatusId, addon.PurchaseDate, addon.Comments);
|
|
|
|
if (result.ExceedingQuotas.Tables[0].Rows.Count > 0)
|
|
{
|
|
result.Result = BusinessErrorCodes.ERROR_PACKAGE_QUOTA_EXCEED;
|
|
return result;
|
|
}
|
|
|
|
result.Result = addonId;
|
|
|
|
// Update the Hard quota on home folder in case it was enabled and in case there was a change in disk space
|
|
UpdatePackageHardQuota(addon.PackageId);
|
|
return result;
|
|
}
|
|
|
|
public static PackageResult UpdatePackageAddon(PackageAddonInfo addon)
|
|
{
|
|
PackageResult result = new PackageResult();
|
|
|
|
// check account
|
|
result.Result = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsReseller);
|
|
|
|
if (result.Result < 0)
|
|
result.Result = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsPlatformCSR);
|
|
|
|
if (result.Result < 0)
|
|
result.Result = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsResellerCSR);
|
|
|
|
if (result.Result < 0) return result;
|
|
|
|
result.ExceedingQuotas = DataProvider.UpdatePackageAddon(SecurityContext.User.UserId, addon.PackageAddonId,
|
|
addon.PlanId, addon.Quantity, addon.StatusId, addon.PurchaseDate, addon.Comments);
|
|
|
|
if (result.ExceedingQuotas.Tables[0].Rows.Count > 0)
|
|
result.Result = BusinessErrorCodes.ERROR_PACKAGE_QUOTA_EXCEED;
|
|
|
|
// Update the Hard quota on home folder in case it was enabled and in case there was a change in disk space
|
|
UpdatePackageHardQuota(addon.PackageId);
|
|
|
|
return result;
|
|
}
|
|
|
|
public static int DeletePackageAddon(int packageAddonId)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsReseller);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
|
|
// Update the Hard quota on home folder in case it was enabled and in case there was a change in disk space
|
|
UpdatePackageHardQuota(GetPackageAddon(packageAddonId).PackageId);
|
|
|
|
DataProvider.DeletePackageAddon(SecurityContext.User.UserId, packageAddonId);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Package Items
|
|
public static DataSet GetSearchableServiceItemTypes()
|
|
{
|
|
return DataProvider.GetSearchableServiceItemTypes();
|
|
}
|
|
|
|
public static int GetPackageServiceId(int packageId, string groupName)
|
|
{
|
|
return DataProvider.GetPackageServiceId(SecurityContext.User.UserId, packageId, groupName);
|
|
}
|
|
|
|
public static List<ServiceProviderItem> GetPackageItemsByName(int packageId, string itemName)
|
|
{
|
|
DataSet dsItems = DataProvider.GetServiceItemsByName(
|
|
SecurityContext.User.UserId, packageId, itemName);
|
|
|
|
return CreateServiceItemsList(dsItems, 0);
|
|
}
|
|
|
|
public static List<ServiceProviderItem> GetPackageItemsByType(int packageId, string groupName, Type itemType)
|
|
{
|
|
return GetPackageItemsByType(packageId, groupName, itemType, false);
|
|
}
|
|
|
|
public static List<ServiceProviderItem> GetPackageItemsByType(int packageId, Type itemType)
|
|
{
|
|
return GetPackageItemsByType(packageId, null, itemType, false);
|
|
}
|
|
|
|
public static List<ServiceProviderItem> GetPackageItemsByType(int packageId, Type itemType, bool recursive)
|
|
{
|
|
return GetPackageItemsByType(packageId, null, itemType, recursive);
|
|
}
|
|
|
|
public static List<ServiceProviderItem> GetPackageItemsByType(int packageId, string groupName, Type itemType, bool recursive)
|
|
{
|
|
string typeName = ObjectUtils.GetTypeFullName(itemType);
|
|
DataSet dsItems = DataProvider.GetServiceItems(SecurityContext.User.UserId,
|
|
packageId, groupName, typeName, recursive);
|
|
|
|
return CreateServiceItemsList(dsItems, 0);
|
|
}
|
|
|
|
public static List<ServiceProviderItem> GetPackageItemsByTypeInternal(int packageId, string groupName, Type itemType, bool recursive)
|
|
{
|
|
string typeName = ObjectUtils.GetTypeFullName(itemType);
|
|
DataSet dsItems = DataProvider.GetServiceItems(-1, packageId, groupName, typeName, recursive);
|
|
|
|
return CreateServiceItemsList(dsItems, 0);
|
|
}
|
|
|
|
public static DataSet GetRawPackageItemsByType(int packageId, Type itemType, bool recursive)
|
|
{
|
|
return GetRawPackageItemsByType(packageId, null, itemType, recursive);
|
|
}
|
|
|
|
public static DataSet GetRawPackageItemsByType(int packageId, string groupName, Type itemType, bool recursive)
|
|
{
|
|
string typeName = ObjectUtils.GetTypeFullName(itemType);
|
|
DataSet dsItems = DataProvider.GetServiceItems(SecurityContext.User.UserId,
|
|
packageId, groupName, typeName, recursive);
|
|
|
|
FlatternItemsTable(dsItems, 0, itemType);
|
|
|
|
return dsItems;
|
|
}
|
|
|
|
public static ServiceItemsPaged GetPackageItemsPaged(int packageId, Type itemType,
|
|
string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
return GetPackageItemsPaged(packageId, null, itemType, false, filterColumn, filterValue,
|
|
sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static ServiceItemsPaged GetPackageItemsPaged(int packageId, Type itemType, bool recursive,
|
|
string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
return GetPackageItemsPaged(packageId, null, itemType, recursive, filterColumn, filterValue,
|
|
sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static DataSet GetRawPackageItemsPaged(int packageId, Type itemType, bool recursive,
|
|
string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
return GetRawPackageItemsPaged(packageId, null, itemType, recursive, filterColumn, filterValue,
|
|
sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static ServiceItemsPaged GetPackageItemsPaged(int packageId, string groupName, Type itemType,
|
|
string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
return GetPackageItemsPaged(packageId, groupName, itemType, false, filterColumn, filterValue,
|
|
sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static ServiceItemsPaged GetPackageItemsPaged(int packageId, string groupName, Type itemType, bool recursive,
|
|
string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
|
|
{
|
|
string typeName = ObjectUtils.GetTypeFullName(itemType);
|
|
DataSet dsItems = DataProvider.GetServiceItemsPaged(
|
|
SecurityContext.User.UserId, packageId, groupName, typeName, 0, recursive, filterColumn, filterValue,
|
|
sortColumn, startRow, maximumRows);
|
|
|
|
ServiceItemsPaged result = new ServiceItemsPaged();
|
|
result.RecordsCount = (int)dsItems.Tables[0].Rows[0][0];
|
|
result.PageItems = CreateServiceItemsList(dsItems, 1).ToArray();
|
|
return result;
|
|
}
|
|
|
|
public static DataSet GetRawPackageItemsPaged(int packageId, string groupName, Type itemType,
|
|
bool recursive, string filterColumn, string filterValue, string sortColumn,
|
|
int startRow, int maximumRows)
|
|
{
|
|
return GetRawPackageItemsPaged(packageId, groupName, itemType, 0, recursive, filterColumn, filterValue,
|
|
sortColumn, startRow, maximumRows);
|
|
}
|
|
|
|
public static DataSet GetRawPackageItemsPaged(int packageId, string groupName, Type itemType,
|
|
int serverId, bool recursive, string filterColumn, string filterValue, string sortColumn,
|
|
int startRow, int maximumRows)
|
|
{
|
|
string typeName = ObjectUtils.GetTypeFullName(itemType);
|
|
DataSet dsItems = DataProvider.GetServiceItemsPaged(
|
|
SecurityContext.User.UserId, packageId, groupName, typeName, serverId, recursive, filterColumn, filterValue,
|
|
sortColumn, startRow, maximumRows);
|
|
|
|
FlatternItemsTable(dsItems, 1, itemType);
|
|
|
|
return dsItems;
|
|
}
|
|
|
|
public static int GetServiceItemsCount(Type itemType, string groupName)
|
|
{
|
|
return GetServiceItemsCount(itemType, groupName, 0);
|
|
}
|
|
|
|
public static int GetServiceItemsCount(Type itemType, string groupName, int serviceId)
|
|
{
|
|
string typeName = ObjectUtils.GetTypeFullName(itemType);
|
|
return DataProvider.GetServiceItemsCount(typeName, groupName, serviceId);
|
|
}
|
|
|
|
public static DataSet GetPackageItemsDataSet(int packageId)
|
|
{
|
|
return DataProvider.GetServiceItemsByPackage(SecurityContext.User.UserId,
|
|
packageId);
|
|
}
|
|
|
|
public static List<ServiceProviderItem> GetPackageItems(int packageId)
|
|
{
|
|
DataSet dsItems = GetPackageItemsDataSet(packageId);
|
|
return CreateServiceItemsList(dsItems, 0);
|
|
}
|
|
|
|
public static DataSet GetRawPackageItems(int packageId)
|
|
{
|
|
return DataProvider.GetServiceItemsByPackage(SecurityContext.User.UserId,
|
|
packageId);
|
|
}
|
|
|
|
public static DataSet GetServiceItemsDataSet(int serviceId)
|
|
{
|
|
return DataProvider.GetServiceItemsByService(SecurityContext.User.UserId,
|
|
serviceId);
|
|
}
|
|
|
|
public static List<ServiceProviderItem> GetServiceItems(int serviceId)
|
|
{
|
|
DataSet dsItems = GetServiceItemsDataSet(serviceId);
|
|
return CreateServiceItemsList(dsItems, 0);
|
|
}
|
|
|
|
public static List<ServiceProviderItemType> GetServiceItemTypes()
|
|
{
|
|
return ObjectUtils.CreateListFromDataReader<ServiceProviderItemType>(
|
|
DataProvider.GetServiceItemTypes());
|
|
}
|
|
|
|
public static ServiceProviderItemType GetServiceItemType(int itemTypeId)
|
|
{
|
|
return ObjectUtils.FillObjectFromDataReader<ServiceProviderItemType>(
|
|
DataProvider.GetServiceItemType(itemTypeId));
|
|
}
|
|
|
|
public static List<ServiceProviderItem> GetServiceItemsForStatistics(int serviceId, int packageId,
|
|
bool calculateDiskspace, bool calculateBandwidth, bool suspendable, bool disposable)
|
|
{
|
|
DataSet dsItems = DataProvider.GetServiceItemsForStatistics(SecurityContext.User.UserId,
|
|
serviceId, packageId, calculateDiskspace, calculateBandwidth, suspendable, disposable);
|
|
return CreateServiceItemsList(dsItems, 0);
|
|
}
|
|
|
|
public static ServiceProviderItem GetPackageItem(int itemId)
|
|
{
|
|
DataSet dsItem = DataProvider.GetServiceItem(SecurityContext.User.UserId, itemId);
|
|
DataView dvItem = dsItem.Tables[0].DefaultView;
|
|
if (dvItem.Count == 0)
|
|
return null;
|
|
|
|
return CreateServiceItem(dvItem[0], dsItem.Tables[1].DefaultView);
|
|
}
|
|
|
|
public static ServiceProviderItem GetPackageItemByName(int packageId, string itemName, Type itemType)
|
|
{
|
|
return GetPackageItemByName(packageId, null, itemName, itemType);
|
|
}
|
|
|
|
public static ServiceProviderItem GetPackageItemByName(int packageId, string groupName, string itemName, Type itemType)
|
|
{
|
|
string itemTypeName = ObjectUtils.GetTypeFullName(itemType);
|
|
DataSet dsItem = DataProvider.GetServiceItemByName(SecurityContext.User.UserId,
|
|
packageId, groupName, itemName, itemTypeName);
|
|
DataView dvItem = dsItem.Tables[0].DefaultView;
|
|
if (dvItem.Count == 0)
|
|
return null;
|
|
|
|
return CreateServiceItem(dvItem[0], dsItem.Tables[1].DefaultView);
|
|
}
|
|
|
|
public static bool CheckServiceItemExists(string itemName, Type itemType)
|
|
{
|
|
return CheckServiceItemExists(itemName, null, itemType);
|
|
}
|
|
|
|
public static bool CheckServiceItemExists(string itemName, string groupName, Type itemType)
|
|
{
|
|
string itemTypeName = ObjectUtils.GetTypeFullName(itemType);
|
|
return DataProvider.CheckServiceItemExists(itemName, groupName, itemTypeName);
|
|
}
|
|
|
|
public static bool CheckServiceItemExists(int serviceId, string itemName, Type itemType)
|
|
{
|
|
string itemTypeName = ObjectUtils.GetTypeFullName(itemType);
|
|
return DataProvider.CheckServiceItemExists(serviceId, itemName, itemTypeName);
|
|
}
|
|
|
|
public static int AddPackageItem(ServiceProviderItem item)
|
|
{
|
|
// check parameters
|
|
if (item.PackageId < 0)
|
|
throw new ArgumentException("item.PackageId property value should be specified!");
|
|
|
|
if (item.ServiceId < 0)
|
|
throw new ArgumentException("item.ServiceId property value should be specified!");
|
|
|
|
string itemTypeName = ObjectUtils.GetTypeFullName(item.GetType());
|
|
|
|
// build properties xml
|
|
string xml = BuildPropertiesXml(ObjectUtils.GetObjectProperties(item, true));
|
|
|
|
// add item itself
|
|
int itemId = DataProvider.AddServiceItem(SecurityContext.User.UserId,
|
|
item.ServiceId, item.PackageId, item.Name,
|
|
itemTypeName, xml);
|
|
|
|
return itemId;
|
|
}
|
|
|
|
public static int UpdatePackageItem(ServiceProviderItem item)
|
|
{
|
|
// build properties xml
|
|
string xml = BuildPropertiesXml(ObjectUtils.GetObjectProperties(item, true));
|
|
|
|
// update item
|
|
DataProvider.UpdateServiceItem(SecurityContext.User.UserId, item.Id, item.Name, xml);
|
|
|
|
return 0;
|
|
}
|
|
|
|
private static string BuildPropertiesXml(Hashtable props)
|
|
{
|
|
XmlDocument doc = new XmlDocument();
|
|
XmlElement nodeProps = doc.CreateElement("properties");
|
|
foreach (string propertyName in props.Keys)
|
|
{
|
|
XmlElement nodeProp = doc.CreateElement("property");
|
|
nodeProp.SetAttribute("name", propertyName);
|
|
nodeProp.SetAttribute("value", props[propertyName].ToString());
|
|
nodeProps.AppendChild(nodeProp);
|
|
}
|
|
return nodeProps.OuterXml;
|
|
}
|
|
|
|
public static int DetachPackageItem(int itemId)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsAdmin);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// HACK: Mail accounts detach is hard coded.
|
|
MailDomain mailDomain = GetPackageItem(itemId) as MailDomain;
|
|
if (mailDomain != null)
|
|
{
|
|
// Load accounts and detach them as well.
|
|
List<ServiceProviderItem> accounts = GetPackageItemsByName(mailDomain.PackageId, "%@" + mailDomain.Name);
|
|
foreach (ServiceProviderItem account in accounts)
|
|
{
|
|
DetachPackageItem(account.Id);
|
|
}
|
|
}
|
|
|
|
DeletePackageItem(itemId);
|
|
|
|
return 0;
|
|
}
|
|
|
|
public static int MovePackageItem(int itemId, int destinationServiceId)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
|
|
| DemandAccount.IsAdmin);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// move item
|
|
DataProvider.MoveServiceItem(SecurityContext.User.UserId, itemId, destinationServiceId);
|
|
|
|
return 0;
|
|
}
|
|
|
|
public static int DeletePackageItem(int itemId)
|
|
{
|
|
// delete item
|
|
DataProvider.DeleteServiceItem(SecurityContext.User.UserId, itemId);
|
|
|
|
return 0;
|
|
}
|
|
|
|
public static int UpdatePackageBandwidth(int packageId, string xml)
|
|
{
|
|
DataProvider.UpdatePackageBandwidth(packageId, xml);
|
|
return 0;
|
|
}
|
|
|
|
public static int UpdatePackageDiskSpace(int packageId, string xml)
|
|
{
|
|
DataProvider.UpdatePackageDiskSpace(packageId, xml);
|
|
return 0;
|
|
}
|
|
|
|
public static List<ServiceProviderItem> CreateServiceItemsList(DataSet dsItems, int itemsTablePosition)
|
|
{
|
|
List<ServiceProviderItem> items = new List<ServiceProviderItem>();
|
|
|
|
DataView dvItems = dsItems.Tables[itemsTablePosition].DefaultView;
|
|
foreach (DataRowView drItem in dvItems)
|
|
{
|
|
DataView dvProps = new DataView(dsItems.Tables[itemsTablePosition + 1], "ItemID=" + drItem["ItemID"].ToString(),
|
|
"", DataViewRowState.CurrentRows);
|
|
items.Add(CreateServiceItem(drItem, dvProps));
|
|
}
|
|
|
|
return items;
|
|
}
|
|
|
|
|
|
private static ServiceProviderItem CreateServiceItem(DataRowView drItem, DataView dvProps)
|
|
{
|
|
// create item instance
|
|
string itemTypeName = (string)drItem["TypeName"];
|
|
Type itemType = Type.GetType(itemTypeName);
|
|
|
|
if (itemType == null)
|
|
itemType = typeof(ServiceProviderItem); // create generic item
|
|
|
|
// create item instance and fill other properties
|
|
ServiceProviderItem item = (ServiceProviderItem)ObjectUtils.CreateObjectFromDataview(
|
|
Type.GetType(itemTypeName), dvProps, "PropertyName", "PropertyValue", true);
|
|
|
|
// fill item key properties
|
|
item.Id = (int)drItem["ItemID"];
|
|
item.TypeId = (int)drItem["ItemTypeID"];
|
|
item.Name = (string)drItem["ItemName"];
|
|
item.PackageId = (int)drItem["PackageID"];
|
|
item.ServiceId = (int)drItem["ServiceID"];
|
|
item.GroupName = (string)drItem["GroupName"];
|
|
item.CreatedDate = Utils.ParseDate(drItem["CreatedDate"]);
|
|
|
|
return item;
|
|
}
|
|
|
|
private static void FlatternItemsTable(DataSet dsItems, int itemsTablePosition, Type itemType)
|
|
{
|
|
DataTable dtItems = dsItems.Tables[itemsTablePosition];
|
|
DataTable dtProps = dsItems.Tables[itemsTablePosition + 1];
|
|
|
|
// add columns to the table
|
|
PropertyInfo[] props = itemType.GetProperties(BindingFlags.Instance | BindingFlags.Public);
|
|
foreach (PropertyInfo prop in props)
|
|
{
|
|
if (!dtItems.Columns.Contains(prop.Name) && !prop.PropertyType.IsArray)
|
|
dtItems.Columns.Add(prop.Name, prop.PropertyType);
|
|
}
|
|
|
|
foreach (DataRow drItem in dtItems.Rows)
|
|
{
|
|
DataView dvProps = new DataView(dtProps, "ItemID=" + drItem["ItemID"].ToString(),
|
|
"", DataViewRowState.CurrentRows);
|
|
|
|
foreach (DataRowView drProp in dvProps)
|
|
{
|
|
object propValue = "";
|
|
string sVal = (drProp["PropertyValue"] != DBNull.Value) ? drProp["PropertyValue"].ToString() : "";
|
|
string columnName = drProp["PropertyName"].ToString();
|
|
|
|
if (!dtItems.Columns.Contains(columnName))
|
|
continue;
|
|
|
|
Type columnType = dtItems.Columns[columnName].DataType;
|
|
if (columnType == typeof(string))
|
|
propValue = sVal;
|
|
if (columnType == typeof(int))
|
|
propValue = (sVal != "") ? Int32.Parse(sVal) : 0;
|
|
if (columnType == typeof(long))
|
|
propValue = (sVal != "") ? Int64.Parse(sVal) : 0;
|
|
if (columnType == typeof(bool))
|
|
propValue = (sVal != "") ? Boolean.Parse(sVal) : false;
|
|
if (columnType == typeof(Guid))
|
|
propValue = (!string.IsNullOrEmpty(sVal)) ? new Guid(sVal) : Guid.Empty;
|
|
|
|
drItem[columnName] = propValue;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Package Settings
|
|
public static PackageSettings GetPackageSettings(int packageId, string settingsName)
|
|
{
|
|
IDataReader reader = DataProvider.GetPackageSettings(
|
|
SecurityContext.User.UserId, packageId, settingsName);
|
|
|
|
PackageSettings settings = new PackageSettings();
|
|
settings.PackageId = packageId;
|
|
settings.SettingsName = settingsName;
|
|
|
|
while (reader.Read())
|
|
{
|
|
settings.PackageId = (int)reader["PackageID"];
|
|
settings[(string)reader["PropertyName"]] = (string)reader["PropertyValue"];
|
|
}
|
|
reader.Close();
|
|
|
|
// set root settings if required
|
|
if (settings.PackageId < 2)
|
|
{
|
|
// instant alias
|
|
if (String.Compare(PackageSettings.INSTANT_ALIAS, settingsName, true) == 0)
|
|
{
|
|
// load package info
|
|
PackageInfo package = GetPackage(packageId);
|
|
|
|
// load package server
|
|
ServerInfo srv = ServerController.GetServerByIdInternal(package.ServerId);
|
|
if (srv != null)
|
|
settings["InstantAlias"] = srv.InstantDomainAlias;
|
|
}
|
|
|
|
// name servers
|
|
else if (String.Compare(PackageSettings.NAME_SERVERS, settingsName, true) == 0)
|
|
{
|
|
// load DNS service settings
|
|
int dnsServiceId = GetPackageServiceId(packageId, ResourceGroups.Dns);
|
|
if (dnsServiceId > 0)
|
|
{
|
|
StringDictionary dnsSettings = ServerController.GetServiceSettings(dnsServiceId);
|
|
settings["NameServers"] = dnsSettings["NameServers"];
|
|
}
|
|
}
|
|
|
|
// shared SSL sites
|
|
else if (String.Compare(PackageSettings.SHARED_SSL_SITES, settingsName, true) == 0)
|
|
{
|
|
// load WEB service settings
|
|
int webServiceId = GetPackageServiceId(packageId, ResourceGroups.Web);
|
|
if (webServiceId > 0)
|
|
{
|
|
StringDictionary webSettings = ServerController.GetServiceSettings(webServiceId);
|
|
settings["SharedSslSites"] = webSettings["SharedSslSites"];
|
|
}
|
|
}
|
|
|
|
// child spaces location
|
|
else if (String.Compare(PackageSettings.SPACES_FOLDER, settingsName, true) == 0)
|
|
{
|
|
settings["ChildSpacesFolder"] = "";
|
|
}
|
|
|
|
// Exchange Server
|
|
else if (String.Compare(PackageSettings.EXCHANGE_SERVER, settingsName, true) == 0)
|
|
{
|
|
// load Exchange service settings
|
|
int exchServiceId = GetPackageServiceId(packageId, ResourceGroups.Exchange);
|
|
if (exchServiceId > 0)
|
|
{
|
|
StringDictionary exchSettings = ServerController.GetServiceSettings(exchServiceId);
|
|
settings["TempDomain"] = exchSettings["TempDomain"];
|
|
}
|
|
}
|
|
|
|
// VPS
|
|
else if (String.Compare(PackageSettings.VIRTUAL_PRIVATE_SERVERS, settingsName, true) == 0)
|
|
{
|
|
// load Exchange service settings
|
|
int vpsServiceId = GetPackageServiceId(packageId, ResourceGroups.VPS);
|
|
if (vpsServiceId > 0)
|
|
{
|
|
StringDictionary vpsSettings = ServerController.GetServiceSettings(vpsServiceId);
|
|
settings["HostnamePattern"] = vpsSettings["HostnamePattern"];
|
|
}
|
|
}
|
|
|
|
//vpforCP
|
|
else if (String.Compare(PackageSettings.VIRTUAL_PRIVATE_SERVERS_FOR_PRIVATE_CLOUD, settingsName, true) == 0)
|
|
{
|
|
int vpsServiceId = GetPackageServiceId(packageId, ResourceGroups.VPSForPC);
|
|
if (vpsServiceId > 0)
|
|
{
|
|
StringDictionary vpsSettings = ServerController.GetServiceSettings(vpsServiceId);
|
|
settings["HostnamePattern"] = vpsSettings["HostnamePattern"];
|
|
}
|
|
}
|
|
}
|
|
|
|
return settings;
|
|
}
|
|
|
|
public static int UpdatePackageSettings(PackageSettings settings)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
//// get user details
|
|
//UserInfo user = GetUserInternally(settings.UserId);
|
|
|
|
//// place log record
|
|
//LogRecord record = new LogRecord();
|
|
//record.RecordType = LogRecordType.Information;
|
|
//record.PackageId = 0;
|
|
//record.ItemId = settings.UserId;
|
|
//record.Source = LogSource.USERS;
|
|
//record.Action = "USERS_UPDATE_USER_SETTINGS";
|
|
//record.ActionParameters.Add(user.Username).Add(settings.SettingsName);
|
|
|
|
try
|
|
{
|
|
// build xml
|
|
XmlDocument doc = new XmlDocument();
|
|
XmlElement nodeProps = doc.CreateElement("properties");
|
|
if (settings.SettingsArray != null)
|
|
{
|
|
foreach (string[] pair in settings.SettingsArray)
|
|
{
|
|
XmlElement nodeProp = doc.CreateElement("property");
|
|
nodeProp.SetAttribute("name", pair[0]);
|
|
nodeProp.SetAttribute("value", pair[1]);
|
|
nodeProps.AppendChild(nodeProp);
|
|
}
|
|
}
|
|
|
|
string xml = nodeProps.OuterXml;
|
|
|
|
// update settings
|
|
DataProvider.UpdatePackageSettings(SecurityContext.User.UserId,
|
|
settings.PackageId, settings.SettingsName, xml);
|
|
|
|
return 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
//record.RecordType = LogRecordType.Error;
|
|
//record.Description["Error"] = ex.ToString();
|
|
throw new Exception("Could not update package settings", ex);
|
|
}
|
|
//finally
|
|
//{
|
|
// AuditLog.AddRecord(record);
|
|
//}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Quotas
|
|
public static QuotaValueInfo GetPackageQuota(int packageId, string quotaName)
|
|
{
|
|
QuotaValueInfo quota = ObjectUtils.FillObjectFromDataReader<QuotaValueInfo>(
|
|
DataProvider.GetPackageQuota(SecurityContext.User.UserId,
|
|
packageId, quotaName));
|
|
|
|
// set exhausted flag
|
|
quota.QuotaExhausted = (quota.QuotaAllocatedValue != -1 && quota.QuotaUsedValue >= quota.QuotaAllocatedValue);
|
|
|
|
return quota;
|
|
}
|
|
#endregion
|
|
|
|
#region Fix for item #1547 by Pavel Tsurbeleu
|
|
public static string BuildMessageBccField(params string[] bccAddresses)
|
|
{
|
|
List<string> mailAddresses = new List<string>();
|
|
//
|
|
foreach (string bccItem in bccAddresses)
|
|
{
|
|
if (!String.IsNullOrEmpty(bccItem))
|
|
{
|
|
string bccAddress = bccItem.Trim();
|
|
// check if value is semicolon-delimited and convert it to the standard format
|
|
if (bccAddress.Contains(";"))
|
|
bccAddress = bccAddress.Replace(';', ',');
|
|
//
|
|
mailAddresses.Add(bccAddress);
|
|
}
|
|
}
|
|
//
|
|
return String.Join(",", mailAddresses.ToArray());
|
|
}
|
|
#endregion
|
|
|
|
#region Templates
|
|
public static int SendAccountSummaryLetter(int userId, string to, string bcc, bool signup)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load user details
|
|
UserInfo user = UserController.GetUser(userId);
|
|
if (user == null)
|
|
return BusinessErrorCodes.ERROR_USER_NOT_FOUND;
|
|
|
|
UserSettings settings = UserController.GetUserSettings(userId, UserSettings.ACCOUNT_SUMMARY_LETTER);
|
|
string from = settings["From"];
|
|
|
|
#region Fix for item #1547 by Pavel Tsurbeleu
|
|
// Build BCC field
|
|
bcc = BuildMessageBccField(bcc, settings["CC"], user.SecondaryEmail);
|
|
#endregion
|
|
|
|
string subject = settings["Subject"];
|
|
string body = user.HtmlMail ? settings["HtmlBody"] : settings["TextBody"];
|
|
bool isHtml = user.HtmlMail;
|
|
|
|
MailPriority priority = MailPriority.Normal;
|
|
if (!String.IsNullOrEmpty(settings["Priority"]))
|
|
priority = (MailPriority)Enum.Parse(typeof(MailPriority), settings["Priority"], true);
|
|
|
|
if (String.IsNullOrEmpty(body))
|
|
return 0;// BusinessErrorCodes.ERROR_SETTINGS_ACCOUNT_LETTER_EMPTY_BODY;
|
|
|
|
// load user info
|
|
if (to == null)
|
|
to = user.Email;
|
|
|
|
subject = EvaluateAccountTempate(userId, subject, signup, true);
|
|
body = EvaluateAccountTempate(userId, body, signup, true);
|
|
|
|
// send message
|
|
return MailHelper.SendMessage(from, to, bcc, subject, body, priority, isHtml);
|
|
}
|
|
|
|
public static int SendPackageSummaryLetter(int packageId, string to, string bcc, bool signup)
|
|
{
|
|
// check account
|
|
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
|
|
if (accountCheck < 0) return accountCheck;
|
|
|
|
// load package
|
|
PackageInfo package = GetPackage(packageId);
|
|
if (package == null)
|
|
return BusinessErrorCodes.ERROR_PACKAGE_NOT_FOUND;
|
|
|
|
// load user details
|
|
UserInfo user = UserController.GetUser(package.UserId);
|
|
if (user == null)
|
|
return BusinessErrorCodes.ERROR_USER_NOT_FOUND;
|
|
|
|
UserSettings settings = UserController.GetUserSettings(package.UserId, UserSettings.PACKAGE_SUMMARY_LETTER);
|
|
string from = settings["From"];
|
|
|
|
#region Fix for item #1547 by Pavel Tsurbeleu
|
|
// Build BCC field
|
|
bcc = BuildMessageBccField(bcc, settings["CC"], user.SecondaryEmail);
|
|
#endregion
|
|
|
|
string subject = settings["Subject"];
|
|
string body = user.HtmlMail ? settings["HtmlBody"] : settings["TextBody"];
|
|
bool isHtml = user.HtmlMail;
|
|
|
|
MailPriority priority = MailPriority.Normal;
|
|
if (!String.IsNullOrEmpty(settings["Priority"]))
|
|
priority = (MailPriority)Enum.Parse(typeof(MailPriority), settings["Priority"], true);
|
|
|
|
if (String.IsNullOrEmpty(body))
|
|
return 0;// BusinessErrorCodes.ERROR_SETTINGS_ACCOUNT_LETTER_EMPTY_BODY;
|
|
|
|
// load user info
|
|
if (to == null)
|
|
to = user.Email;
|
|
|
|
subject = EvaluatePackageTempate(packageId, subject, signup, true);
|
|
body = EvaluatePackageTempate(packageId, body, signup, true);
|
|
|
|
// send message
|
|
return MailHelper.SendMessage(from, to, bcc, subject, body, priority, isHtml);
|
|
}
|
|
|
|
public static string GetEvaluatedPackageTemplateBody(int packageId, bool signup)
|
|
{
|
|
// load user info
|
|
UserInfo user = GetPackageOwner(packageId);
|
|
string settingName = user.HtmlMail ? "HtmlBody" : "TextBody";
|
|
|
|
// get space letter settings
|
|
UserSettings settings = UserController.GetUserSettings(user.UserId, UserSettings.PACKAGE_SUMMARY_LETTER);
|
|
string body = settings[settingName];
|
|
if (String.IsNullOrEmpty(body))
|
|
return null;
|
|
|
|
string result = EvaluatePackageTempate(packageId, body, signup, false);
|
|
return user.HtmlMail ? result : result.Replace("\n", "<br/>");
|
|
}
|
|
|
|
public static string GetEvaluatedAccountTemplateBody(int userId, bool signup)
|
|
{
|
|
// load user info
|
|
UserInfo user = UserController.GetUser(userId);
|
|
string settingName = user.HtmlMail ? "HtmlBody" : "TextBody";
|
|
|
|
// get account letter settings
|
|
UserSettings settings = UserController.GetUserSettings(user.UserId, UserSettings.ACCOUNT_SUMMARY_LETTER);
|
|
string body = settings[settingName];
|
|
if (String.IsNullOrEmpty(body))
|
|
return null;
|
|
|
|
string result = EvaluateAccountTempate(userId, body, signup, false);
|
|
return user.HtmlMail ? result : result.Replace("\n", "<br/>");
|
|
}
|
|
|
|
public static string EvaluateUserPackageTempate(int userId, int packageId, string template)
|
|
{
|
|
// package context
|
|
if (packageId > -1)
|
|
{
|
|
return EvaluatePackageTempate(packageId, template, false, false);
|
|
}
|
|
else
|
|
{
|
|
return EvaluateAccountTempate(userId, template, false, false);
|
|
}
|
|
}
|
|
|
|
public static string EvaluatePackageTempate(int packageId, string template, bool signup, bool email)
|
|
{
|
|
Hashtable items = new Hashtable();
|
|
|
|
items["Signup"] = signup;
|
|
items["Email"] = email;
|
|
|
|
// load package
|
|
PackageInfo package = GetPackage(packageId);
|
|
if (package == null)
|
|
return null;
|
|
|
|
// add package context
|
|
PackageContext cntx = GetPackageContext(packageId);
|
|
items["space"] = cntx;
|
|
|
|
// get hosting plan
|
|
HostingPlanInfo plan = GetHostingPlan(package.PlanId);
|
|
if (plan != null)
|
|
items["plan"] = plan;
|
|
|
|
// name servers
|
|
PackageSettings packageSettings = PackageController.GetPackageSettings(packageId, PackageSettings.NAME_SERVERS);
|
|
string[] nameServers = new string[] { };
|
|
if (!String.IsNullOrEmpty(packageSettings["NameServers"]))
|
|
nameServers = packageSettings["NameServers"].Split(';');
|
|
|
|
items["NameServers"] = nameServers;
|
|
|
|
// instant alias
|
|
string instantAlias = null;
|
|
packageSettings = PackageController.GetPackageSettings(packageId, PackageSettings.INSTANT_ALIAS);
|
|
if (!String.IsNullOrEmpty(packageSettings["InstantAlias"]))
|
|
instantAlias = packageSettings["InstantAlias"];
|
|
|
|
items["InstantAlias"] = instantAlias;
|
|
|
|
// web sites
|
|
List<WebsitePanel.Providers.Web.WebSite> webSites =
|
|
WebServerController.GetWebSites(packageId, false);
|
|
items["WebSites"] = webSites;
|
|
|
|
// domains
|
|
List<DomainInfo> domains = ServerController.GetDomains(packageId, false);
|
|
items["Domains"] = domains;
|
|
|
|
// FTP Server
|
|
int ftpServiceId = GetPackageServiceId(packageId, ResourceGroups.Ftp);
|
|
if (ftpServiceId > 0)
|
|
{
|
|
// get FTP DNS records
|
|
List<GlobalDnsRecord> ftpRecords = ServerController.GetDnsRecordsByService(ftpServiceId);
|
|
if (ftpRecords.Count > 0)
|
|
{
|
|
GlobalDnsRecord ftpRecord = ftpRecords[0];
|
|
string ftpIp = ftpRecord.ExternalIP;
|
|
if (String.IsNullOrEmpty(ftpIp))
|
|
ftpIp = ftpRecord.RecordData;
|
|
|
|
items["FtpIP"] = ftpIp;
|
|
}
|
|
}
|
|
|
|
// FTP accounts
|
|
List<FtpAccount> ftpAccounts =
|
|
FtpServerController.GetFtpAccounts(packageId, false);
|
|
items["FtpAccounts"] = ftpAccounts;
|
|
|
|
// Mail Accounts
|
|
List<MailAccount> mailAccounts =
|
|
MailServerController.GetMailAccounts(packageId, false);
|
|
items["MailAccounts"] = mailAccounts;
|
|
|
|
// mail server IP
|
|
List<GlobalDnsRecord> mailRecords = new List<GlobalDnsRecord>();
|
|
int mailServiceId = GetPackageServiceId(packageId, ResourceGroups.Mail);
|
|
if (mailServiceId > 0)
|
|
{
|
|
StringDictionary mailSettings = ServerController.GetServiceSettings(mailServiceId);
|
|
if (mailSettings != null)
|
|
items["MailIP"] = ServerController.GetExternalIPAddress(Utils.ParseInt(mailSettings["ServerIPAddress"], 0));
|
|
|
|
mailRecords = ServerController.GetDnsRecordsByService(mailServiceId);
|
|
}
|
|
items["MailRecords"] = mailRecords;
|
|
|
|
SetSqlServerExternalAddress(packageId, items, ResourceGroups.MsSql2000);
|
|
SetSqlServerExternalAddress(packageId, items, ResourceGroups.MsSql2005);
|
|
SetSqlServerExternalAddress(packageId, items, ResourceGroups.MsSql2008);
|
|
SetSqlServerExternalAddress(packageId, items, ResourceGroups.MsSql2012);
|
|
SetSqlServerExternalAddress(packageId, items, ResourceGroups.MySql4);
|
|
SetSqlServerExternalAddress(packageId, items, ResourceGroups.MySql5);
|
|
|
|
// Exchange organizations
|
|
items["ExchangeOrganizations"] = ExchangeServerController.GetExchangeOrganizations(packageId, false);
|
|
|
|
// Exchange service settings
|
|
int exchangeServiceId = GetPackageServiceId(packageId, ResourceGroups.Exchange);
|
|
StringDictionary exchangeSettings = ServerController.GetServiceSettings(exchangeServiceId);
|
|
if (exchangeSettings != null)
|
|
{
|
|
items["TempDomain"] = exchangeSettings["TempDomain"];
|
|
items["AutodiscoverIP"] = exchangeSettings["AutodiscoverIP"];
|
|
items["AutodiscoverDomain"] = exchangeSettings["AutodiscoverDomain"];
|
|
items["OwaUrl"] = exchangeSettings["OwaUrl"];
|
|
items["ActiveSyncServer"] = exchangeSettings["ActiveSyncServer"];
|
|
items["SmtpServers"] = Utils.ParseDelimitedString(exchangeSettings["SmtpServers"], '\n');
|
|
}
|
|
|
|
// package root folder
|
|
items["PackageRootFolder"] = FilesController.GetHomeFolder(packageId);
|
|
|
|
// get user details
|
|
UserInfo user = UserController.GetUser(package.UserId);
|
|
if (user == null)
|
|
return null;
|
|
|
|
items["user"] = user;
|
|
|
|
// get reseller details
|
|
UserInfo reseller = UserController.GetUser(user.OwnerId);
|
|
if (reseller != null)
|
|
{
|
|
reseller.Password = "";
|
|
items["reseller"] = reseller;
|
|
}
|
|
|
|
return EvaluateTemplate(template, items);
|
|
}
|
|
|
|
private static void SetSqlServerExternalAddress(int packageId, Hashtable items, string groupName)
|
|
{
|
|
int serviceId = GetPackageServiceId(packageId, groupName);
|
|
if (serviceId > 0)
|
|
{
|
|
StringDictionary sqlSettings = ServerController.GetServiceSettings(serviceId);
|
|
items[groupName + "Address"] = sqlSettings["ExternalAddress"]; // left for compatibility with existing templates
|
|
items[groupName + "ExternalAddress"] = sqlSettings["ExternalAddress"];
|
|
items[groupName + "InternalAddress"] = sqlSettings["InternalAddress"];
|
|
}
|
|
}
|
|
|
|
public static string EvaluateAccountTempate(int userId, string template, bool signup, bool email)
|
|
{
|
|
Hashtable items = new Hashtable();
|
|
|
|
items["Signup"] = signup;
|
|
items["Email"] = email;
|
|
|
|
// get user details
|
|
UserInfo user = UserController.GetUser(userId);
|
|
if (user == null)
|
|
return null;
|
|
|
|
items["user"] = user;
|
|
|
|
// get reseller details
|
|
UserInfo reseller = UserController.GetUser(user.OwnerId);
|
|
if (reseller != null)
|
|
{
|
|
reseller.Password = "";
|
|
items["reseller"] = reseller;
|
|
}
|
|
|
|
// get all purchased packages
|
|
List<PackageInfo> packages = GetMyPackages(userId);
|
|
items["Spaces"] = packages;
|
|
|
|
// hosting plans
|
|
Hashtable plans = new Hashtable();
|
|
foreach (PackageInfo package in packages)
|
|
{
|
|
HostingPlanInfo plan = GetHostingPlan(package.PlanId);
|
|
|
|
if (plan != null && !plans.ContainsKey(plan.PlanId))
|
|
plans.Add(plan.PlanId, plan);
|
|
}
|
|
items["Plans"] = plans;
|
|
|
|
//Add ons
|
|
Hashtable addOns = new Hashtable();
|
|
int i = 0;
|
|
foreach (PackageInfo package in packages)
|
|
{
|
|
List<PackageAddonInfo> lstAddOns = ObjectUtils.CreateListFromDataSet<PackageAddonInfo>(GetPackageAddons(package.PackageId));
|
|
foreach (PackageAddonInfo addOn in lstAddOns)
|
|
{
|
|
addOns.Add(i, addOn);
|
|
i++;
|
|
}
|
|
|
|
}
|
|
items["Addons"] = addOns;
|
|
|
|
// package contexts
|
|
Hashtable cntxs = new Hashtable();
|
|
foreach (PackageInfo package in packages)
|
|
{
|
|
PackageContext cntx = GetPackageContext(package.PackageId);
|
|
cntxs.Add(package.PackageId, cntx);
|
|
}
|
|
items["SpaceContexts"] = cntxs;
|
|
|
|
return EvaluateTemplate(template, items);
|
|
}
|
|
|
|
public static string EvaluateTemplate(string template, Hashtable items)
|
|
{
|
|
StringWriter writer = new StringWriter();
|
|
|
|
try
|
|
{
|
|
Template tmp = new Template(template);
|
|
|
|
if (items != null)
|
|
{
|
|
foreach (string key in items.Keys)
|
|
tmp[key] = items[key];
|
|
}
|
|
|
|
tmp.Evaluate(writer);
|
|
}
|
|
catch (ParserException ex)
|
|
{
|
|
return String.Format("Error in template (Line {0}, Column {1}): {2}",
|
|
ex.Line, ex.Column, ex.Message);
|
|
}
|
|
return writer.ToString();
|
|
}
|
|
#endregion
|
|
|
|
#region Reports
|
|
public static DataSet GetPackagesBandwidthPaged(int userId, int packageId,
|
|
DateTime startDate, DateTime endDate, string sortColumn,
|
|
int startRow, int maximumRows)
|
|
{
|
|
return DataProvider.GetPackagesBandwidthPaged(
|
|
SecurityContext.User.UserId, userId, packageId, startDate, endDate, sortColumn,
|
|
startRow, maximumRows);
|
|
}
|
|
|
|
public static DataSet GetPackagesDiskspacePaged(int userId, int packageId, string sortColumn,
|
|
int startRow, int maximumRows)
|
|
{
|
|
return DataProvider.GetPackagesDiskspacePaged(
|
|
SecurityContext.User.UserId, userId, packageId, sortColumn,
|
|
startRow, maximumRows);
|
|
}
|
|
|
|
public static DataSet GetPackageBandwidth(int packageId, DateTime startDate, DateTime endDate)
|
|
{
|
|
return DataProvider.GetPackageBandwidth(
|
|
SecurityContext.User.UserId, packageId, startDate, endDate);
|
|
}
|
|
|
|
public static DataSet GetPackageDiskspace(int packageId)
|
|
{
|
|
return DataProvider.GetPackageDiskspace(
|
|
SecurityContext.User.UserId, packageId);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Overusage Report
|
|
public static Reports.OverusageReport GetOverusageSummaryReport(int userId, int packageId, DateTime startDate, DateTime endDate)
|
|
{
|
|
Reports.OverusageReport report = new Reports.OverusageReport();
|
|
|
|
report = GetDiskspaceReport(report, userId, packageId, String.Empty);
|
|
report = GetBandwidthReport(report, userId, packageId, String.Empty, startDate, endDate);
|
|
|
|
return report;
|
|
}
|
|
|
|
public static Reports.OverusageReport GetDiskspaceOverusageDetailsReport(int userId, int packageId)
|
|
{
|
|
Reports.OverusageReport report = new Reports.OverusageReport();
|
|
|
|
report = GetDiskspaceInformationAboutPackage(report, packageId);
|
|
report = GetDiskspaceDetails(report);
|
|
|
|
return report;
|
|
}
|
|
|
|
public static Reports.OverusageReport GetBandwidthDetailsReport(int userId, int packageId, DateTime startDate, DateTime endDate)
|
|
{
|
|
Reports.OverusageReport report = new Reports.OverusageReport();
|
|
|
|
report = GetBandwidthInformationAboutPackage(report, packageId, startDate, endDate);
|
|
report = GetBandwidthDetails(report, startDate, endDate);
|
|
|
|
return report;
|
|
}
|
|
|
|
private static Reports.OverusageReport GetDiskspaceInformationAboutPackage(Reports.OverusageReport report, int packageId)
|
|
{
|
|
PackageInfo packageInfo = GetPackage(packageId);
|
|
packageInfo.DiskSpaceQuota = GetPackageQuota(packageId, "OS.Diskspace").QuotaAllocatedValue;
|
|
packageInfo.DiskSpaceQuota = packageInfo.DiskSpaceQuota < 1 ? 0 : packageInfo.DiskSpaceQuota;
|
|
|
|
// 1. Add HostingSpace row
|
|
report.HostingSpace.AddHostingSpaceRow(
|
|
Reports.OverusageReport.HostingSpaceRow
|
|
.CreateFromPackageInfo(
|
|
report
|
|
, packageInfo
|
|
, UserController.GetUser(packageInfo.UserId)
|
|
, ServerController.GetServerByIdInternal(packageInfo.ServerId)
|
|
, packageInfo.DiskSpace > packageInfo.DiskSpaceQuota
|
|
, packageInfo.BandWidth > packageInfo.BandWidthQuota
|
|
, String.Empty
|
|
)
|
|
);
|
|
|
|
report.DiskspaceOverusage.AddDiskspaceOverusageRow(
|
|
Reports.OverusageReport.DiskspaceOverusageRow
|
|
.CreateFromPackageInfo(
|
|
report
|
|
, packageInfo
|
|
)
|
|
);
|
|
|
|
return report;
|
|
}
|
|
|
|
|
|
private static Reports.OverusageReport GetBandwidthInformationAboutPackage(Reports.OverusageReport report, int packageId, DateTime startDate, DateTime endDate)
|
|
{
|
|
PackageInfo packageInfo = GetPackage(packageId);
|
|
packageInfo.BandWidthQuota = GetPackageQuota(packageId, "OS.Bandwidth").QuotaAllocatedValue;
|
|
packageInfo.BandWidthQuota = packageInfo.BandWidthQuota < 1 ? 0 : packageInfo.BandWidthQuota;
|
|
|
|
// 1. Add HostingSpace row
|
|
report.HostingSpace.AddHostingSpaceRow(
|
|
Reports.OverusageReport.HostingSpaceRow
|
|
.CreateFromPackageInfo(
|
|
report
|
|
, packageInfo
|
|
, UserController.GetUser(packageInfo.UserId)
|
|
, ServerController.GetServerByIdInternal(packageInfo.ServerId)
|
|
, packageInfo.DiskSpace > packageInfo.DiskSpaceQuota
|
|
, packageInfo.BandWidth > packageInfo.BandWidthQuota
|
|
, String.Empty
|
|
)
|
|
);
|
|
|
|
// 2. Add BandwidthOverusage row
|
|
report.BandwidthOverusage.AddBandwidthOverusageRow(
|
|
Reports.OverusageReport.BandwidthOverusageRow
|
|
.CreateFromPackageInfo(
|
|
report
|
|
, packageInfo
|
|
)
|
|
);
|
|
|
|
return report;
|
|
}
|
|
|
|
|
|
private static Reports.OverusageReport GetBandwidthDetails(Reports.OverusageReport report, DateTime startDate, DateTime endDate)
|
|
{
|
|
foreach (Reports.OverusageReport.HostingSpaceRow hsRow in report.HostingSpace.Rows)
|
|
{
|
|
DataSet ds = GetPackageBandwidth((int)hsRow.HostingSpaceId, startDate, endDate);
|
|
|
|
foreach (DataRow bwRow in ds.Tables[0].Rows)
|
|
{
|
|
report.OverusageDetails.AddOverusageDetailsRow(
|
|
Reports.OverusageReport.OverusageDetailsRow
|
|
.CreateFromBandwidthRow(report, bwRow, hsRow.HostingSpaceId, "Bandwidth")
|
|
);
|
|
}
|
|
}
|
|
|
|
return report;
|
|
}
|
|
|
|
private static Reports.OverusageReport GetDiskspaceDetails(Reports.OverusageReport report)
|
|
{
|
|
foreach (Reports.OverusageReport.HostingSpaceRow hsRow in report.HostingSpace.Rows)
|
|
{
|
|
DataSet ds = GetPackageDiskspace((int)hsRow.HostingSpaceId);
|
|
|
|
foreach (DataRow dsRow in ds.Tables[0].Rows)
|
|
{
|
|
report.OverusageDetails.AddOverusageDetailsRow(
|
|
Reports.OverusageReport.OverusageDetailsRow
|
|
.CreateFromPackageDiskspaceRow(report, dsRow, hsRow.HostingSpaceId, "Diskspace")
|
|
);
|
|
}
|
|
}
|
|
|
|
return report;
|
|
}
|
|
|
|
private static Reports.OverusageReport GetBandwidthReport(Reports.OverusageReport report, int userId, long packageId, string rootHostingSpacePath, DateTime startDate, DateTime endDate)
|
|
{
|
|
DataTable bwTable = GetPackagesBandwidthPaged(userId, (int)packageId, startDate, endDate);
|
|
|
|
Reports.OverusageReport.HostingSpaceRow hsRow = null;
|
|
|
|
// 1.
|
|
foreach (DataRow bwRow in bwTable.Rows)
|
|
{
|
|
if (Reports.OverusageReport.HostingSpaceRow
|
|
.VerifyIfBandwidthOverused(bwRow))
|
|
{
|
|
hsRow = report.HostingSpace.FindByHostingSpaceId(
|
|
Reports.OverusageReport.HostingSpaceRow.GetPackageId(bwRow)
|
|
);
|
|
|
|
if (hsRow != null)
|
|
{
|
|
hsRow.IsBandwidthOverused = true;
|
|
}
|
|
else
|
|
{
|
|
report.HostingSpace.AddHostingSpaceRow(
|
|
CreateHostingSpacesRow(bwRow, report, false, true, rootHostingSpacePath)
|
|
);
|
|
}
|
|
|
|
report.BandwidthOverusage.AddBandwidthOverusageRow(
|
|
Reports.OverusageReport.BandwidthOverusageRow
|
|
.CreateFromHostingSpaceDataRow(report, bwRow)
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
// 2.
|
|
foreach (DataRow bwRow in bwTable.Rows)
|
|
{
|
|
if (Reports.OverusageReport.HostingSpaceRow
|
|
.IsContainChildSpaces(bwRow))
|
|
{
|
|
report = GetBandwidthReport(
|
|
report
|
|
, userId
|
|
, Reports.OverusageReport.HostingSpaceRow.GetPackageId(bwRow)
|
|
, String.Format(
|
|
"{0} \\ {1}"
|
|
, rootHostingSpacePath
|
|
, Reports.OverusageReportUtils.GetStringOrDefault(bwRow, "PackageName", String.Empty)
|
|
)
|
|
, startDate
|
|
, endDate
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
return report;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gathers summary information about disksapce usage.
|
|
/// </summary>
|
|
/// <param name="report"></param>
|
|
/// <param name="packageId"></param>
|
|
/// <param name="rootHostingSpacePath"></param>
|
|
/// <returns></returns>
|
|
private static Reports.OverusageReport GetDiskspaceReport(Reports.OverusageReport report, int userId, long packageId, string rootHostingSpacePath)
|
|
{
|
|
DataTable dsTable = GetPackagesDiskspacePaged(userId, (int)packageId);
|
|
|
|
Reports.OverusageReport.HostingSpaceRow hsRow = null;
|
|
|
|
//1. generate basic list of reports
|
|
foreach (DataRow dsRow in dsTable.Rows)
|
|
{
|
|
if (Reports.OverusageReport.HostingSpaceRow
|
|
.VerifyIfDiskspaceOverused(dsRow))
|
|
{
|
|
//determine whether this row already exists in the table
|
|
hsRow = report.HostingSpace.FindByHostingSpaceId(
|
|
Reports.OverusageReport.HostingSpaceRow.GetPackageId(dsRow)
|
|
);
|
|
if (hsRow != null)
|
|
{
|
|
//if so, just update it's Diskspace overusage status
|
|
hsRow.IsDiskspaceOverused = true;
|
|
}
|
|
else
|
|
{
|
|
//othrewise, create a new one
|
|
report.HostingSpace.AddHostingSpaceRow(
|
|
CreateHostingSpacesRow(dsRow, report, true, false, rootHostingSpacePath)
|
|
);
|
|
}
|
|
|
|
report.DiskspaceOverusage.AddDiskspaceOverusageRow(
|
|
Reports.OverusageReport.DiskspaceOverusageRow
|
|
.CreateFromHostingSpacesRow(report, dsRow)
|
|
);
|
|
}
|
|
}
|
|
|
|
//2. analyze children
|
|
foreach (DataRow dsRow in dsTable.Rows)
|
|
{
|
|
if (Reports.OverusageReport.HostingSpaceRow.IsContainChildSpaces(dsRow))
|
|
{
|
|
report = GetDiskspaceReport(
|
|
report
|
|
, userId
|
|
, Reports.OverusageReport.HostingSpaceRow.GetPackageId(dsRow)
|
|
, String.Format(
|
|
"{0} \\ {1}"
|
|
, rootHostingSpacePath
|
|
, Reports.OverusageReportUtils.GetStringOrDefault(dsRow, "PackageName", String.Empty)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
return report;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves child Hosting Spaces (packages) by parent Hosting Space Id
|
|
/// with information about bandwidth usage per Hosting Space
|
|
/// </summary>
|
|
/// <param name="packageId"></param>
|
|
/// <returns></returns>
|
|
private static DataTable GetPackagesDiskspacePaged(int userId, int packageId)
|
|
{
|
|
return GetPackagesDiskspacePaged(
|
|
userId
|
|
, packageId
|
|
, String.Empty
|
|
, 0
|
|
, int.MaxValue
|
|
).Tables[1];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves child Hosting Spaces (packages) using parent Hosting Space Id
|
|
/// with information about bandwidth usage per Hosting Space
|
|
/// </summary>
|
|
/// <param name="packageId"></param>
|
|
/// <param name="startDate"></param>
|
|
/// <param name="endDate"></param>
|
|
/// <returns></returns>
|
|
private static DataTable GetPackagesBandwidthPaged(int userId, int packageId, DateTime startDate, DateTime endDate)
|
|
{
|
|
return GetPackagesBandwidthPaged(
|
|
userId
|
|
, packageId
|
|
, startDate
|
|
, endDate
|
|
, String.Empty
|
|
, 0
|
|
, int.MaxValue
|
|
).Tables[1];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates HostingSpacesRow class instance.
|
|
/// </summary>
|
|
/// <param name="hsRow">Hosting Space information data row</param>
|
|
/// <param name="currentOverusageReport">The report to update.</param>
|
|
/// <param name="isDiskspaceOverused">Shows whether diskspace is overused.</param>
|
|
/// <param name="isBandwidthOverused">Shows whether bandwidth is overused.</param>
|
|
/// <param name="packageFullTree">Hosting spaces tree.</param>
|
|
/// <returns>HostingSpacesRow class instance.</returns>
|
|
private static Reports.OverusageReport.HostingSpaceRow CreateHostingSpacesRow(DataRow hsRow, Reports.OverusageReport currentOverusageReport, bool isDiskspaceOverused, bool isBandwidthOverused, string packageFullTree)
|
|
{
|
|
Reports.OverusageReport.HostingSpaceRow row = Reports.OverusageReport.HostingSpaceRow.CreateFromHostingSpacesRow(currentOverusageReport, hsRow, isDiskspaceOverused, isBandwidthOverused, packageFullTree);
|
|
|
|
//TODO: Optimiza it in some way :)
|
|
PackageInfo packageInfo = GetPackage((int)row.HostingSpaceId);
|
|
row.Location = ServerController.GetServerShortDetails(packageInfo.ServerId).ServerName;
|
|
row.HostingSpaceCreationDate = packageInfo.PurchaseDate;
|
|
|
|
return row;
|
|
}
|
|
#endregion
|
|
|
|
#region Helper Methods
|
|
public static Dictionary<int, List<ServiceProviderItem>> OrderServiceItemsByServices(
|
|
List<ServiceProviderItem> items)
|
|
{
|
|
// order items by service id
|
|
Dictionary<int, List<ServiceProviderItem>> orderedItems = new Dictionary<int, List<ServiceProviderItem>>();
|
|
foreach (ServiceProviderItem item in items)
|
|
{
|
|
int serviceId = item.ServiceId;
|
|
List<ServiceProviderItem> serviceItems = null;
|
|
if (orderedItems.ContainsKey(serviceId))
|
|
serviceItems = orderedItems[serviceId];
|
|
else
|
|
{
|
|
serviceItems = new List<ServiceProviderItem>();
|
|
orderedItems.Add(serviceId, serviceItems);
|
|
}
|
|
|
|
// add item to the appropriate list
|
|
serviceItems.Add(item);
|
|
}
|
|
|
|
return orderedItems;
|
|
}
|
|
#endregion
|
|
}
|
|
}
|