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); } }
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 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); }
public static byte[] GetFileBinaryChunk(int storageSpaceId, string path, int offset, int length) { var storageSpace = StorageSpacesController.GetStorageSpaceById(storageSpaceId); if (storageSpace == null) { throw new Exception(string.Format("Storage space with id={0} not found", storageSpaceId)); } var ss = GetStorageSpaceService(storageSpace.ServiceId); return(ss.GetFileBinaryChunk(path, offset, length)); }
private static IntResult CreateStorageSpaceFolderInternal(int storageSpaceId, string groupName, string organizationId, string folderName, long quotaInBytes, QuotaType quotaType) { var result = TaskManager.StartResultTask <IntResult>("STORAGE_SPACES", "CREATE_STORAGE_SPACE_FOLDER"); try { var storageSpace = StorageSpacesController.GetStorageSpaceById(storageSpaceId); if (storageSpace == null) { throw new Exception(string.Format("Storage space with id={0} not found", storageSpaceId)); } var ss = GetStorageSpaceService(storageSpace.ServiceId); var fullPath = CreateFilePath(storageSpace.Path, organizationId, groupName, folderName); ss.CreateFolder(fullPath); var shareName = GenerateShareName(organizationId, folderName); var share = ShareStorageSpaceFolderInternal(storageSpace.Id, fullPath, shareName); ss.UpdateFolderQuota(fullPath, quotaInBytes, quotaType); result.Value = DataProvider.CreateStorageSpaceFolder(folderName, storageSpace.Id, fullPath, share.UncPath, true, quotaType, quotaInBytes); } catch (Exception exception) { TaskManager.WriteError(exception); result.AddError("Error creating Storage Space folder", exception); if (result.Value > 0) { DataProvider.RemoveStorageSpaceFolder(result.Value); } } finally { if (!result.IsSuccess) { TaskManager.CompleteResultTask(result); } else { TaskManager.CompleteResultTask(); } } return(result); }
private static ResultObject UpdateStorageSpaceFolderInternal(int storageSpaceId, int storageSpaceFolderId, string organizationId, string groupName, string folderName, string uncPath, long quotaInBytes, QuotaType quotaType) { var result = TaskManager.StartResultTask <ResultObject>("STORAGE_SPACES", "UPDATE_STORAGE_SPACE_FOLDER"); try { var storageSpace = StorageSpacesController.GetStorageSpaceById(storageSpaceId); if (storageSpace == null) { throw new Exception(string.Format("Storage space with id={0} not found", storageSpaceId)); } var ss = StorageSpacesController.GetStorageSpaceService(storageSpace.ServiceId); var fullPath = CreateFilePath(storageSpace.Path, organizationId, groupName, folderName); if (quotaInBytes > 0) { ss.UpdateFolderQuota(fullPath, quotaInBytes, quotaType); } DataProvider.UpdateStorageSpaceFolder(storageSpaceFolderId, folderName, storageSpace.Id, fullPath, uncPath, false, quotaType, quotaInBytes); } catch (Exception exception) { TaskManager.WriteError(exception); result.AddError("Error removing Storage Space", exception); } finally { if (!result.IsSuccess) { TaskManager.CompleteResultTask(result); } else { TaskManager.CompleteResultTask(); } } return(result); }
private static StorageSpaceFolderShare ShareStorageSpaceFolderInternal(int storageSpaceId, string fullPath, string shareName) { var result = TaskManager.StartResultTask <ResultObject>("STORAGE_SPACES", "SHARE_STORAGE_SPACE_FOLDER"); try { var storageSpace = StorageSpacesController.GetStorageSpaceById(storageSpaceId); if (storageSpace == null) { throw new Exception(string.Format("Storage space with id={0} not found", storageSpaceId)); } var ss = StorageSpacesController.GetStorageSpaceService(storageSpace.ServiceId); var share = ss.ShareFolder(fullPath, shareName); if (share == null) { throw new Exception("Error sharin folder"); } return(share); } catch (Exception exception) { result.AddError("Error sharing Storage Space folder", exception); throw TaskManager.WriteError(exception); } finally { if (!result.IsSuccess) { TaskManager.CompleteResultTask(result); } else { TaskManager.CompleteResultTask(); } } }
private static List <SystemFile> SearchInStorageSpaceFolderInternal(int storageSpaceId, int storageSpaceFolderId, string searchPath, string searchValue) { var storageSpace = StorageSpacesController.GetStorageSpaceById(storageSpaceId); if (storageSpace == null) { throw new Exception(string.Format("Storage space with id={0} not found", storageSpaceId)); } var storageSpaceFolder = StorageSpacesController.GetStorageSpaceFolderById(storageSpaceFolderId); if (storageSpaceFolder == null) { throw new Exception(string.Format("Storage space folder with id={0} not found", storageSpaceFolderId)); } var origSearchPath = searchPath; var ss = GetStorageSpaceService(storageSpace.ServiceId); int index = searchPath.IndexOf(Path.DirectorySeparatorChar); if (index >= 0) { searchPath = searchPath.Substring(index + 1); searchPath = Path.Combine(storageSpaceFolder.Path, searchPath); } else { searchPath = storageSpaceFolder.Path; } var searchResults = ss.Search(new[] { searchPath }, searchValue, true).ToList(); foreach (var result in searchResults) { result.RelativeUrl = result.FullName.Replace(storageSpaceFolder.Path, Path.GetFileName(storageSpaceFolder.Path)); } return(searchResults); }
public StorageSpaceFolder CreateFolder(string organizationId, int itemId, string type, long quotaInBytes, QuotaType qoutaType) { var storageId = StorageSpacesController.FindBestStorageSpaceService(new DefaultStorageSpaceSelector(), ResourceGroups.HostedOrganizations, quotaInBytes); if (!storageId.IsSuccess) { throw new Exception(storageId.ErrorCodes.First()); } var folder = StorageSpacesController.CreateStorageSpaceFolder(storageId.Value, ResourceGroups.HostedOrganizations, organizationId, type, quotaInBytes, qoutaType); if (!folder.IsSuccess) { throw new Exception(string.Join("---------------------------------------", folder.ErrorCodes)); } DataProvider.AddOrganizationStoragSpacesFolder(itemId, type, folder.Value); return(StorageSpacesController.GetStorageSpaceFolderById(folder.Value)); }
public ResultObject DeleteFolder(int itemId, int folderId) { var result = TaskManager.StartResultTask <ResultObject>("ORGANIZATION_FOLDERS", "DELETE_FOLDER"); try { var folder = StorageSpacesController.GetStorageSpaceFolderById(folderId); if (folder == null) { throw new Exception("Folder not found"); } DataProvider.DeleteOrganizationStoragSpacesFolder(folderId); var deletionResult = StorageSpacesController.DeleteStorageSpaceFolder(folder.StorageSpaceId, folder.Id); if (deletionResult.IsSuccess == false) { throw new Exception(string.Join(";", deletionResult.ErrorCodes)); } } catch (Exception exception) { TaskManager.WriteError(exception); result.AddError("Error deleting organization folder", exception); } finally { if (!result.IsSuccess) { TaskManager.CompleteResultTask(result); } else { TaskManager.CompleteResultTask(); } } return(result); }
public List <StorageSpace> GetStorageSpacesByLevelId(int levelId) { return(StorageSpacesController.GetStorageSpacesByLevelId(levelId)); }
public void SetStorageSpaceFolderAbeStatus(int storageSpaceFolderId, bool enabled) { StorageSpacesController.SetStorageSpaceFolderAbeStatus(storageSpaceFolderId, enabled); }
public bool GetStorageSpaceFolderAbeStatus(int storageSpaceFolderId) { return(StorageSpacesController.GetStorageSpaceFolderAbeStatus(storageSpaceFolderId)); }
public void SetStorageSpaceFolderEncryptDataAccessStatus(int storageSpaceFolderId, bool enabled) { StorageSpacesController.SetStorageSpaceFolderEncryptDataAccessStatus(storageSpaceFolderId, enabled); }
public bool GetStorageSpaceFolderEncryptDataAccessStatus(int storageSpaceFolderId) { return(StorageSpacesController.GetStorageSpaceFolderEncryptDataAccessStatus(storageSpaceFolderId)); }
public bool CheckIsStorageSpacePathInUse(int serverId, string path, int currentServiceId) { return(StorageSpacesController.CheckIsStorageSpacePathInUse(serverId, path, currentServiceId)); }
public ResultObject RemoveStorageSpace(int id) { return(StorageSpacesController.RemoveStorageSpace(id)); }
public SystemFile[] GetSystemSubFolders(int serviceId, string path) { return(StorageSpacesController.GetSystemSubFolders(serviceId, path)); }
public IntResult SaveStorageSpace(StorageSpace space) { return(StorageSpacesController.SaveStorageSpace(space)); }
public IntResult SaveStorageSpaceLevel(StorageSpaceLevel level, List <ResourceGroupInfo> groups) { return(StorageSpacesController.SaveStorageSpaceLevel(level, groups)); }
public StorageSpacesPaged GetStorageSpacesPaged(string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows) { return(StorageSpacesController.GetStorageSpacesPaged(filterColumn, filterValue, sortColumn, startRow, maximumRows)); }
public ResultObject SaveLevelResourceGroups(int levelId, List <ResourceGroupInfo> newGroups) { return(StorageSpacesController.SaveLevelResourceGroups(levelId, newGroups)); }
public List <ResourceGroupInfo> GetLevelResourceGroups(int id) { return(StorageSpacesController.GetLevelResourceGroups(id)); }
public List <StorageSpaceFolder> GetStorageSpaceFoldersByStorageSpaceId(int id) { return(StorageSpacesController.GetStorageSpaceFoldersByStorageSpaceId(id)); }
public StorageSpace GetStorageSpaceById(int id) { return(StorageSpacesController.GetStorageSpaceById(id)); }
public SystemFile[] GetDriveLetters(int serviceId) { return(StorageSpacesController.GetDriveLetters(serviceId)); }