public override bool FolderExists(string folderPath, FolderMappingInfo folderMapping) { Requires.NotNull("folderPath", folderPath); Requires.NotNull("folderMapping", folderMapping); return(DirectoryWrapper.Instance.Exists(PathUtils.Instance.GetPhysicalPath(folderMapping.PortalID, folderPath))); }
public override bool FolderExists(string folderPath, FolderMappingInfo folderMapping) { Requires.PropertyNotNull("folderPath", folderPath); Requires.NotNull("folderMapping", folderMapping); return(DirectoryWrapper.Instance.Exists(GetActualPath(folderMapping, folderPath))); }
public override bool FolderExists(string folderPath, FolderMappingInfo folderMapping) { Requires.PropertyNotNull("folderPath", folderPath); Requires.NotNull("folderMapping", folderMapping); return(FolderManager.Instance.GetFolder(folderMapping.PortalID, folderPath) != null); }
/// <summary> /// Moves the folder and files at the specified folder path to the new folder path. /// </summary> public virtual void MoveFolder(string folderPath, string newFolderPath, FolderMappingInfo folderMapping) { Requires.NotNullOrEmpty("folderPath", folderPath); Requires.NotNullOrEmpty("newFolderPath", newFolderPath); Requires.NotNull("folderMapping", folderMapping); var folderProvider = Instance(folderMapping.FolderProviderType); AddFolderAndMoveFiles(folderPath, newFolderPath, folderMapping); var folderManager = new FolderManager(); var subFolders = folderManager.GetFolderMappingFoldersRecursive(folderMapping, folderPath).Skip(1).Reverse(); foreach (var subFolderPath in subFolders.Select(s => s.Key)) { var newSubFolderPath = newFolderPath + subFolderPath.Substring(folderPath.Length); AddFolderAndMoveFiles(subFolderPath, newSubFolderPath, folderMapping); folderProvider.DeleteFolder(new FolderInfo { FolderPath = subFolderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.FolderMappingID }); } folderProvider.DeleteFolder(new FolderInfo { FolderPath = folderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.PortalID }); }
private static void MoveFiles(IFolderInfo folder, IFolderInfo newFolder, FolderMappingInfo folderMapping) { var folderProvider = Instance(folderMapping.FolderProviderType); var files = folderProvider.GetFiles(folder); foreach (var file in files) { using (var fileContent = folderProvider.GetFileStream(folder, file)) { if (!fileContent.CanSeek) { using (var seekableStream = FileManager.Instance.GetSeekableStream(fileContent)) { folderProvider.AddFile(newFolder, file, seekableStream); } } else { folderProvider.AddFile(newFolder, file, fileContent); } } folderProvider.DeleteFile(new FileInfo { FileName = file, Folder = folder.FolderPath, FolderMappingID = folderMapping.FolderMappingID, PortalId = folderMapping.PortalID }); } }
/// <summary> /// Copies the specified file to the destination folder. /// </summary> public virtual void CopyFile(string folderPath, string fileName, string newFolderPath, FolderMappingInfo folderMapping) { Requires.NotNull("folderPath", folderPath); Requires.NotNullOrEmpty("fileName", fileName); Requires.NotNull("newFolderPath", newFolderPath); Requires.NotNull("folderMapping", folderMapping); if (folderPath == newFolderPath) return; var sourceFolder = new FolderInfo { FolderPath = folderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.PortalID }; var destinationFolder = new FolderInfo { FolderPath = newFolderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.PortalID }; using (var fileContent = GetFileStream(sourceFolder, fileName)) { if (!fileContent.CanSeek) { using (var seekableStream = FileManager.Instance.GetSeekableStream(fileContent)) { AddFile(destinationFolder, fileName, seekableStream); } } else { AddFile(destinationFolder, fileName, fileContent); } } }
public override bool FolderExists(string folderPath, FolderMappingInfo folderMapping) { Requires.NotNull("folderPath", folderPath); Requires.NotNull("folderMapping", folderMapping); return(DataProvider.Instance().GetFolder(folderMapping.PortalID, folderPath).Read()); }
public override IEnumerable <string> GetSubFolders(string folderPath, FolderMappingInfo folderMapping) { Requires.PropertyNotNull("folderPath", folderPath); Requires.NotNull("folderMapping", folderMapping); return(DirectoryWrapper.Instance.GetDirectories(GetActualPath(folderMapping, folderPath)) .Select(directory => GetRelativePath(folderMapping, directory))); }
public override IEnumerable <string> GetSubFolders(string folderPath, FolderMappingInfo folderMapping) { Requires.NotNull("folderPath", folderPath); Requires.NotNull("folderMapping", folderMapping); return(DirectoryWrapper.Instance.GetDirectories(PathUtils.Instance.GetPhysicalPath(folderMapping.PortalID, folderPath)) .Select(directory => PathUtils.Instance.GetRelativePath(folderMapping.PortalID, directory))); }
private static void UpdateFolderMappingSettings(FolderMappingInfo objFolderMapping) { foreach (string sKey in objFolderMapping.FolderMappingSettings.Keys) { UpdateFolderMappingSetting(objFolderMapping.FolderMappingID, sKey, Convert.ToString(objFolderMapping.FolderMappingSettings[sKey])); } ClearFolderMappingSettingsCache(objFolderMapping.FolderMappingID); }
public void UpdateFolderMapping(FolderMappingInfo objFolderMapping) { dataProvider.UpdateFolderMapping(objFolderMapping.FolderMappingID, objFolderMapping.MappingName, objFolderMapping.Priority, UserController.Instance.GetCurrentUserInfo().UserID); ClearFolderMappingCache(objFolderMapping.PortalID); UpdateFolderMappingSettings(objFolderMapping); }
public override IEnumerable <string> GetSubFolders(string folderPath, FolderMappingInfo folderMapping) { Requires.PropertyNotNull("folderPath", folderPath); Requires.NotNull("folderMapping", folderMapping); var folderManager = FolderManager.Instance; var folder = folderManager.GetFolder(folderMapping.PortalID, folderPath); return(folderManager.GetFolders(folder).Select(subfolder => subfolder.FolderPath)); }
public int AddFolderMapping(FolderMappingInfo objFolderMapping) { objFolderMapping.FolderMappingID = dataProvider.AddFolderMapping(objFolderMapping.PortalID, objFolderMapping.MappingName, objFolderMapping.FolderProviderType, UserController.Instance.GetCurrentUserInfo().UserID); UpdateFolderMappingSettings(objFolderMapping); ClearFolderMappingCache(objFolderMapping.PortalID); return(objFolderMapping.FolderMappingID); }
public override void CopyFile(string folderPath, string fileName, string newFolderPath, FolderMappingInfo folderMapping) { Requires.NotNull("folderPath", folderPath); Requires.NotNullOrEmpty("fileName", fileName); Requires.NotNull("newFolderPath", newFolderPath); Requires.NotNull("folderMapping", folderMapping); if (folderPath == newFolderPath) return; var filePath = GetActualPath(folderMapping, folderPath, fileName); var newFilePath = GetActualPath(folderMapping, newFolderPath, fileName); if (FileWrapper.Instance.Exists(filePath)) { FileWrapper.Instance.Copy(filePath, newFilePath, true); } }
public void DeleteFile_Calls_FolderProviderDeleteFile() { //Arrange var fileInfo = new FileInfoBuilder().Build(); _fileVersionController.Setup(fv => fv.DeleteAllUnpublishedVersions(fileInfo, false)); var folderMapping = new FolderMappingInfo { FolderProviderType = Constants.FOLDER_ValidFolderProviderType }; _folderMappingController.Setup(fmc => fmc.GetFolderMapping(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping); _mockData.Setup(md => md.DeleteFile(It.IsAny<int>(), It.IsAny<string>(), It.IsAny<int>())); _mockFolderProvider.Setup(mf => mf.DeleteFile(fileInfo)).Verifiable(); string someString; _mockFileLockingController.Setup(mflc => mflc.IsFileLocked(fileInfo, out someString)).Returns(false); //Act FileDeletionController.Instance.DeleteFile(fileInfo); //Assert _mockFolderProvider.Verify(); }
/// <summary> /// Get the path relative to the root of the FolderMapping /// </summary> /// <param name="folderMapping">Path is relative to this</param> /// <param name="path">The path</param> /// <returns>A relative path</returns> protected virtual string GetRelativePath(FolderMappingInfo folderMapping, string path) { return(PathUtils.Instance.GetRelativePath(folderMapping.PortalID, path)); }
public void ExistsFolder_Returns_False_When_Folder_Does_Not_Exist() { var folderMapping = new FolderMappingInfo { PortalID = Constants.CONTENT_ValidPortalId }; _pathUtils.Setup(pu => pu.GetPhysicalPath(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath)).Returns(Constants.FOLDER_ValidFolderPath); _directoryWrapper.Setup(dw => dw.Exists(Constants.FOLDER_ValidFolderPath)).Returns(false); var result = _sfp.FolderExists(Constants.FOLDER_ValidFolderRelativePath, folderMapping); Assert.IsFalse(result); }
public void GetSubFolders_Throws_On_Null_FolderPath() { var folderMapping = new FolderMappingInfo(); _sfp.GetSubFolders(null, folderMapping).ToList(); }
/// <summary> /// Get actual path to a file /// </summary> /// <param name="folderMapping">Folder Mapping of the folder</param> /// <param name="folderPath">Folder Path where the file is contained</param> /// <param name="fileName">Name of the file</param> /// <returns>A windows supported path to the file</returns> protected virtual string GetActualPath(FolderMappingInfo folderMapping, string folderPath, string fileName) { var actualFolderPath = GetActualPath(folderMapping, folderPath); return(Path.Combine(actualFolderPath, fileName)); }
public override void AddFolder(string folderPath, FolderMappingInfo folderMapping) { }
public void MoveFile_Calls_DeleteFile_When_A_File_With_The_Same_Name_Exists_On_The_Destination_Folder() { _fileInfo.Setup(fi => fi.FileName).Returns(Constants.FOLDER_ValidFileName); _fileInfo.Setup(fi => fi.PortalId).Returns(Constants.CONTENT_ValidPortalId); _fileInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID); _fileInfo.Setup(fi => fi.FolderId).Returns(Constants.FOLDER_ValidFolderId); _fileInfo.Setup(fi => fi.StartDate).Returns(DateTime.Parse(Constants.FOLDER_FileStartDate)); _folderInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID); _folderInfo.Setup(fi => fi.PortalID).Returns(Constants.CONTENT_ValidPortalId); _folderInfo.Setup(fi => fi.FolderID).Returns(Constants.FOLDER_OtherValidFolderId); var folderMapping = new FolderMappingInfo { FolderProviderType = Constants.FOLDER_ValidFolderProviderType }; _folderMappingController.Setup(fmc => fmc.GetFolderMapping(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping); var fileContent = new MemoryStream(); _mockFileManager.Setup(mfm => mfm.GetFileContent(_fileInfo.Object)).Returns(fileContent); string someString; _mockFileLockingController.Setup(mflc => mflc.IsFileLocked(_fileInfo.Object, out someString)).Returns(false); _mockFileManager.Setup(mfm => mfm.MoveVersions(_fileInfo.Object, It.IsAny<IFolderInfo>(), It.IsAny<FolderProvider>(), It.IsAny<FolderProvider>())); var existingFile = new FileInfo(); _mockFileManager.Setup(mfm => mfm.GetFile(_folderInfo.Object, Constants.FOLDER_ValidFileName, It.IsAny<bool>())).Returns(existingFile); _mockFileManager.Setup(mfm => mfm.DeleteFile(existingFile)).Verifiable(); _mockFileManager.Object.MoveFile(_fileInfo.Object, _folderInfo.Object); _mockFileManager.Verify(); }
/// <inheritdoc/> protected override string GetActualPath(FolderMappingInfo folderMapping, string folderPath, string fileName) { return(base.GetActualPath(folderMapping, folderPath, fileName) + this.ProtectedExtension); }
public void MoveFile_Calls_FolderProvider_AddFile_And_DeleteFile_And_FileManager_UpdateFile() { _fileInfo.Setup(fi => fi.FileName).Returns(Constants.FOLDER_ValidFileName); _fileInfo.Setup(fi => fi.PortalId).Returns(Constants.CONTENT_ValidPortalId); _fileInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID); _fileInfo.Setup(fi => fi.FolderId).Returns(Constants.FOLDER_ValidFolderId); _folderInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID); _folderInfo.Setup(fi => fi.FolderID).Returns(Constants.FOLDER_OtherValidFolderId); _folderInfo.Setup(fi => fi.PortalID).Returns(Constants.CONTENT_ValidPortalId); var folderMapping = new FolderMappingInfo { FolderProviderType = Constants.FOLDER_ValidFolderProviderType }; _folderMappingController.Setup(fmc => fmc.GetFolderMapping(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping); var fileContent = new MemoryStream(); _mockFileManager.Setup(mfm => mfm.GetFileContent(_fileInfo.Object)).Returns(fileContent); string someString; _mockFileLockingController.Setup(mflc => mflc.IsFileLocked(_fileInfo.Object, out someString)).Returns(false); _mockFileManager.Setup(mfm => mfm.MoveVersions(_fileInfo.Object, It.IsAny<IFolderInfo>(), It.IsAny<FolderProvider>(), It.IsAny<FolderProvider>())); _mockFolder.Setup(mf => mf.AddFile(_folderInfo.Object, Constants.FOLDER_ValidFileName, fileContent)).Verifiable(); _mockFolder.Setup(mf => mf.DeleteFile(_fileInfo.Object)).Verifiable(); _mockFileManager.Setup(mfm => mfm.UpdateFile(_fileInfo.Object)).Verifiable(); _mockFileManager.Object.MoveFile(_fileInfo.Object, _folderInfo.Object); _mockFolder.Verify(); _mockFileManager.Verify(); }
public void MoveFile_Updates_FolderId_And_Folder() { _fileInfo.Setup(fi => fi.FileName).Returns(Constants.FOLDER_ValidFileName); _fileInfo.Setup(fi => fi.PortalId).Returns(Constants.CONTENT_ValidPortalId); _fileInfo.Setup(fi => fi.FolderId).Returns(Constants.FOLDER_ValidFolderId); _fileInfo.Setup(fi => fi.Folder).Returns(Constants.FOLDER_ValidFolderRelativePath); _fileInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID); _fileInfo.Setup(fi => fi.StartDate).Returns(DateTime.Parse(Constants.FOLDER_FileStartDate)); _folderInfo.Setup(fi => fi.FolderID).Returns(Constants.FOLDER_OtherValidFolderId); _folderInfo.Setup(fi => fi.PortalID).Returns(Constants.CONTENT_ValidPortalId); _folderInfo.Setup(fi => fi.FolderPath).Returns(Constants.FOLDER_OtherValidFolderRelativePath); _folderInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID); _fileInfo.SetupSet(fi => fi.FolderId = Constants.FOLDER_OtherValidFolderId).Verifiable(); _fileInfo.SetupSet(fi => fi.Folder = Constants.FOLDER_OtherValidFolderRelativePath).Verifiable(); var folderMapping = new FolderMappingInfo { FolderProviderType = Constants.FOLDER_ValidFolderProviderType }; _folderMappingController.Setup(fmc => fmc.GetFolderMapping(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping); var fileContent = new MemoryStream(); _mockFileManager.Setup(mfm => mfm.GetFileContent(_fileInfo.Object)).Returns(fileContent); string someString; _mockFileLockingController.Setup(mflc => mflc.IsFileLocked(_fileInfo.Object, out someString)).Returns(false); _mockFileManager.Setup(mfm => mfm.MoveVersions(_fileInfo.Object, It.IsAny<IFolderInfo>(), It.IsAny<FolderProvider>(), It.IsAny<FolderProvider>())); _mockFileManager.Object.MoveFile(_fileInfo.Object, _folderInfo.Object); _fileInfo.Verify(); }
public void ExistsFile_Returns_False_When_File_Does_Not_Exist() { _folderInfo.Setup(fi => fi.PortalID).Returns(Constants.CONTENT_ValidPortalId); _folderInfo.Setup(fi => fi.FolderID).Returns(Constants.FOLDER_ValidFolderId); _folderInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID); _mockFileManager.Setup(mfm => mfm.GetFile(_folderInfo.Object, Constants.FOLDER_ValidFileName, It.IsAny<bool>())).Returns(_fileInfo.Object); var folderMapping = new FolderMappingInfo { FolderProviderType = Constants.FOLDER_ValidFolderProviderType }; _folderMappingController.Setup(fmc => fmc.GetFolderMapping(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping); _mockFolder.Setup(mf => mf.FileExists(_folderInfo.Object, Constants.FOLDER_ValidFileName)).Returns(false); var result = _mockFileManager.Object.FileExists(_folderInfo.Object, Constants.FOLDER_ValidFileName); Assert.IsFalse(result); }
public void ExistsFile_Calls_FolderProvider_ExistsFile() { _folderInfo.Setup(fi => fi.PortalID).Returns(Constants.CONTENT_ValidPortalId); _folderInfo.Setup(fi => fi.FolderID).Returns(Constants.FOLDER_ValidFolderId); _folderInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID); _mockFileManager.Setup(mfm => mfm.GetFile(_folderInfo.Object, Constants.FOLDER_ValidFileName, It.IsAny<bool>())).Returns(_fileInfo.Object); var folderMapping = new FolderMappingInfo { FolderProviderType = Constants.FOLDER_ValidFolderProviderType }; _folderMappingController.Setup(fmc => fmc.GetFolderMapping(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping); _mockFolder.Setup(mf => mf.FileExists(_folderInfo.Object, Constants.FOLDER_ValidFileName)).Returns(true).Verifiable(); _mockFileManager.Object.FileExists(_folderInfo.Object, Constants.FOLDER_ValidFileName); _mockFolder.Verify(); }
public void AddFile_Does_Not_Call_FolderProvider_AddFile_When_Not_Overwritting_And_File_Exists() { _folderInfo.Setup(fi => fi.PortalID).Returns(Constants.CONTENT_ValidPortalId); _folderInfo.Setup(fi => fi.FolderID).Returns(Constants.FOLDER_ValidFolderId); _folderInfo.Setup(fi => fi.PhysicalPath).Returns(Constants.FOLDER_ValidFolderPath); _folderInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID); _folderInfo.Setup(fi => fi.WorkflowID).Returns(Null.NullInteger); var fileContent = new MemoryStream(); _portalController.Setup(pc => pc.HasSpaceAvailable(Constants.CONTENT_ValidPortalId, fileContent.Length)).Returns(true); _globals.Setup(g => g.GetSubFolderPath(Constants.FOLDER_ValidFilePath, Constants.CONTENT_ValidPortalId)).Returns(Constants.FOLDER_ValidFolderRelativePath); var folderMapping = new FolderMappingInfo { FolderProviderType = Constants.FOLDER_ValidFolderProviderType }; _folderMappingController.Setup(fmc => fmc.GetFolderMapping(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping); _mockFolder.Setup(mf => mf.FileExists(_folderInfo.Object, Constants.FOLDER_ValidFileName)).Returns(true); _mockFolder.Setup(mf => mf.AddFile(_folderInfo.Object, Constants.FOLDER_ValidFileName, fileContent)); _mockFileManager.Setup(mfm => mfm.IsAllowedExtension(Constants.FOLDER_ValidFileName)).Returns(true); _mockFileManager.Setup(mfm => mfm.UpdateFile(It.IsAny<IFileInfo>(), It.IsAny<Stream>())); _mockFileManager.Setup(mfm => mfm.CreateFileContentItem()).Returns(new ContentItem()); _contentWorkflowController.Setup(wc => wc.GetWorkflowByID(It.IsAny<int>())).Returns((ContentWorkflow)null); _mockData.Setup( md => md.AddFile(It.IsAny<int>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<long>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string>(), It.IsAny<DateTime>(), It.IsAny<string>(), It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<bool>(), It.IsAny<int>())) .Returns(Constants.FOLDER_ValidFileId); _mockData.Setup(md => md.UpdateFileLastModificationTime(It.IsAny<int>(), It.IsAny<DateTime>())); _mockFileManager.Object.AddFile(_folderInfo.Object, Constants.FOLDER_ValidFileName, fileContent, false, false, Constants.CONTENTTYPE_ValidContentType); _mockFolder.Verify(mf => mf.AddFile(It.IsAny<IFolderInfo>(), It.IsAny<string>(), It.IsAny<Stream>()), Times.Never()); }
public override void CopyFile(string folderPath, string fileName, string newFolderPath, FolderMappingInfo folderMapping) { Requires.PropertyNotNull("folderPath", folderPath); Requires.NotNullOrEmpty("fileName", fileName); Requires.PropertyNotNull("newFolderPath", newFolderPath); Requires.NotNull("folderMapping", folderMapping); if (folderPath == newFolderPath) { return; } var sourceFolder = FolderManager.Instance.GetFolder(folderMapping.PortalID, folderPath); var destinationFolder = FolderManager.Instance.GetFolder(folderMapping.PortalID, newFolderPath); Requires.NotNull("sourceFolder", sourceFolder); Requires.NotNull("destinationFolder", destinationFolder); using (var fileContent = this.GetFileStream(sourceFolder, fileName)) { if (!fileContent.CanSeek) { using (var seekableStream = FileManager.Instance.GetSeekableStream(fileContent)) { this.AddFile(destinationFolder, fileName, seekableStream); } } else { this.AddFile(destinationFolder, fileName, fileContent); } } }
public void RenameFile_Calls_FolderProvider_RenameFile_When_FileNames_Are_Distinct_And_NewFileName_Does_Not_Exist() { _fileInfo.Setup(fi => fi.FileName).Returns(Constants.FOLDER_ValidFileName); _fileInfo.Setup(fi => fi.PortalId).Returns(Constants.CONTENT_ValidPortalId); _fileInfo.Setup(fi => fi.FolderId).Returns(Constants.FOLDER_ValidFolderId); _fileInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID); _folderManager.Setup(fm => fm.GetFolder(Constants.FOLDER_ValidFolderId)).Returns(_folderInfo.Object); _mockFileManager.Setup(mfm => mfm.FileExists(_folderInfo.Object, Constants.FOLDER_OtherValidFileName, It.IsAny<bool>())).Returns(false); _mockFileManager.Setup(mfm => mfm.UpdateFile(_fileInfo.Object)); var folderMapping = new FolderMappingInfo(); folderMapping.FolderProviderType = Constants.FOLDER_ValidFolderProviderType; _folderMappingController.Setup(fmc => fmc.GetFolderMapping(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping); _mockFileManager.Object.RenameFile(_fileInfo.Object, Constants.FOLDER_OtherValidFileName); _mockFolder.Verify(mf => mf.RenameFile(_fileInfo.Object, Constants.FOLDER_OtherValidFileName), Times.Once()); }
/// <summary> /// Gets the list of subfolders for the specified folder. /// </summary> public abstract IEnumerable<string> GetSubFolders(string folderPath, FolderMappingInfo folderMapping);
public void RenameFile_Throws_When_FolderProvider_Throws() { _fileInfo.Setup(fi => fi.FileName).Returns(Constants.FOLDER_ValidFileName); _fileInfo.Setup(fi => fi.PortalId).Returns(Constants.CONTENT_ValidPortalId); _fileInfo.Setup(fi => fi.FolderId).Returns(Constants.FOLDER_ValidFolderId); _fileInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID); _folderManager.Setup(fm => fm.GetFolder(Constants.FOLDER_ValidFolderId)).Returns(_folderInfo.Object); _mockFileManager.Setup(mfm => mfm.FileExists(_folderInfo.Object, Constants.FOLDER_OtherValidFileName, It.IsAny<bool>())).Returns(false); _mockFileManager.Setup(mfm => mfm.UpdateFile(_fileInfo.Object)); var folderMapping = new FolderMappingInfo(); folderMapping.FolderProviderType = Constants.FOLDER_ValidFolderProviderType; _folderMappingController.Setup(fmc => fmc.GetFolderMapping(Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping); _mockFolder.Setup(mf => mf.RenameFile(_fileInfo.Object, Constants.FOLDER_OtherValidFileName)).Throws<Exception>(); _mockFileManager.Object.RenameFile(_fileInfo.Object, Constants.FOLDER_OtherValidFileName); }
public void AddFile_Checks_Space_For_Stream_Length() { //Arrange _folderInfo.Setup(fi => fi.PortalID).Returns(Constants.CONTENT_ValidPortalId); _folderInfo.Setup(fi => fi.FolderID).Returns(Constants.FOLDER_ValidFolderId); _folderInfo.Setup(fi => fi.PhysicalPath).Returns(Constants.FOLDER_ValidFolderPath); _folderInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID); _folderInfo.Setup(fi => fi.WorkflowID).Returns(Null.NullInteger); var fileContent = new MemoryStream(Encoding.ASCII.GetBytes("some data here")); _portalController.Setup(pc => pc.HasSpaceAvailable(It.IsAny<int>(), It.IsAny<long>())).Returns(true); _globals.Setup(g => g.GetSubFolderPath(Constants.FOLDER_ValidFilePath, Constants.CONTENT_ValidPortalId)).Returns(Constants.FOLDER_ValidFolderRelativePath); var folderMapping = new FolderMappingInfo { FolderProviderType = Constants.FOLDER_ValidFolderProviderType }; _folderMappingController.Setup(fmc => fmc.GetFolderMapping(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping); _mockFolder.Setup(mf => mf.FileExists(_folderInfo.Object, Constants.FOLDER_ValidFileName)).Returns(false); _mockFolder.Setup(mf => mf.AddFile(_folderInfo.Object, Constants.FOLDER_ValidFileName, fileContent)).Verifiable(); _mockFileManager.Setup(mfm => mfm.IsAllowedExtension(Constants.FOLDER_ValidFileName)).Returns(true); _mockFileManager.Setup(mfm => mfm.CreateFileContentItem()).Returns(new ContentItem()); _contentWorkflowController.Setup(wc => wc.GetWorkflowByID(It.IsAny<int>())).Returns((ContentWorkflow)null); //Act _mockFileManager.Object.AddFile(_folderInfo.Object, Constants.FOLDER_ValidFileName, fileContent, true, false, Constants.CONTENTTYPE_ValidContentType); //Assert _portalController.Verify(pc => pc.HasSpaceAvailable(Constants.CONTENT_ValidPortalId, fileContent.Length)); }
public void DeleteFile_Throws_WhenFolderProviderThrows() { //Arrange var fileInfo = new FileInfoBuilder().Build(); _fileVersionController.Setup(fv => fv.DeleteAllUnpublishedVersions(fileInfo, false)); var folderMapping = new FolderMappingInfo { FolderProviderType = Constants.FOLDER_ValidFolderProviderType }; _folderMappingController.Setup(fmc => fmc.GetFolderMapping(Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping); string someString; _mockFileLockingController.Setup(mflc => mflc.IsFileLocked(fileInfo, out someString)).Returns(false); _mockFolderProvider.Setup(mf => mf.DeleteFile(fileInfo)).Throws<Exception>(); FileDeletionController.Instance.DeleteFile(fileInfo); }
private FolderMappingViewModel GetFolderMappingViewModel(FolderMappingInfo folderMapping) { return new FolderMappingViewModel { Id = folderMapping.FolderMappingID, FolderTypeName = folderMapping.FolderProviderType, Name = folderMapping.MappingName }; }
/// <summary> /// Checks the existence of the specified folder in the underlying system. /// </summary> public abstract bool FolderExists(string folderPath, FolderMappingInfo folderMapping);
public void GetSubFolders_Calls_DirectoryWrapper_GetDirectories() { var folderMapping = new FolderMappingInfo { PortalID = Constants.CONTENT_ValidPortalId }; _pathUtils.Setup(pu => pu.GetPhysicalPath(folderMapping.PortalID, Constants.FOLDER_ValidFolderRelativePath)).Returns(Constants.FOLDER_ValidFolderPath); _sfp.GetSubFolders(Constants.FOLDER_ValidFolderRelativePath, folderMapping).ToList(); _directoryWrapper.Verify(dw => dw.GetDirectories(Constants.FOLDER_ValidFolderPath), Times.Once()); }
/// <summary> /// Copies the specified file to the destination folder. /// </summary> public virtual void CopyFile(string folderPath, string fileName, string newFolderPath, FolderMappingInfo folderMapping) { Requires.NotNull("folderPath", folderPath); Requires.NotNullOrEmpty("fileName", fileName); Requires.NotNull("newFolderPath", newFolderPath); Requires.NotNull("folderMapping", folderMapping); if (folderPath == newFolderPath) { return; } var sourceFolder = new FolderInfo { FolderPath = folderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.PortalID }; var destinationFolder = new FolderInfo { FolderPath = newFolderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.PortalID }; using (var fileContent = GetFileStream(sourceFolder, fileName)) { if (!fileContent.CanSeek) { using (var seekableStream = FileManager.Instance.GetSeekableStream(fileContent)) { AddFile(destinationFolder, fileName, seekableStream); } } else { AddFile(destinationFolder, fileName, fileContent); } } }
public override void MoveFolder(string folderPath, string newFolderPath, FolderMappingInfo folderMapping) { // The folder has already been moved in filesystem }
public void GetSubFolders_Returns_Valid_SubFolders_When_Folder_Is_Not_Empty() { var expectedSubFolders = new[] { Constants.FOLDER_ValidSubFolderRelativePath, Constants.FOLDER_OtherValidSubFolderRelativePath }; var folderMapping = new FolderMappingInfo { PortalID = Constants.CONTENT_ValidPortalId }; _pathUtils.Setup(pu => pu.GetPhysicalPath(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath)).Returns(Constants.FOLDER_ValidFolderPath); _pathUtils.Setup(pu => pu.GetRelativePath(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidSubFolderPath)).Returns(Constants.FOLDER_ValidSubFolderRelativePath); _pathUtils.Setup(pu => pu.GetRelativePath(Constants.CONTENT_ValidPortalId, Constants.FOLDER_OtherValidSubFolderPath)).Returns(Constants.FOLDER_OtherValidSubFolderRelativePath); var subFolders = new[] { Constants.FOLDER_ValidSubFolderPath, Constants.FOLDER_OtherValidSubFolderPath }; _directoryWrapper.Setup(dw => dw.GetDirectories(Constants.FOLDER_ValidFolderPath)).Returns(subFolders); var result = _sfp.GetSubFolders(Constants.FOLDER_ValidFolderRelativePath, folderMapping).ToList(); CollectionAssert.AreEqual(expectedSubFolders, result); }
/// <summary> /// Get actual path to a folder in the specified folder mapping /// </summary> /// <param name="folderMapping">The folder mapping</param> /// <param name="folderPath">The folder path</param> /// <returns>A windows supported path to the folder</returns> protected virtual string GetActualPath(FolderMappingInfo folderMapping, string folderPath) { return(PathUtils.Instance.GetPhysicalPath(folderMapping.PortalID, folderPath)); }
public override void CopyFile(string folderPath, string fileName, string newFolderPath, FolderMappingInfo folderMapping) { Requires.PropertyNotNull("folderPath", folderPath); Requires.NotNullOrEmpty("fileName", fileName); Requires.PropertyNotNull("newFolderPath", newFolderPath); Requires.NotNull("folderMapping", folderMapping); if (folderPath == newFolderPath) { return; } var filePath = GetActualPath(folderMapping, folderPath, fileName); var newFilePath = GetActualPath(folderMapping, newFolderPath, fileName); if (FileWrapper.Instance.Exists(filePath)) { FileWrapper.Instance.Copy(filePath, newFilePath, true); } }
/// <summary> /// Get actual path to a file /// </summary> /// <param name="folderMapping">Folder Mapping of the folder</param> /// <param name="folderPath">Folder Path where the file is contained</param> /// <param name="fileName">Name of the file</param> /// <returns>A windows supported path to the file</returns> protected virtual string GetActualPath(FolderMappingInfo folderMapping, string folderPath, string fileName) { var actualFolderPath = GetActualPath(folderMapping, folderPath); return Path.Combine(actualFolderPath, fileName); }
public void ExistsFolder_Throws_On_Null_FolderPath() { var folderMapping = new FolderMappingInfo(); _sfp.FolderExists(null, folderMapping); }
/// <summary> /// Get actual path to a folder in the specified folder mapping /// </summary> /// <param name="folderMapping">The folder mapping</param> /// <param name="folderPath">The folder path</param> /// <returns>A windows supported path to the folder</returns> protected virtual string GetActualPath(FolderMappingInfo folderMapping, string folderPath) { return PathUtils.Instance.GetPhysicalPath(folderMapping.PortalID, folderPath); }
public virtual void AddFolder(string folderPath, FolderMappingInfo folderMapping, string mappedPath) { AddFolder(folderPath, folderMapping); }
/// <summary> /// Get the path relative to the root of the FolderMapping /// </summary> /// <param name="folderMapping">Path is relative to this</param> /// <param name="path">The path</param> /// <returns>A relative path</returns> protected virtual string GetRelativePath(FolderMappingInfo folderMapping, string path) { return PathUtils.Instance.GetRelativePath(folderMapping.PortalID, path); }
private static void AddFolderAndMoveFiles(string folderPath, string newFolderPath, FolderMappingInfo folderMapping) { var folderProvider = Instance(folderMapping.FolderProviderType); if (!folderProvider.FolderExists(newFolderPath, folderMapping)) { folderProvider.AddFolder(newFolderPath, folderMapping); } var folder = new FolderInfo { FolderPath = folderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.PortalID }; var newFolder = new FolderInfo { FolderPath = newFolderPath, FolderMappingID = folderMapping.FolderMappingID, PortalID = folderMapping.PortalID }; MoveFiles(folder, newFolder, folderMapping); }
public void GetSubFolders_Count_Equals_DirectoryWrapper_GetDirectories_Count() { var folderMapping = new FolderMappingInfo { PortalID = Constants.CONTENT_ValidPortalId }; _pathUtils.Setup(pu => pu.GetPhysicalPath(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderRelativePath)).Returns(Constants.FOLDER_ValidFolderPath); _pathUtils.Setup(pu => pu.GetRelativePath(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidSubFolderPath)).Returns(Constants.FOLDER_ValidSubFolderRelativePath); _pathUtils.Setup(pu => pu.GetRelativePath(Constants.CONTENT_ValidPortalId, Constants.FOLDER_OtherValidSubFolderPath)).Returns(Constants.FOLDER_OtherValidSubFolderRelativePath); var subFolders = new[] { Constants.FOLDER_ValidSubFolderPath, Constants.FOLDER_OtherValidSubFolderPath }; _directoryWrapper.Setup(dw => dw.GetDirectories(Constants.FOLDER_ValidFolderPath)).Returns(subFolders); var result = _sfp.GetSubFolders(Constants.FOLDER_ValidFolderRelativePath, folderMapping).ToList(); Assert.AreEqual(subFolders.Length, result.Count); }
/// <summary> /// Adds a new folder to a specified parent folder. /// </summary> public abstract void AddFolder(string folderPath, FolderMappingInfo folderMapping);
public void AddFile_Throws_When_Portal_Has_No_Space_Available() { _folderInfo.Setup(fi => fi.PortalID).Returns(Constants.CONTENT_ValidPortalId); _folderInfo.Setup(fi => fi.PhysicalPath).Returns(Constants.FOLDER_ValidFolderPath); _folderInfo.Setup(fi => fi.PhysicalPath).Returns(Constants.FOLDER_ValidFolderPath); _folderInfo.Setup(fi => fi.FolderMappingID).Returns(Constants.FOLDER_ValidFolderMappingID); _mockData.Setup(c => c.GetProviderPath()).Returns(String.Empty); var fileContent = new MemoryStream(); _globals.Setup(g => g.GetSubFolderPath(Constants.FOLDER_ValidFilePath, Constants.CONTENT_ValidPortalId)).Returns(Constants.FOLDER_ValidFolderRelativePath); var folderMapping = new FolderMappingInfo { FolderProviderType = Constants.FOLDER_ValidFolderProviderType }; _folderMappingController.Setup(fmc => fmc.GetFolderMapping(Constants.CONTENT_ValidPortalId, Constants.FOLDER_ValidFolderMappingID)).Returns(folderMapping); _portalController.Setup(pc => pc.HasSpaceAvailable(Constants.CONTENT_ValidPortalId, fileContent.Length)).Returns(false); _mockFileManager.Setup(fm => fm.CreateFileContentItem()).Returns(new ContentItem()); _mockFileManager.Object.AddFile(_folderInfo.Object, Constants.FOLDER_ValidFileName, fileContent, false, false, Constants.CONTENTTYPE_ValidContentType); }
/// <summary> /// Gets the list of subfolders for the specified folder. /// </summary> public abstract IEnumerable <string> GetSubFolders(string folderPath, FolderMappingInfo folderMapping);
public override bool FolderExists(string folderPath, FolderMappingInfo folderMapping) { Requires.NotNull("folderPath", folderPath); Requires.NotNull("folderMapping", folderMapping); return DirectoryWrapper.Instance.Exists(GetActualPath(folderMapping, folderPath)); }
private void cmdUpdate_Click(object sender, EventArgs e) { Page.Validate("vgEditFolderMapping"); if (!Page.IsValid) return; try { var folderMapping = new FolderMappingInfo(); if (FolderMappingID != Null.NullInteger) { folderMapping = _folderMappingController.GetFolderMapping(FolderMappingID) ?? new FolderMappingInfo(); } folderMapping.FolderMappingID = FolderMappingID; folderMapping.MappingName = txtName.Text; folderMapping.FolderProviderType = cboFolderProviders.SelectedValue; folderMapping.PortalID = FolderPortalID; var originalSettings = folderMapping.FolderMappingSettings; try { var folderMappingID = FolderMappingID; if (folderMappingID == Null.NullInteger) { folderMappingID = _folderMappingController.AddFolderMapping(folderMapping); } else { _folderMappingController.UpdateFolderMapping(folderMapping); } if (phProviderSettings.Controls.Count > 0 && phProviderSettings.Controls[0] is FolderMappingSettingsControlBase) { var settingsControl = (FolderMappingSettingsControlBase)phProviderSettings.Controls[0]; try { settingsControl.UpdateSettings(folderMappingID); } catch { if (FolderMappingID == Null.NullInteger) { _folderMappingController.DeleteFolderMapping(FolderPortalID, folderMappingID); } return; } } if (FolderMappingID != Null.NullInteger) { // Check if some setting has changed var updatedSettings = _folderMappingController.GetFolderMappingSettings(FolderMappingID); if (originalSettings.Keys.Cast<object>().Any(key => updatedSettings.ContainsKey(key) && !originalSettings[key].ToString().Equals(updatedSettings[key].ToString()))) { // Re-synchronize folders using the existing mapping. It's important to synchronize them in descending order var folders = FolderManager.Instance.GetFolders(FolderPortalID).Where(f => f.FolderMappingID == FolderMappingID).OrderByDescending(f => f.FolderPath); foreach (var folder in folders) { FolderManager.Instance.Synchronize(FolderPortalID, folder.FolderPath, false, true); } } } } catch { UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("DuplicateMappingName", LocalResourceFile), ModuleMessage.ModuleMessageType.RedError); return; } Response.Redirect(EditUrl("FolderMappings")); } catch (Exception exc) { Exceptions.ProcessModuleLoadException(this, exc); } }
public override IEnumerable<string> GetSubFolders(string folderPath, FolderMappingInfo folderMapping) { Requires.NotNull("folderPath", folderPath); Requires.NotNull("folderMapping", folderMapping); return DirectoryWrapper.Instance.GetDirectories(GetActualPath(folderMapping, folderPath)) .Select(directory => GetRelativePath(folderMapping, directory)); }