public void CalculatePackage(int packageId) { DateTime since = PackageController.GetPackageBandwidthUpdate(packageId); DateTime nextUpdate = DateTime.Now; try { // get all package items List <ServiceProviderItem> items = PackageController.GetServiceItemsForStatistics( 0, packageId, false, true, false, false); // order items by service Dictionary <int, List <ServiceProviderItem> > orderedItems = PackageController.OrderServiceItemsByServices(items); // calculate statistics for each service set List <ServiceProviderItemBandwidth> itemsBandwidth = new List <ServiceProviderItemBandwidth>(); foreach (int serviceId in orderedItems.Keys) { ServiceProviderItemBandwidth[] serviceBandwidth = CalculateItems(serviceId, orderedItems[serviceId], since); if (serviceBandwidth != null) { itemsBandwidth.AddRange(serviceBandwidth); } } // update info in the database string xml = BuildDiskBandwidthStatisticsXml(itemsBandwidth.ToArray()); PackageController.UpdatePackageBandwidth(packageId, xml); // if everything is OK // update date PackageController.UpdatePackageBandwidthUpdate(packageId, nextUpdate); // suspend package if requested if (suspendOverused) { // disk space QuotaValueInfo dsQuota = PackageController.GetPackageQuota(packageId, Quotas.OS_BANDWIDTH); if (dsQuota.QuotaExhausted) { PackageController.ChangePackageStatus(null, packageId, PackageStatus.Suspended, false); } } } catch (Exception ex) { // load package details PackageInfo package = PackageController.GetPackage(packageId); // load user details UserInfo user = PackageController.GetPackageOwner(package.PackageId); // log error TaskManager.WriteError(String.Format("Error calculating bandwidth for '{0}' space of user '{1}': {2}", package.PackageName, user.Username, ex.ToString())); } }
public static int SetFilePermissions(int packageId, string path, UserPermission[] users, bool resetChildPermissions) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // place log record TaskManager.StartTask("FILES", "SET_PERMISSIONS", path, packageId); try { OS.OperatingSystem os = GetOS(packageId); string fullPath = GetFullPackagePath(packageId, path); // get users OU defined on web server string usersOU = WebServerController.GetWebUsersOU(packageId); os.GrantGroupNtfsPermissions(fullPath, users, usersOU, resetChildPermissions); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int CloseTerminalServicesSession(int serverId, int sessionId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // load server info ServerInfo server = ServerController.GetServerById(serverId, false); // place log record TaskManager.StartTask("SERVER", "RESET_TERMINAL_SESSION", sessionId, serverId); try { GetServerService(serverId).CloseTerminalServicesSession(sessionId); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
private static ResultObject RemoveStorageSpaceLevelInternal(int id) { var result = TaskManager.StartResultTask <ResultObject>("STORAGE_SPACES", "REMOVE_STORAGE_SPACE_LEVEL"); try { if (id < 1) { throw new ArgumentException("Id must be greater than 0"); } DataProvider.RemoveStorageSpaceLevel(id); } catch (Exception exception) { TaskManager.WriteError(exception); result.AddError("Error removing Storage Space Level", exception); } finally { if (!result.IsSuccess) { TaskManager.CompleteResultTask(result); } else { TaskManager.CompleteResultTask(); } } return(result); }
private static int BackupItem(string tempFolder, XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group, IBackupController controller) { writer.WriteStartElement("Item"); writer.WriteAttributeString("itemId", item.Id.ToString()); writer.WriteAttributeString("itemTypeId", item.TypeId.ToString()); writer.WriteAttributeString("itemName", item.Name); writer.WriteAttributeString("packageId", item.PackageId.ToString()); writer.WriteAttributeString("serviceId", item.ServiceId.ToString()); try { return(controller.BackupItem(tempFolder, writer, item, group)); } catch (Exception ex) { TaskManager.WriteError(ex); } finally { writer.WriteEndElement(); // Item } return(0); }
public static int BackupItem(string tempFolder, XmlWriter writer, ServiceProviderItem item) { // load item type ServiceProviderItemType itemType = PackageController.GetServiceItemType(item.TypeId); if (!itemType.Backupable) { return(-1); } // load group ResourceGroupInfo group = ServerController.GetResourceGroup(itemType.GroupId); // create controller IBackupController controller = null; try { controller = Activator.CreateInstance(Type.GetType(group.GroupController)) as IBackupController; if (controller != null) { return(BackupItem(tempFolder, writer, item, group, controller)); } } catch (Exception ex) { TaskManager.WriteError(ex); } return(-2); }
private static ResultObject DeleteStorageSpaceFolderInternal(int storageSpaceId, int storageSpaceFolderId) { var result = TaskManager.StartResultTask <IntResult>("STORAGE_SPACES", "DELETE_STORAGE_SPACE_FOLDER"); try { if (storageSpaceId < 0) { throw new ArgumentException("Storage Space iD must be greater than 0"); } var storage = GetStorageSpaceById(storageSpaceId); if (storage == null) { throw new Exception(string.Format("Storage space with id={0} not found", storageSpaceId)); } var storageFolder = GetStorageSpaceFolderById(storageSpaceFolderId); if (storageFolder == null) { throw new Exception(string.Format("Storage Space folder with id={0} not found", storageSpaceFolderId)); } var ss = GetStorageSpaceService(storage.ServiceId); if (storageFolder.IsShared) { ss.RemoveShare(storageFolder.Path); } ss.DeleteFolder(storageFolder.Path); DataProvider.RemoveStorageSpaceFolder(storageSpaceFolderId); } catch (Exception exception) { TaskManager.WriteError(exception); result.AddError("Error removing Storage Space folder", exception); if (result.Value > 0) { DataProvider.RemoveStorageSpaceFolder(result.Value); } } finally { if (!result.IsSuccess) { TaskManager.CompleteResultTask(result); } else { TaskManager.CompleteResultTask(); } } return(result); }
public ResultObject DeleteFolders(int itemId) { var result = TaskManager.StartResultTask <ResultObject>("ORGANIZATION_FOLDERS", "DELETE_ALL_FOLDERS"); try { foreach (var storageSpaceFolderType in Enum.GetValues(typeof(StorageSpaceFolderTypes))) { DeleteFolders(itemId, storageSpaceFolderType.ToString()); } } catch (Exception exception) { TaskManager.WriteError(exception); result.AddError("Error deleting organization folders", exception); } finally { if (!result.IsSuccess) { TaskManager.CompleteResultTask(result); } else { TaskManager.CompleteResultTask(); } } return(result); }
private static void RunBackgroundTask(BackgroundTask backgroundTask) { UserInfo user = PackageController.GetPackageOwner(backgroundTask.PackageId); SecurityContext.SetThreadPrincipal(user.UserId); var schedule = SchedulerController.GetScheduleComplete(backgroundTask.ScheduleId); backgroundTask.Guid = TaskManager.Guid; backgroundTask.Status = BackgroundTaskStatus.Run; TaskController.UpdateTask(backgroundTask); try { var objTask = (SchedulerTask)Activator.CreateInstance(Type.GetType(schedule.Task.TaskType)); objTask.DoWork(); } catch (Exception ex) { TaskManager.WriteError(ex, "Error executing scheduled task"); } finally { try { TaskManager.CompleteTask(); } catch (Exception) { } } }
public static int TerminateWindowsProcess(int serverId, int pid) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // load server info ServerInfo server = ServerController.GetServerById(serverId); // place log record TaskManager.StartTask("SERVER", "TERMINATE_SYSTEM_PROCESS", pid); TaskManager.ItemId = serverId; try { GetServerService(serverId).TerminateWindowsProcess(pid); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
private static void SetStorageSpaceFolderEncryptDataAccessStatusInternal(int storageSpaceFolderId, bool enabled) { TaskManager.StartTask("STORAGE_SPACES", "SET_ENCRYPT_DATA_ACCESS_STATUS"); try { var folder = GetStorageSpaceFolderById(storageSpaceFolderId); if (folder == null) { throw new Exception(string.Format("Storage space folder with id={0} not found", storageSpaceFolderId)); } var storageSpace = StorageSpacesController.GetStorageSpaceById(folder.StorageSpaceId); if (storageSpace == null) { throw new Exception(string.Format("Storage space with id={0} not found", folder.StorageSpaceId)); } var ss = GetStorageSpaceService(storageSpace.ServiceId); ss.ShareSetEncyptDataAccess(folder.Path, enabled); } catch (Exception exception) { throw TaskManager.WriteError(exception); } finally { TaskManager.CompleteTask(); } }
private static bool GetStorageSpaceFolderEncryptDataAccessStatusInternal(int storageSpaceFolderId) { try { var folder = GetStorageSpaceFolderById(storageSpaceFolderId); if (folder == null) { throw new Exception(string.Format("Storage space folder with id={0} not found", storageSpaceFolderId)); } var storageSpace = StorageSpacesController.GetStorageSpaceById(folder.StorageSpaceId); if (storageSpace == null) { throw new Exception(string.Format("Storage space with id={0} not found", folder.StorageSpaceId)); } var ss = GetStorageSpaceService(storageSpace.ServiceId); return(ss.ShareGetEncyptDataAccessStatus(folder.Path)); } catch (Exception exception) { throw TaskManager.WriteError(exception); } }
public static int ChangeUserPassword(string username, string oldPassword, string newPassword, string ip) { // place log record TaskManager.StartTask("USER", "CHANGE_PASSWORD_BY_USERNAME_PASSWORD", username); TaskManager.WriteParameter("IP", ip); try { UserInfo user = GetUserByUsernamePassword(username, oldPassword, ip); if (user == null) { TaskManager.WriteWarning("Account not found"); return(BusinessErrorCodes.ERROR_USER_NOT_FOUND); } // change password DataProvider.ChangeUserPassword(-1, user.UserId, CryptoUtils.Encrypt(newPassword)); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int ChangeUserPassword(int userId, string password) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // get user details UserInfo user = GetUserInternally(userId); // place log record TaskManager.StartTask("USER", "CHANGE_PASSWORD", user.Username, user.UserId); try { DataProvider.ChangeUserPassword(SecurityContext.User.UserId, userId, CryptoUtils.Encrypt(password)); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int ClearLog(int serverId, string logName) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } TaskManager.StartTask("SERVER", "CLEAR_EVENT_LOG", logName); TaskManager.ItemId = serverId; try { GetServerService(serverId).ClearLog(logName); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } return(0); }
public static int RebootSystem(int serverId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // load server info ServerInfo server = ServerController.GetServerById(serverId); // place log record TaskManager.StartTask("SERVER", "REBOOT"); TaskManager.ItemId = serverId; try { GetServerService(serverId).RebootSystem(); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int CalculatePackageDiskspace(int packageId) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo); if (accountCheck < 0) { return(accountCheck); } // place log record TaskManager.StartTask("SPACE", "CALCULATE_DISKSPACE", packageId); try { // create thread parameters ThreadStartParameters prms = new ThreadStartParameters(); prms.UserId = SecurityContext.User.UserId; prms.Parameters = new object[] { packageId }; Thread t = new Thread(new ParameterizedThreadStart(CalculatePackageDiskspaceAsync)); t.Start(prms); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int ChangeWindowsServiceStatus(int serverId, string id, WindowsServiceStatus status) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsAdmin | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // load server info ServerInfo server = ServerController.GetServerById(serverId); // place log record TaskManager.StartTask("SERVER", "CHANGE_WINDOWS_SERVICE_STATUS", id); TaskManager.ItemId = serverId; TaskManager.WriteParameter("New Status", status); try { GetServerService(serverId).ChangeWindowsServiceStatus(id, status); return(0); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public ResultObject DeleteFolders(int itemId, string type) { var result = TaskManager.StartResultTask <ResultObject>("ORGANIZATION_FOLDERS", "DELETE_FOLDERS_BY_TYPE"); try { var folders = GetFolders(itemId, type); foreach (var folder in folders) { DeleteFolder(itemId, folder.Id); } } catch (Exception exception) { TaskManager.WriteError(exception); result.AddError("Error deleting organization folders", exception); } finally { if (!result.IsSuccess) { TaskManager.CompleteResultTask(result); } else { TaskManager.CompleteResultTask(); } } return(result); }
public int BackupItem(string tempFolder, XmlWriter writer, ServiceProviderItem item, ResourceGroupInfo group) { if (!(item is DnsZone)) { return(0); } // DNS provider DNSServer dns = GetDNSServer(item.ServiceId); // zone records serialized XmlSerializer serializer = new XmlSerializer(typeof(DnsRecord)); try { // get zone records DnsRecord[] records = dns.GetZoneRecords(item.Name); // serialize zone records foreach (DnsRecord record in records) { serializer.Serialize(writer, record); } } catch (Exception ex) { TaskManager.WriteError(ex, "Could not read zone records"); } return(0); }
private static IntResult FindBestStorageSpaceServiceInternal(IStorageSpaceSelector selector, string groupName, long quotaSizeBytes) { var result = TaskManager.StartResultTask <IntResult>("STORAGE_SPACES", "FIND_BEST_STORAGE_SPACE_SERVICE"); try { var bestStorage = selector.FindBest(groupName, quotaSizeBytes); result.Value = bestStorage.Id; } catch (Exception exception) { TaskManager.WriteError(exception); result.AddError("Error finding best Storage Space", exception); } finally { if (!result.IsSuccess) { TaskManager.CompleteResultTask(result); } else { TaskManager.CompleteResultTask(); } } return(result); }
public static UserInfo GetUserByUsernamePassword(string username, string password, string ip) { // place log record TaskManager.StartTask("USER", "GET_BY_USERNAME_PASSWORD", username); TaskManager.WriteParameter("IP", ip); try { // try to get user from database UserInfoInternal user = GetUserInternally(username); // check if the user exists if (user == null) { TaskManager.WriteWarning("Account not found"); return(null); } // compare user passwords if ((CryptoUtils.SHA1(user.Password) == password) || (user.Password == password)) { return(new UserInfo(user)); } return(null); } catch (Exception ex) { throw TaskManager.WriteError(ex); } finally { TaskManager.CompleteTask(); } }
public static int SetupControlPanelAccounts(string passwordA, string passwordB, string ip) { try { TaskManager.StartTask("SYSTEM", "COMPLETE_SCPA"); // TaskManager.WriteParameter("Password A", passwordA); TaskManager.WriteParameter("Password B", passwordB); TaskManager.WriteParameter("IP Address", ip); // var enabledScpaMode = GetSystemSetupMode(); // if (enabledScpaMode == false) { // TaskManager.WriteWarning("Attempt to execute SCPA procedure for an uknown reason"); // return(BusinessErrorCodes.FAILED_EXECUTE_SERVICE_OPERATION); } // Entering the security context into Supervisor mode SecurityContext.SetThreadSupervisorPrincipal(); // var accountA = UserController.GetUserInternally("serveradmin"); var accountB = UserController.GetUserInternally("admin"); // var resultCodeA = UserController.ChangeUserPassword(accountA.UserId, passwordA); // if (resultCodeA < 0) { TaskManager.WriteParameter("Result Code A", resultCodeA); // return(resultCodeA); } // var resultCodeB = UserController.ChangeUserPassword(accountB.UserId, passwordB); // if (resultCodeB < 0) { TaskManager.WriteParameter("Result Code B", resultCodeB); // return(resultCodeB); } // Disable SCPA mode SetSystemSettings(SystemSettings.SETUP_SETTINGS, SystemSettings.Empty); // Operation has succeeded return(0); } catch (Exception ex) { TaskManager.WriteError(ex); // return(BusinessErrorCodes.FAILED_EXECUTE_SERVICE_OPERATION); } finally { TaskManager.CompleteTask(); } }
public static int UpdateSqlUser(SqlUser item) { // check account int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive); if (accountCheck < 0) { return(accountCheck); } // load original meta item SqlUser origItem = (SqlUser)PackageController.GetPackageItem(item.Id); if (origItem == null) { return(BusinessErrorCodes.ERROR_MSSQL_USERS_PACKAGE_ITEM_NOT_FOUND); } // check package int packageCheck = SecurityContext.CheckPackage(origItem.PackageId, DemandPackage.IsActive); if (packageCheck < 0) { return(packageCheck); } // place log record TaskManager.StartTask("SQL_USER", "UPDATE", origItem.Name, item.Id); try { // get service DatabaseServer sql = GetDatabaseServer(origItem.ServiceId); // update service item sql.UpdateUser(item, GetSqlDatabasesArray(origItem.PackageId, origItem.GroupName)); // update meta item if (item.Password == "") { item.Password = CryptoUtils.Decrypt(origItem.Password); } item.Password = CryptoUtils.Encrypt(item.Password); PackageController.UpdatePackageItem(item); 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 ZipFiles(int packageId, 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 rootFolder = ""; foreach (string file in files) { string archFile = GetFullPackagePath(packageId, file); int idx = archFile.LastIndexOf("\\"); rootFolder = archFile.Substring(0, idx); archFiles.Add(archFile.Substring(idx + 1)); } os.ZipFiles(zipFilePath, rootFolder, 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(); } }
private static IntResult SaveStorageSpaceInternal(StorageSpace space, bool isShared = false) { var result = TaskManager.StartResultTask <IntResult>("STORAGE_SPACES", "SAVE_STORAGE_SPACE"); try { if (space == null) { throw new ArgumentNullException("space"); } var ss = GetStorageSpaceService(space.ServiceId); if (isShared) { var share = ShareStorageSpaceFolderInternal(space.Id, space.Path, space.Name); space.IsShared = true; space.UncPath = share.UncPath; } if (space.Id > 0) { DataProvider.UpdateStorageSpace(space); TaskManager.Write("Updating Storage Space with id = {0}", space.Id.ToString(CultureInfo.InvariantCulture)); result.Value = space.Id; } else { result.Value = DataProvider.InsertStorageSpace(space); TaskManager.Write("Inserting new Storage Space, obtained id = {0}", space.Id.ToString(CultureInfo.InvariantCulture)); space.Id = result.Value; } ss.UpdateStorageSettings(space.Path, space.FsrmQuotaSizeBytes, space.FsrmQuotaType); } catch (Exception exception) { TaskManager.WriteError(exception); result.AddError("Error saving Storage Space", exception); } finally { if (!result.IsSuccess) { TaskManager.CompleteResultTask(result); } else { TaskManager.CompleteResultTask(); } } return(result); }
public void CalculatePackage(int packageId) { try { // get all package items List <ServiceProviderItem> items = PackageController.GetServiceItemsForStatistics( 0, packageId, true, false, false, false); //TaskManager.Write("Items: " + items.Count); // order items by service Dictionary <int, List <ServiceProviderItem> > orderedItems = PackageController.OrderServiceItemsByServices(items); // calculate statistics for each service set List <ServiceProviderItemDiskSpace> itemsDiskspace = new List <ServiceProviderItemDiskSpace>(); foreach (int serviceId in orderedItems.Keys) { ServiceProviderItemDiskSpace[] serviceDiskspace = CalculateItems(serviceId, orderedItems[serviceId]); if (serviceDiskspace != null) { itemsDiskspace.AddRange(serviceDiskspace); } } // update info in the database string xml = BuildDiskSpaceStatisticsXml(itemsDiskspace.ToArray()); PackageController.UpdatePackageDiskSpace(packageId, xml); //TaskManager.Write("XML: " + xml); // suspend package if requested if (suspendOverused) { // disk space QuotaValueInfo dsQuota = PackageController.GetPackageQuota(packageId, Quotas.OS_DISKSPACE); if (dsQuota.QuotaExhausted) { PackageController.ChangePackageStatus(null, packageId, PackageStatus.Suspended, false); } } } catch (Exception ex) { // load package details PackageInfo package = PackageController.GetPackage(packageId); // load user details UserInfo user = PackageController.GetPackageOwner(package.PackageId); // log error TaskManager.WriteError(String.Format("Error calculating diskspace for '{0}' space of user '{1}': {2}", package.PackageName, user.Username, ex.ToString())); } }
private static IntResult SaveStorageSpaceLevelInternal(StorageSpaceLevel level, List <ResourceGroupInfo> groups) { var result = TaskManager.StartResultTask <IntResult>("STORAGE_SPACES", "SAVE_STORAGE_SPACE_LEVEL"); try { if (level == null) { throw new ArgumentNullException("level"); } if (level.Id > 0) { DataProvider.UpdateStorageSpaceLevel(level); TaskManager.Write("Updating Storage Space Level with id = {0}", level.Id.ToString(CultureInfo.InvariantCulture)); result.Value = level.Id; } else { result.Value = DataProvider.InsertStorageSpaceLevel(level); TaskManager.Write("Inserting new Storage Space Level, obtained id = {0}", level.Id.ToString(CultureInfo.InvariantCulture)); level.Id = result.Value; } var resultGroup = SaveLevelResourceGroups(result.Value, groups); if (!resultGroup.IsSuccess) { throw new Exception("Error saving resource groups"); } } catch (Exception exception) { TaskManager.WriteError(exception); result.AddError("Error saving Storage Space Level", exception); } finally { if (!result.IsSuccess) { TaskManager.CompleteResultTask(result); } else { TaskManager.CompleteResultTask(); } } return(result); }
private static ResultObject RenameFolderInternal(int storageSpaceId, int folderId, string organizationId, string group, string fullPath, string newName) { var result = TaskManager.StartResultTask <ResultObject>("STORAGE_SPACES", "RENAME_FOLDER"); try { if (storageSpaceId < 0) { throw new ArgumentException("Storage Space iD must be greater than 0"); } var storage = GetStorageSpaceById(storageSpaceId); if (storage == null) { throw new Exception(string.Format("Storage space with id={0} not found", storageSpaceId)); } var ss = GetStorageSpaceService(storage.ServiceId); ss.RemoveShare(fullPath); ss.RenameFolder(fullPath, newName); var newPath = Path.Combine(Directory.GetParent(fullPath).ToString(), newName); var shareName = GenerateShareName(organizationId, newName); var share = ShareStorageSpaceFolderInternal(storageSpaceId, newPath, shareName); var folder = GetStorageSpaceFolderById(folderId); StorageSpacesController.UpdateStorageSpaceFolder(storageSpaceId, folderId, organizationId, group, newName, share.UncPath, folder.FsrmQuotaSizeBytes, folder.FsrmQuotaType); } catch (Exception exception) { TaskManager.WriteError(exception); result.AddError("Error during folder rename", exception); } finally { if (!result.IsSuccess) { TaskManager.CompleteResultTask(result); } else { TaskManager.CompleteResultTask(); } } return(result); }
private static ResultObject SetStorageSpaceFolderQuotaInternal(int storageSpaceId, int storageSpaceFolderId, long quotaInBytes, QuotaType quotaType) { var result = TaskManager.StartResultTask <IntResult>("STORAGE_SPACES", "SET_STORAGE_SPACE_FOLDER_QUOTA"); try { if (storageSpaceId < 0) { throw new ArgumentException("Storage Space iD must be greater than 0"); } var storage = GetStorageSpaceById(storageSpaceId); if (storage == null) { throw new Exception(string.Format("Storage space with id={0} not found", storageSpaceId)); } var storageFolder = GetStorageSpaceFolderById(storageSpaceFolderId); if (storageFolder == null) { throw new Exception(string.Format("Storage Space folder with id={0} not found", storageSpaceFolderId)); } SetFolderQuota(storageSpaceId, storageFolder.Path, quotaInBytes, quotaType); DataProvider.UpdateStorageSpaceFolder(storageSpaceFolderId, storageFolder.Name, storageSpaceId, storageFolder.Path, storageFolder.UncPath, storageFolder.IsShared, quotaType, quotaInBytes); } catch (Exception exception) { TaskManager.WriteError(exception); result.AddError("Error removing Storage Space folder", exception); if (result.Value > 0) { DataProvider.RemoveStorageSpaceFolder(result.Value); } } finally { if (!result.IsSuccess) { TaskManager.CompleteResultTask(result); } else { TaskManager.CompleteResultTask(); } } return(result); }