public static StatsServer[] GetServers(int serviceId)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive
| DemandAccount.IsAdmin);
if (accountCheck < 0)
{
return(null);
}
StatisticsServer stats = new StatisticsServer();
ServiceProviderProxy.Init(stats, serviceId);
return(stats.GetServers());
}
public static int DeleteAuditLogRecords(int userId, int itemId, string itemName,
DateTime startDate, DateTime endDate, int severityId, string sourceName, string taskName)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
DataProvider.DeleteAuditLogRecords(SecurityContext.User.UserId,
userId, itemId, itemName, GetStartDate(startDate), GetEndDate(endDate), severityId, sourceName, taskName);
return(0);
}
public static int DeleteSqlDatabase(int itemId)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
// load original meta item
SqlDatabase origItem = (SqlDatabase)PackageController.GetPackageItem(itemId);
if (origItem == null)
{
return(BusinessErrorCodes.ERROR_MSSQL_DATABASES_PACKAGE_ITEM_NOT_FOUND);
}
// place log record
TaskManager.StartTask("SQL_DATABASE", "DELETE", origItem.Name);
TaskManager.ItemId = itemId;
TaskManager.WriteParameter("Provider", origItem.GroupName);
try
{
// get service
DatabaseServer sql = GetDatabaseServer(origItem.ServiceId);
// delete service item
sql.DeleteDatabase(origItem.Name);
// delete meta item
PackageController.DeletePackageItem(origItem.Id);
return(0);
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
// Return a generic error instead of re-throwing an exception
return(BusinessErrorCodes.FAILED_EXECUTE_SERVICE_OPERATION);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int DeleteSite(int itemId)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
// load original meta item
StatsSite origItem = (StatsSite)PackageController.GetPackageItem(itemId);
if (origItem == null)
{
return(BusinessErrorCodes.ERROR_STATS_PACKAGE_ITEM_NOT_FOUND);
}
// place log record
TaskManager.StartTask("STATS_SITE", "DELETE", origItem.Name);
TaskManager.ItemId = origItem.Id;
try
{
// get service
StatisticsServer stats = new StatisticsServer();
ServiceProviderProxy.Init(stats, origItem.ServiceId);
// delete service item
stats.DeleteSite(origItem.SiteId);
// delete meta item
PackageController.DeletePackageItem(origItem.Id);
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static GalleryApplicationsResult GetGalleryApplicationsByServiceId(int serviceId)
{
GalleryApplicationsResult result;
//
try
{
TaskManager.StartTask(TASK_MANAGER_SOURCE, GET_SRV_GALLERY_APPS_TASK);
//
if (SecurityContext.CheckAccount(DemandAccount.IsAdmin) != 0)
{
return(WAG_MODULE_NOT_AVAILABLE <GalleryApplicationsResult>());
}
//
WebServer webServer = WebServerController.GetWebServer(serviceId);
// ERROR: WAG is unavailable
if (!webServer.IsMsDeployInstalled())
{
return(WAG_MODULE_NOT_AVAILABLE <GalleryApplicationsResult>());
}
//
result = webServer.GetGalleryApplications(String.Empty);
//
if (!result.IsSuccess)
{
foreach (string errorMessage in result.ErrorCodes)
{
TaskManager.WriteError(errorMessage);
}
//
return(WAG_GENERIC_MODULE_ERROR <GalleryApplicationsResult>());
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
//
return(WAG_GENERIC_MODULE_ERROR <GalleryApplicationsResult>());
}
finally
{
TaskManager.CompleteTask();
}
//
return(result);
}
public static int AddComment(string itemTypeId, int itemId,
string commentText, int severityId)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// add comment
DataProvider.AddComment(SecurityContext.User.UserId, itemTypeId,
itemId, commentText, severityId);
return(0);
}
public static int DeleteFtpAccount(int itemId)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
// load original meta item
FtpAccount origItem = (FtpAccount)PackageController.GetPackageItem(itemId);
if (origItem == null)
{
return(BusinessErrorCodes.ERROR_FTP_PACKAGE_ITEM_NOT_FOUND);
}
// place log record
TaskManager.StartTask("FTP_ACCOUNT", "DELETE", origItem.Name);
TaskManager.ItemId = itemId;
try
{
// get service
FTPServer ftp = new FTPServer();
ServiceProviderProxy.Init(ftp, origItem.ServiceId);
// delete service item
ftp.DeleteAccount(origItem.Name);
// delete meta item
PackageController.DeletePackageItem(origItem.Id);
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int DeleteFiles(int packageId, string[] files)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
// place log record
TaskManager.StartTask("FILES", "DELETE_FILES", packageId);
if (files != null)
{
foreach (string file in files)
{
TaskManager.Write(file);
}
}
try
{
OS.OperatingSystem os = GetOS(packageId);
for (int i = 0; i < files.Length; i++)
{
files[i] = GetFullPackagePath(packageId, files[i]);
}
// delete files
os.DeleteFiles(files);
return(0);
}
catch (Exception ex)
{
//Log and return a generic error rather than throwing an exception
TaskManager.WriteError(ex);
return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int DeleteSharePointUser(int itemId)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
// load original meta item
SystemUser origItem = (SystemUser)PackageController.GetPackageItem(itemId);
if (origItem == null)
{
return(BusinessErrorCodes.ERROR_SHAREPOINT_USERS_PACKAGE_ITEM_NOT_FOUND);
}
// place log record
TaskManager.StartTask("SHAREPOINT", "DELETE_USER", origItem.Name);
TaskManager.ItemId = itemId;
try
{
// get service
SharePointServer sps = GetSharePoint(origItem.ServiceId);
// delete service item
sps.DeleteUser(origItem.Name);
// delete meta item
PackageController.DeletePackageItem(origItem.Id);
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int DeleteOdbcSource(int itemId)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
// load original meta item
SystemDSN origItem = (SystemDSN)PackageController.GetPackageItem(itemId);
if (origItem == null)
{
return(BusinessErrorCodes.ERROR_OS_DSN_PACKAGE_ITEM_NOT_FOUND);
}
// place log record
TaskManager.StartTask("ODBC_DSN", "DELETE", origItem.Name);
TaskManager.ItemId = itemId;
try
{
// get service
OS.OperatingSystem os = GetOS(origItem.ServiceId);
// delete service item
os.DeleteDSN(origItem.Name);
// delete meta item
PackageController.DeletePackageItem(origItem.Id);
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static GalleryApplicationsResult GetGalleryApplicationsByServiceId(int serviceId)
{
GalleryApplicationsResult result;
//
try
{
TaskManager.StartTask(TASK_MANAGER_SOURCE, GET_SRV_GALLERY_APPS_TASK);
int accountCheck = SecurityContext.CheckAccount(DemandAccount.IsAdmin);
if (accountCheck < 0)
{
return(Warning <GalleryApplicationsResult>((-accountCheck).ToString()));
}
// check if WAG is installed
WebServer webServer = WebServerController.GetWebServer(serviceId);
if (!webServer.IsMsDeployInstalled())
{
return(Error <GalleryApplicationsResult>(GalleryErrors.MsDeployIsNotInstalled));
}
// get applications
result = webServer.GetGalleryApplications(String.Empty);
if (!result.IsSuccess)
{
return(Error <GalleryApplicationsResult>(result, GalleryErrors.GetApplicationsError));
}
}
catch (Exception ex)
{
TaskManager.WriteError(ex);
return(Error <GalleryApplicationsResult>(GalleryErrors.GeneralError, ex.Message));
}
finally
{
TaskManager.CompleteTask();
}
//
return(result);
}
public static int CreateFolder(int packageId, string path)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// check package
int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// place log record
TaskManager.StartTask("FILES", "CREATE_FOLDER", path);
TaskManager.ItemId = packageId;
try
{
OS.OperatingSystem os = GetOS(packageId);
string fullPath = GetFullPackagePath(packageId, path);
// create folder
os.CreateDirectory(fullPath);
return(0);
}
catch (Exception ex)
{
//Log and return a generic error rather than throwing an exception
TaskManager.WriteError(ex);
return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int UpdateFileBinaryContentUsingEncoding(int packageId, string path, byte[] content, string encoding)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// check package
int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// place log record
TaskManager.StartTask("FILES", "UPDATE_BINARY_CONTENT", path);
TaskManager.ItemId = packageId;
try
{
OS.OperatingSystem os = GetOS(packageId);
string fullPath = GetFullPackagePath(packageId, path);
// create file
os.UpdateFileBinaryContentUsingEncoding(fullPath, content, encoding);
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int TruncateSqlDatabase(int itemId)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
// load original meta item
SqlDatabase origItem = (SqlDatabase)PackageController.GetPackageItem(itemId);
if (origItem == null)
{
return(BusinessErrorCodes.ERROR_MSSQL_DATABASES_PACKAGE_ITEM_NOT_FOUND);
}
// place log record
TaskManager.StartTask("SQL_DATABASE", "TRUNCATE", origItem.Name);
TaskManager.ItemId = itemId;
try
{
// get service
DatabaseServer sql = GetDatabaseServer(origItem.ServiceId);
// truncate database
sql.TruncateDatabase(origItem.Name);
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int StopSchedule(int scheduleId)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
SchedulerJob schedule = GetScheduleComplete(scheduleId);
if (schedule == null)
{
return(0);
}
Scheduler.StopSchedule(schedule);
return(0);
}
public static int DeleteSchedule(int scheduleId)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
// stop schedule if active
StopSchedule(scheduleId);
// delete schedule
DataProvider.DeleteSchedule(SecurityContext.User.UserId, scheduleId);
// re-schedule tasks
Scheduler.ScheduleTasks();
return(0);
}
public static int DeleteDirectoryRecursive(int packageId, string rootPath)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// check package
int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// place log record
TaskManager.StartTask("FILES", "DELETE_DIRECTORY_RECURSIVE", rootPath, packageId);
try
{
OS.OperatingSystem os = GetOS(packageId);
os.DeleteDirectoryRecursive(rootPath);
return(0);
}
catch (Exception ex)
{
//Log and return a generic error rather than throwing an exception
TaskManager.WriteError(ex);
return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED);
}
finally
{
TaskManager.CompleteTask();
}
}
public static string[] GetInstalledWebParts(int itemId)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(null);
}
// load original meta item
SharePointSite item = (SharePointSite)PackageController.GetPackageItem(itemId);
if (item == null)
{
return(null);
}
SharePointServer sps = GetSharePoint(item.ServiceId);
return(sps.GetInstalledWebParts(item.Name));
}
public static int InstallApplication(InstallationInfo inst)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// check package
int packageCheck = SecurityContext.CheckPackage(inst.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// install application
WebApplicationsInstaller installer = new WebApplicationsInstaller();
return(installer.InstallWebApplication(inst));
}
public static int SetSystemSettings(string settingsName, SystemSettings settings)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin
| DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
XmlDocument xmldoc = new XmlDocument();
XmlElement root = xmldoc.CreateElement("properties");
foreach (string[] pair in settings.SettingsArray)
{
string name = pair[0];
string val = pair[1];
if (name.ToLower().IndexOf("password") != -1)
{
val = CryptoUtils.Encrypt(val);
}
XmlElement property = xmldoc.CreateElement("property");
property.SetAttribute("name", name);
property.SetAttribute("value", val);
root.AppendChild(property);
}
DataProvider.SetSystemSettings(settingsName, root.OuterXml);
return(0);
}
public static int RenameFile(int packageId, string oldPath, string newPath)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
// place log record
TaskManager.StartTask("FILES", "RENAME_FILE", oldPath, packageId);
TaskManager.WriteParameter("New name", newPath);
try
{
OS.OperatingSystem os = GetOS(packageId);
string oldFullPath = GetFullPackagePath(packageId, oldPath);
string destFullPath = GetFullPackagePath(packageId, newPath);
os.MoveFile(oldFullPath, destFullPath);
return(0);
}
catch (Exception ex)
{
//Log and return a generic error rather than throwing an exception
TaskManager.WriteError(ex);
return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int UpdateOdbcSource(SystemDSN item)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// load original meta item
SystemDSN origItem = (SystemDSN)PackageController.GetPackageItem(item.Id);
if (origItem == null)
{
return(BusinessErrorCodes.ERROR_OS_DSN_PACKAGE_ITEM_NOT_FOUND);
}
// check package
int packageCheck = SecurityContext.CheckPackage(origItem.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// place log record
TaskManager.StartTask("ODBC_DSN", "UPDATE", origItem.Name);
TaskManager.ItemId = item.Id;
try
{
// get service
OS.OperatingSystem os = GetOS(origItem.ServiceId);
// password
item.Driver = origItem.Driver;
item.Name = origItem.Name;
if (item.DatabasePassword == "")
{
item.DatabasePassword = CryptoUtils.Decrypt(origItem.DatabasePassword);
}
string[] dbNameParts = item.DatabaseName.Split('|');
string groupName = null;
if (dbNameParts.Length > 1)
{
item.DatabaseName = dbNameParts[0];
groupName = dbNameParts[1];
}
// get database server address
item.DatabaseServer = GetDatabaseServerName(groupName, item.PackageId);
if (item.Driver == "MsAccess" || item.Driver == "Excel" || item.Driver == "Text")
{
item.DatabaseName = FilesController.GetFullPackagePath(origItem.PackageId, item.DatabaseName);
}
// update service item
os.UpdateDSN(item);
// update meta item
if (item.DatabasePassword != "")
{
item.DatabasePassword = CryptoUtils.Encrypt(item.DatabasePassword);
PackageController.UpdatePackageItem(item);
}
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int AddOdbcSource(SystemDSN item)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// check package
int packageCheck = SecurityContext.CheckPackage(item.PackageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// check quota
QuotaValueInfo quota = PackageController.GetPackageQuota(item.PackageId, Quotas.OS_ODBC);
if (quota.QuotaExhausted)
{
return(BusinessErrorCodes.ERROR_OS_DSN_RESOURCE_QUOTA_LIMIT);
}
// check if mail resource is available
int serviceId = PackageController.GetPackageServiceId(item.PackageId, ResourceGroups.Os);
if (serviceId == 0)
{
return(BusinessErrorCodes.ERROR_OS_RESOURCE_UNAVAILABLE);
}
// check package items
if (PackageController.GetPackageItemByName(item.PackageId, item.Name, typeof(SystemDSN)) != null)
{
return(BusinessErrorCodes.ERROR_OS_DSN_PACKAGE_ITEM_EXISTS);
}
// place log record
TaskManager.StartTask("ODBC_DSN", "ADD", item.Name);
try
{
// check service items
OS.OperatingSystem os = GetOS(serviceId);
if (os.GetDSN(item.Name) != null)
{
return(BusinessErrorCodes.ERROR_OS_DSN_SERVICE_ITEM_EXISTS);
}
string[] dbNameParts = item.DatabaseName.Split('|');
string groupName = null;
if (dbNameParts.Length > 1)
{
item.DatabaseName = dbNameParts[0];
groupName = dbNameParts[1];
}
// get database server address
item.DatabaseServer = GetDatabaseServerName(groupName, item.PackageId);
if (item.Driver == "MsAccess" || item.Driver == "Excel" || item.Driver == "Text")
{
item.DatabaseName = FilesController.GetFullPackagePath(item.PackageId, item.DatabaseName);
}
// add service item
os.CreateDSN(item);
// save item
item.DatabasePassword = CryptoUtils.Encrypt(item.DatabasePassword);
item.ServiceId = serviceId;
int itemId = PackageController.AddPackageItem(item);
TaskManager.ItemId = itemId;
return(itemId);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int ChangeUserStatus(string taskId, int userId, UserStatus status)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
int result = 0;
// get user details
UserInfo user = GetUserInternally(userId);
// place log record
TaskManager.StartTask(taskId, "USER", "CHANGE_STATUS", user.Username);
TaskManager.ItemId = user.UserId;
try
{
// change this account
result = ChangeUserStatusInternal(userId, status);
if (result < 0)
{
return(result);
}
// change peer accounts
List <UserInfo> peers = GetUserPeers(userId);
foreach (UserInfo peer in peers)
{
result = ChangeUserStatusInternal(peer.UserId, status);
if (result < 0)
{
return(result);
}
}
// change child accounts
List <UserInfo> children = GetUsers(userId, true);
foreach (UserInfo child in children)
{
result = ChangeUserStatusInternal(child.UserId, status);
if (result < 0)
{
return(result);
}
}
// update user packages
List <PackageInfo> packages = new List <PackageInfo>();
// his packages
packages.AddRange(PackageController.GetMyPackages(userId));
// children packages
packages.AddRange(PackageController.GetPackages(userId));
PackageStatus packageStatus = PackageStatus.Active;
switch (status)
{
case UserStatus.Active: packageStatus = PackageStatus.Active; break;
case UserStatus.Cancelled: packageStatus = PackageStatus.Cancelled; break;
case UserStatus.Pending: packageStatus = PackageStatus.New; break;
case UserStatus.Suspended: packageStatus = PackageStatus.Suspended; break;
}
// change packages state
result = PackageController.ChangePackagesStatus(packages, packageStatus, true);
if (result < 0)
{
return(result);
}
return(0);
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int ZipRemoteFiles(int packageId, string rootFolder, string[] files, string archivePath)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// check package
int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// place log record
TaskManager.StartTask("FILES", "ZIP_FILES", archivePath, packageId);
if (files != null)
{
foreach (string file in files)
{
TaskManager.Write(file);
}
}
try
{
OS.OperatingSystem os = GetOS(packageId);
string zipFilePath = GetFullPackagePath(packageId, archivePath);
List <string> archFiles = new List <string>();
string root = String.IsNullOrEmpty(rootFolder) ? "" : GetFullPackagePath(packageId, rootFolder);
foreach (string file in files)
{
string archFile = GetFullPackagePath(packageId, file);
if (!String.IsNullOrEmpty(rootFolder))
{
archFiles.Add(archFile.Substring(root.Length + 1));
}
else
{
int idx = archFile.LastIndexOf("\\");
root = archFile.Substring(0, idx);
archFiles.Add(archFile.Substring(idx + 1));
}
}
os.ZipFiles(zipFilePath, root, archFiles.ToArray());
return(0);
}
catch (Exception ex)
{
//Log and return a generic error rather than throwing an exception
TaskManager.WriteError(ex);
return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int MoveFiles(int packageId, string[] files, string destFolder)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
// check dest folder exists
if (!DirectoryExists(packageId, destFolder))
{
return(BusinessErrorCodes.ERROR_FILE_DEST_FOLDER_NONEXISTENT);
}
// place log record
TaskManager.StartTask("FILES", "MOVE_FILES", packageId);
TaskManager.WriteParameter("Destination folder", destFolder);
if (files != null)
{
foreach (string file in files)
{
TaskManager.Write(file);
}
}
try
{
OS.OperatingSystem os = GetOS(packageId);
string destFullFolder = GetFullPackagePath(packageId, destFolder);
for (int i = 0; i < files.Length; i++)
{
string srcFilePath = GetFullPackagePath(packageId, files[i]);
string destFilePath = Path.Combine(destFullFolder,
srcFilePath.Substring(srcFilePath.LastIndexOf("\\") + 1));
if (srcFilePath == destFilePath)
{
return(BusinessErrorCodes.ERROR_FILE_COPY_TO_SELF);
}
//Check that we're not trying to copy a folder into its own subfolder
else if (destFilePath.StartsWith(srcFilePath + "\\"))
{
return(BusinessErrorCodes.ERROR_FILE_COPY_TO_OWN_SUBFOLDER);
}
else if (os.FileExists(destFilePath) || os.DirectoryExists(destFilePath))
{
return(BusinessErrorCodes.ERROR_FILE_MOVE_PATH_ALREADY_EXISTS);
}
else
{
os.MoveFile(srcFilePath, destFilePath);
}
}
return(0);
}
catch (Exception ex)
{
//Log and return a generic error rather than throwing an exception
TaskManager.WriteError(ex);
return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED);
}
finally
{
TaskManager.CompleteTask();
}
}
public static int Restore(bool async, string taskId, int userId, int packageId, int serviceId, int serverId,
int storePackageId, string storePackageBackupPath, string storeServerBackupPath)
{
// check demo account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
if (accountCheck < 0)
{
return(accountCheck);
}
// check admin account
accountCheck = SecurityContext.CheckAccount(DemandAccount.IsAdmin);
if ((serviceId > 0 || serverId > 0) && accountCheck < 0)
{
return(accountCheck);
}
// check if backup temp folder is available
string tempFolder = GetTempBackupFolder();
if (!FolderWriteAccessible(tempFolder))
{
return(BusinessErrorCodes.ERROR_BACKUP_TEMP_FOLDER_UNAVAILABLE);
}
// check server source path if required
if (!String.IsNullOrEmpty(storeServerBackupPath))
{
try
{
if (!File.Exists(storeServerBackupPath))
{
return(BusinessErrorCodes.ERROR_RESTORE_BACKUP_SOURCE_NOT_FOUND);
}
}
catch
{
return(BusinessErrorCodes.ERROR_RESTORE_BACKUP_SOURCE_UNAVAILABLE);
}
}
if (async)
{
BackupAsyncWorker worker = new BackupAsyncWorker();
worker.threadUserId = SecurityContext.User.UserId;
worker.taskId = taskId;
worker.userId = userId;
worker.packageId = packageId;
worker.serviceId = serviceId;
worker.serverId = serverId;
worker.storePackageId = storePackageId;
worker.storePackageBackupPath = storePackageBackupPath;
worker.storeServerBackupPath = storeServerBackupPath;
// run
worker.RestoreAsync();
return(0);
}
else
{
return(RestoreInternal(taskId, userId, packageId, serviceId, serverId,
storePackageId, storePackageBackupPath, storeServerBackupPath));
}
}
public static int Backup(bool async, string taskId, int userId, int packageId, int serviceId, int serverId,
string backupFileName, int storePackageId, string storePackageFolder, string storeServerFolder,
bool deleteTempBackup)
{
// check demo account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// check admin account
accountCheck = SecurityContext.CheckAccount(DemandAccount.IsAdmin);
if ((serviceId > 0 || serverId > 0) && accountCheck < 0)
{
return(accountCheck);
}
if (accountCheck < 0)
{
deleteTempBackup = true;
}
// check if backup temp folder is available
string tempFolder = GetTempBackupFolder();
if (!FolderWriteAccessible(tempFolder))
{
return(BusinessErrorCodes.ERROR_BACKUP_TEMP_FOLDER_UNAVAILABLE);
}
// check destination folder if required
if (!String.IsNullOrEmpty(storePackageFolder) &&
!RemoteServerFolderWriteAccessible(storePackageId, storePackageFolder))
{
return(BusinessErrorCodes.ERROR_BACKUP_DEST_FOLDER_UNAVAILABLE);
}
// check server folder if required
if (!String.IsNullOrEmpty(storeServerFolder) &&
!FolderWriteAccessible(storeServerFolder))
{
return(BusinessErrorCodes.ERROR_BACKUP_SERVER_FOLDER_UNAVAILABLE);
}
// check/reset delete flag
accountCheck = SecurityContext.CheckAccount(DemandAccount.IsAdmin);
if (accountCheck < 0 && !deleteTempBackup)
{
deleteTempBackup = true;
}
if (async)
{
BackupAsyncWorker worker = new BackupAsyncWorker();
worker.threadUserId = SecurityContext.User.UserId;
worker.taskId = taskId;
worker.userId = userId;
worker.packageId = packageId;
worker.serviceId = serviceId;
worker.serverId = serverId;
worker.backupFileName = backupFileName;
worker.storePackageId = storePackageId;
worker.storePackageFolder = storePackageFolder;
worker.storeServerFolder = storeServerFolder;
worker.deleteTempBackup = deleteTempBackup;
// run
worker.BackupAsync();
return(0);
}
else
{
return(BackupInternal(taskId, userId, packageId, serviceId, serverId,
backupFileName, storePackageId, storePackageFolder, storeServerFolder,
deleteTempBackup));
}
}
public static int ApplyEnableHardQuotaFeature(int packageId)
{
if (SecurityContext.CheckAccount(DemandAccount.IsActive | DemandAccount.IsAdmin | DemandAccount.NotDemo) != 0)
{
throw new Exception("This method could be called by serveradmin only.");
}
// place log record
TaskManager.StartTask("FILES", "APPLY_ENABLEHARDQUOTAFEATURE");
try
{
// request OS service
//int osId = PackageController.GetPackageServiceId(packageId, ResourceGroups.Os);
//if (osId == 0)
// return -1;
//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 -1;
List <PackageInfo> allPackages = PackageController.GetPackagePackages(packageId, true);
foreach (PackageInfo childPackage in allPackages)
{
// request OS service
int osId = PackageController.GetPackageServiceId(childPackage.PackageId, ResourceGroups.Os);
if (osId == 0)
{
continue;
}
OS.OperatingSystem os = new OS.OperatingSystem();
ServiceProviderProxy.Init(os, osId);
//Get operating system settings
StringDictionary osSesstings = ServerController.GetServiceSettings(osId);
string driveName = osSesstings["LocationDrive"];
if (String.IsNullOrEmpty(driveName))
{
continue;
}
string homeFolder = FilesController.GetHomeFolder(childPackage.PackageId);
FilesController.SetFolderQuota(childPackage.PackageId, homeFolder, driveName, Quotas.OS_DISKSPACE);
}
}
catch (Exception ex)
{
throw TaskManager.WriteError(ex);
}
finally
{
TaskManager.CompleteTask();
}
return(0);
}
public static int SetFolderQuota(int packageId, string path, string driveName, string quotas)
{
// check account
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
return(accountCheck);
}
// check package
int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive);
if (packageCheck < 0)
{
return(packageCheck);
}
// place log record
TaskManager.StartTask("FILES", "SET_QUOTA_ON_FOLDER", path, packageId);
try
{
// disk space quota
// This gets all the disk space allocated for a specific customer
// It includes the package Add Ons * Quatity + Hosting Plan System disk space value. //Quotas.OS_DISKSPACE
QuotaValueInfo diskSpaceQuota = PackageController.GetPackageQuota(packageId, quotas);
#region figure Quota Unit
// Quota Unit
string unit = String.Empty;
if (diskSpaceQuota.QuotaDescription.ToLower().Contains("gb"))
{
unit = "GB";
}
else if (diskSpaceQuota.QuotaDescription.ToLower().Contains("mb"))
{
unit = "MB";
}
else
{
unit = "KB";
}
#endregion
OS.OperatingSystem os = GetOS(packageId);
os.SetQuotaLimitOnFolder(path, driveName, QuotaType.Hard, diskSpaceQuota.QuotaAllocatedValue.ToString() + unit, 0, String.Empty, String.Empty);
return(0);
}
catch (Exception ex)
{
//Log and return a generic error rather than throwing an exception
TaskManager.WriteError(ex);
return(BusinessErrorCodes.ERROR_FILE_GENERIC_LOGGED);
}
finally
{
TaskManager.CompleteTask();
}
}