Пример #1
0
        /// <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))));
        }
Пример #2
0
 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);
     }
 }
Пример #3
0
        /// <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}")));
        }
Пример #4
0
        /// <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}")));
        }
Пример #6
0
        /// <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);
        }
Пример #8
0
 /// <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);
 }
Пример #9
0
        /// <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);
        }
Пример #10
0
        /// <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);
     }
 }
Пример #12
0
        /// <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);
        }
Пример #13
0
        /// <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);
        }
Пример #14
0
        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);
            }
        }
Пример #15
0
 /// <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));
 }
Пример #16
0
 /// <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));
 }
Пример #17
0
        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]));
        }
Пример #18
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));
 }
Пример #19
0
        /// <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));
        }
Пример #20
0
 /// <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));
 }
Пример #21
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>
 /// <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;
 }
Пример #23
0
 public NARCFileSystem(FileSystem.Directory Root)
 {
     this.Root = Root;
 }
Пример #24
0
        /// <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);
        }
Пример #28
0
        /// <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));
        }
Пример #29
0
 /// <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;
 }
Пример #30
0
 /// <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))));
 }