/// <summary> /// gets all the files in a directory, only searches one level /// </summary> /// <param name="BaseDirectory">the base directory</param> /// <returns>collection of File objects</returns> public override IEnumerable <FileSystem.File> GetFiles(FileSystem.Directory BaseDirectory) { var aPath = VirtualPathToUNCPath(BaseDirectory.FullPath); var sysDirectory = new DirectoryInfo(aPath); return(sysDirectory.GetFiles().Where(x => x.Name.ToLower() != "thumbs.db").Select(x => GetFile(string.Format("{0}/{1}", BaseDirectory.FullPath, x.Name)))); }
private static void GenerateEntryNameTable( List <DirectoryTableEntry> directoryTable, List <EntryNameTableEntry> entryNameTable, FileSystem.Directory dir, ref uint Offset, ref ushort FileId) { directoryTable[(int)dir.DirectoryID - 61440].dirEntryStart = Offset; directoryTable[(int)dir.DirectoryID - 61440].dirEntryFileID = FileId; foreach (FileSystem.Directory subDirectory in dir.SubDirectories) { entryNameTable.Add((EntryNameTableEntry) new EntryNameTableDirectoryEntry(subDirectory.DirectoryName, subDirectory.DirectoryID)); Offset += (uint)(subDirectory.DirectoryName.Length + 3); } foreach (FileSystem.File file in dir.Files) { file.FileID = (int)FileId; entryNameTable.Add((EntryNameTableEntry) new EntryNameTableFileEntry(file.FileName)); Offset += (uint)(file.FileName.Length + 1); ++FileId; } entryNameTable.Add((EntryNameTableEntry) new EntryNameTableEndOfDirectoryEntry()); ++Offset; foreach (FileSystem.Directory subDirectory in dir.SubDirectories) { NARC_new.GenerateEntryNameTable(directoryTable, entryNameTable, subDirectory, ref Offset, ref FileId); } }
/// <summary> /// gets all the directories underneath a base directory. Only searches one level. /// </summary> /// <param name="BaseDirectory">the base directory</param> /// <returns>collection of Directory objects</returns> public override IEnumerable <FileSystem.Directory> GetDirectories(FileSystem.Directory BaseDirectory) { var aPath = VirtualPathToUNCPath(BaseDirectory.FullPath); var sysDirectory = new System.IO.DirectoryInfo(aPath); return(sysDirectory.GetDirectories().Select(x => GetDirectory($"{BaseDirectory.FullPath}/{x.Name}"))); }
/// <summary> /// gets all the directories underneath a base directory. Only searches one level. /// </summary> /// <param name="BaseDirectory">the base directory</param> /// <returns>collection of Directory objects</returns> public override IEnumerable <FileSystem.Directory> GetDirectories(FileSystem.Directory BaseDirectory) { var aPath = VirtualPathToUNCPath(BaseDirectory.FullPath); var sysDirectory = new System.IO.DirectoryInfo(aPath); return(sysDirectory.GetDirectories().Select(x => GetDirectory(string.Format("{0}/{1}", BaseDirectory.FullPath, x.Name)))); }
/// <summary> /// gets all the files in a directory, only searches one level /// </summary> /// <param name="BaseDirectory">the base directory</param> /// <returns>collection of File objects</returns> public override IEnumerable <FileSystem.File> GetFiles(FileSystem.Directory BaseDirectory) { var aPath = BlogAbsolutePath(BaseDirectory.FullPath); var sysDirectory = new DirectoryInfo(aPath); return(sysDirectory.GetFiles().Select(x => GetFile($"{BaseDirectory.FullPath}/{x.Name}"))); }
/// <summary> /// gets all the files in a directory, only searches one level /// </summary> /// <param name="BaseDirectory">the base directory</param> /// <returns>collection of File objects</returns> public override IEnumerable <FileSystem.File> GetFiles(FileSystem.Directory BaseDirectory) { var aPath = BlogAbsolutePath(BaseDirectory.FullPath); var sysDirectory = new DirectoryInfo(aPath); return(sysDirectory.GetFiles().Select(x => GetFile(string.Format("{0}/{1}", BaseDirectory.FullPath, x.Name)))); }
public async Task CanCreateRootDirectory() { IDirectory directory = new FileSystem.Directory() { Name = "", Path = $"{FileSystemOptions.DirectorySeparator}" }; await _repository.InsertDirectory(directory); }
/// <summary> /// Loads the project in the specified path into PowerMILL. /// </summary> /// <param name="projectDirectory">The project directory path for the PowerMILL project.</param> /// <param name="openReadOnly">If true it will open as read only.</param> /// <returns>The loaded project.</returns> public PMProject LoadProject(FileSystem.Directory projectDirectory, bool openReadOnly = false) { //Test that the file exists if (projectDirectory.Exists == false) { throw new Exception("The PowerMILL project does not exists"); } _activeProject = new PMProject(this, projectDirectory, openReadOnly); return(_activeProject); }
/// <summary> /// gets all the directories underneath a base directory. Only searches one level. /// </summary> /// <param name="BaseDirectory">the base directory</param> /// <returns>collection of Directory objects</returns> public override IEnumerable <FileSystem.Directory> GetDirectories(FileSystem.Directory BaseDirectory) { FileSystem.FileStoreDb db = new FileSystem.FileStoreDb(this.connectionString); var dirs = db.FileStoreDirectories.Where(x => x.ParentID == BaseDirectory.Id && x.BlogID == Blog.CurrentInstance.Id); List <FileSystem.Directory> directories = new List <FileSystem.Directory>(); foreach (var d in dirs) { directories.Add(d.CopyToDirectory()); } db.Dispose(); return(directories); }
/// <summary> /// gets all the files in a directory, only searches one level /// </summary> /// <param name="BaseDirectory">the base directory</param> /// <returns>collection of File objects</returns> public override IEnumerable <FileSystem.File> GetFiles(FileSystem.Directory BaseDirectory) { var db = new FileSystem.FileStoreDb(this.connectionString); var fileDir = db.FileStoreDirectories.FirstOrDefault(x => x.Id == BaseDirectory.Id); if (fileDir == null) { return(new List <FileSystem.File>()); } var arr = fileDir.FileStoreFiles.Select(x => x.CopyToFile()).ToList(); db.Dispose(); return(arr); }
public void CanCreateSubDirectory() { try { var subDirectory = new FileSystem.Directory(_rootDirectory, "Files"); _rootDirectory.Directories.Add(subDirectory); _repository.SaveChanges(true); } catch (Exception exception) { var message = GetMessage(exception); Assert.Fail(message); } }
/// <summary> /// gets a directory by the virtual path /// </summary> /// <param name="VirtualPath">the virtual path</param> /// <param name="CreateNew">unused</param> /// <returns>the directory object</returns> public override FileSystem.Directory GetDirectory(string VirtualPath, bool CreateNew) { VirtualPath = CleanVirtualPath(VirtualPath); var aPath = VirtualPathToUNCPath(VirtualPath); var sysDir = new System.IO.DirectoryInfo(aPath); if (!sysDir.Exists) { this.CreateDirectory(VirtualPath); } var dir = new FileSystem.Directory(); dir.FullPath = VirtualPath; dir.Name = sysDir.Name; dir.IsRoot = string.IsNullOrWhiteSpace(VirtualPath); dir.LastAccessTime = sysDir.LastAccessTime; dir.DateModified = sysDir.LastWriteTime; dir.DateCreated = sysDir.CreationTime; dir.Id = Guid.NewGuid(); return(dir); }
/// <summary> /// gets a directory by the virtual path /// </summary> /// <param name="VirtualPath">the virtual path</param> /// <param name="CreateNew">unused</param> /// <returns>the directory object</returns> public override FileSystem.Directory GetDirectory(string VirtualPath, bool CreateNew) { VirtualPath = RelativeFilePath(VirtualPath); var aPath = BlogAbsolutePath(VirtualPath); var sysDir = new DirectoryInfo(aPath); if (!sysDir.Exists) { this.CreateDirectory(VirtualPath); } var dir = new FileSystem.Directory(); dir.FullPath = VirtualPath; dir.Name = sysDir.Name; dir.IsRoot = VirtualPath == string.Concat(Blog.CurrentInstance.StorageLocation, "files"); dir.LastAccessTime = sysDir.LastAccessTime; dir.DateModified = sysDir.LastWriteTime; dir.DateCreated = sysDir.CreationTime; dir.Id = Guid.NewGuid(); return(dir); }
private static void GenerateDirectoryTable( List <DirectoryTableEntry> directoryTable, FileSystem.Directory dir) { DirectoryTableEntry directoryTableEntry = new DirectoryTableEntry(); if (dir.IsRoot) { directoryTableEntry.dirParentID = (ushort)(dir.TotalNrSubDirectories + 1U); directoryTableEntry.dirEntryStart = (uint)directoryTableEntry.dirParentID * 8U; } else { directoryTableEntry.dirParentID = dir.Parent.DirectoryID; } dir.DirectoryID = (ushort)(61440 + directoryTable.Count); directoryTable.Add(directoryTableEntry); foreach (FileSystem.Directory subDirectory in dir.SubDirectories) { NARC_new.GenerateDirectoryTable(directoryTable, subDirectory); } }
/// <summary> /// uploads a file to the provider container /// </summary> /// <param name="FileBinary">file contents as byte array</param> /// <param name="FileName">the file name</param> /// <param name="BaseDirectory">directory object that is the owner</param> /// <returns>the new file object</returns> public override FileSystem.File UploadFile(byte[] FileBinary, string FileName, FileSystem.Directory BaseDirectory) { return(UploadFile(FileBinary, FileName, BaseDirectory, false)); }
/// <summary> /// gets a directory by a basedirectory and a string array of sub path tree /// </summary> /// <param name="BaseDirectory">the base directory object</param> /// <param name="CreateNew">if set will create the directory structure</param> /// <param name="SubPath">the params of sub path</param> /// <returns>the directory found, or null for no directory found</returns> public override FileSystem.Directory GetDirectory(FileSystem.Directory BaseDirectory, bool CreateNew, params string[] SubPath) { return(GetDirectory(string.Join("/", BaseDirectory.FullPath, SubPath), CreateNew)); }
public NARCFileSystem ToFileSystem() { List <FileSystem.Directory> directoryList = new List <FileSystem.Directory>(); directoryList.Add(new FileSystem.Directory("/", true)); directoryList[0].DirectoryID = (ushort)61440; uint dirParentId = (uint)this.FNTB.directoryTable[0].dirParentID; for (int index = 1; (long)index < (long)dirParentId; ++index) { directoryList.Add(new FileSystem.Directory((ushort)(61440 + index))); } for (int index = 1; (long)index < (long)dirParentId; ++index) { directoryList[index].Parent = directoryList[(int)this.FNTB.directoryTable[index].dirParentID - 61440]; } for (int index1 = 0; (long)index1 < (long)dirParentId; ++index1) { for (int index2 = 0; (long)index2 < (long)dirParentId; ++index2) { if (directoryList[index1] == directoryList[index2].Parent) { directoryList[index1].SubDirectories.Add(directoryList[index2]); } } } uint num = dirParentId * 8U; ushort dirEntryFileId = this.FNTB.directoryTable[0].dirEntryFileID; FileSystem.Directory Parent = (FileSystem.Directory)null; foreach (EntryNameTableEntry entryNameTableEntry in this.FNTB.entryNameTable) { for (int index = 1; (long)index < (long)dirParentId; ++index) { if ((int)num == (int)this.FNTB.directoryTable[index].dirEntryStart) { Parent = directoryList[index]; break; } } switch (entryNameTableEntry) { case EntryNameTableEndOfDirectoryEntry _: Parent = (FileSystem.Directory)null; ++num; break; case EntryNameTableFileEntry _: Parent.Files.Add(new FileSystem.File((int)dirEntryFileId++, ((EntryNameTableFileEntry)entryNameTableEntry).entryName, Parent)); num += 1U + (uint)entryNameTableEntry.entryNameLength; break; case EntryNameTableDirectoryEntry _: directoryList[(int)((EntryNameTableDirectoryEntry)entryNameTableEntry).directoryID - 61440].DirectoryName = ((EntryNameTableDirectoryEntry)entryNameTableEntry).entryName; num += (uint)(3 + ((int)entryNameTableEntry.entryNameLength & (int)sbyte.MaxValue)); break; } } for (int index = 0; index < (int)this.FATB.numFiles; ++index) { byte[] numArray = new byte[(IntPtr)this.FATB.allocationTable[index].fileSize]; Array.Copy((Array)this.FIMG.fileImage, (long)this.FATB.allocationTable[index].fileTop, (Array)numArray, 0L, (long)numArray.Length); directoryList[0].GetFileByID((int)(ushort)index).Data = numArray; } return(new NARCFileSystem(directoryList[0])); }
/// <summary> /// uploads a file to the provider container /// </summary> /// <param name="FileStream">the file stream of the file being uploaded</param> /// <param name="FileName">the file name</param> /// <param name="BaseDirectory">the directory object that is the owner</param> /// <param name="Overwrite">boolean wether to overwrite the file if it exists.</param> /// <returns>the new file object</returns> public static FileSystem.File UploadFile(System.IO.Stream FileStream, string FileName, FileSystem.Directory BaseDirectory, bool Overwrite) { System.IO.MemoryStream ms = new System.IO.MemoryStream(); FileStream.CopyTo(ms); FileStream.Close(); byte[] binary = ms.ToArray(); ms.Close(); return(FileSystemProvider.UploadFile(binary, FileName, BaseDirectory, Overwrite)); }
/// <summary> /// uploads a file to the provider container /// </summary> /// <param name="FileBinary">the contents of the file as a byte array</param> /// <param name="FileName">the file name</param> /// <param name="BaseDirectory">the directory object that is the owner</param> /// <param name="Overwrite">boolean wether to overwrite the file if it exists.</param> /// <returns>the new file object</returns> public override FileSystem.File UploadFile(byte[] FileBinary, string FileName, FileSystem.Directory BaseDirectory, bool Overwrite) { var virtualPath = $"{BaseDirectory.FullPath}/{FileName}"; if (FileExists(virtualPath)) { if (Overwrite) { DeleteFile(virtualPath); } else { throw new IOException("File " + virtualPath + " already exists. Unable to upload file."); } } var aPath = VirtualPathToUNCPath(virtualPath); File.WriteAllBytes(aPath, FileBinary); return(GetFile(virtualPath)); }
/// <summary> /// uploads a file to the provider container /// </summary> /// <param name="FileBinary">the contents of the file as a byte array</param> /// <param name="FileName">the file name</param> /// <param name="BaseDirectory">the directory object that is the owner</param> /// <param name="Overwrite">boolean wether to overwrite the file if it exists.</param> /// <returns>the new file object</returns> public static FileSystem.File UploadFile(byte[] FileBinary, string FileName, FileSystem.Directory BaseDirectory, bool Overwrite) { return(FileSystemProvider.UploadFile(FileBinary, FileName, BaseDirectory, Overwrite)); }
/// <summary> /// uploads a file to the provider container /// </summary> /// <param name="FileStream">the file stream of the file being uploaded</param> /// <param name="FileName">the file name</param> /// <param name="BaseDirectory">the directory object that is the owner</param> /// <returns>the new file object</returns> public static FileSystem.File UploadFile(System.IO.Stream FileStream, string FileName, FileSystem.Directory BaseDirectory) { return(UploadFile(FileStream, FileName, BaseDirectory, false)); }
public override FileSystem.Directory GetDirectory(string VirtualPath, bool CreateNew) { VirtualPath = RelativeFilePath(VirtualPath); var aPath = BlogAbsolutePath(VirtualPath); var sysDir = new DirectoryInfo(aPath); if (!sysDir.Exists) this.CreateDirectory(VirtualPath); var dir = new FileSystem.Directory(); dir.FullPath = VirtualPath; dir.Name = sysDir.Name; dir.IsRoot = VirtualPath == string.Concat(Blog.CurrentInstance.StorageLocation, "files"); dir.LastAccessTime = sysDir.LastAccessTime; dir.DateModified = sysDir.LastWriteTime; dir.DateCreated = sysDir.CreationTime; dir.Id = Guid.NewGuid(); return dir; }
public NARCFileSystem(FileSystem.Directory Root) { this.Root = Root; }
/// <summary> /// uploads a file to the provider container /// </summary> /// <param name="FileBinary">the contents of the file as a byte array</param> /// <param name="FileName">the file name</param> /// <param name="BaseDirectory">the directory object that is the owner</param> /// <param name="Overwrite">boolean wether to overwrite the file if it exists.</param> /// <returns>the new file object</returns> public override FileSystem.File UploadFile(byte[] FileBinary, string FileName, FileSystem.Directory BaseDirectory, bool Overwrite) { var virtualPath = BaseDirectory.FullPath + "/" + FileName; var db = new FileSystem.FileStoreDb(this.connectionString); var files = db.FileStoreFiles.Where(x => x.FileStoreDirectory.Id == BaseDirectory.Id && x.FullPath.ToLower() == virtualPath); if (files.Count() > 0) { if (!Overwrite) { db.Dispose(); throw new Exception("File " + FileName + " already exists in this path."); } db.FileStoreFiles.DeleteAllOnSubmit(files); db.SubmitChanges(); } var file = new FileSystem.FileStoreFile() { Contents = FileBinary, CreateDate = DateTime.Now, FileID = Guid.NewGuid(), FullPath = virtualPath, LastAccess = DateTime.Now, LastModify = DateTime.Now, Name = FileName, ParentDirectoryID = BaseDirectory.Id, Size = FileBinary.Length }; db.FileStoreFiles.InsertOnSubmit(file); db.SubmitChanges(); db.Dispose(); return(file.CopyToFile()); }
public void CanGetSubDirectory() { _subDirectory = _repository.Directories.SingleOrDefault(d => d.Path == "/Files"); Assert.NotNull(_subDirectory); }
private static void AssertValidDirectory(FileSystem.Directory directory, string path, string name) { Assert.NotNull(directory); Assert.AreEqual(path, directory.Path); Assert.AreEqual(name, directory.Name); }
public void CanGetRootDirectory() { _rootDirectory = _repository.Directories.SingleOrDefault(d => d.Path == "/"); Assert.NotNull(_rootDirectory); }
/// <summary> /// uploads a file to the provider container /// </summary> /// <param name="FileBinary">the contents of the file as a byte array</param> /// <param name="FileName">the file name</param> /// <param name="BaseDirectory">the directory object that is the owner</param> /// <param name="Overwrite">boolean wether to overwrite the file if it exists.</param> /// <returns>the new file object</returns> public override FileSystem.File UploadFile(byte[] FileBinary, string FileName, FileSystem.Directory BaseDirectory, bool Overwrite) { var virtualPath = RelativeFilePath(string.Format("{0}/{1}", BaseDirectory.FullPath, FileName)); if (FileExists(virtualPath)) { if (Overwrite) { DeleteFile(virtualPath); } else { throw new IOException("File " + virtualPath + " already exists. Unable to upload file."); } } var aPath = BlogAbsolutePath(virtualPath); File.WriteAllBytes(aPath, FileBinary); return(GetFile(virtualPath)); }
/// <summary> /// gets a directory by the virtual path /// </summary> /// <param name="VirtualPath">the virtual path</param> /// <param name="CreateNew">unused</param> /// <returns>the directory object</returns> public override FileSystem.Directory GetDirectory(string VirtualPath, bool CreateNew) { VirtualPath = CleanVirtualPath(VirtualPath); var aPath = VirtualPathToUNCPath(VirtualPath); var sysDir = new System.IO.DirectoryInfo(aPath); if (!sysDir.Exists) this.CreateDirectory(VirtualPath); var dir = new FileSystem.Directory(); dir.FullPath = VirtualPath; dir.Name = sysDir.Name; dir.IsRoot = string.IsNullOrWhiteSpace(VirtualPath); dir.LastAccessTime = sysDir.LastAccessTime; dir.DateModified = sysDir.LastWriteTime; dir.DateCreated = sysDir.CreationTime; dir.Id = Guid.NewGuid(); return dir; }
/// <summary> /// gets a directory by a basedirectory and a string array of sub path tree /// </summary> /// <param name="BaseDirectory">the base directory object</param> /// <param name="SubPath">the params of sub path</param> /// <returns>the directory found, or null for no directory found</returns> public override FileSystem.Directory GetDirectory(FileSystem.Directory BaseDirectory, params string[] SubPath) { return(GetDirectory(string.Concat(BaseDirectory.FullPath, string.Join("/", SubPath)))); }