EnumerateDirectories() public method

public EnumerateDirectories ( ) : IEnumerable
return IEnumerable
Ejemplo n.º 1
0
 /// <summary>
 /// Determines whether specified dir looks like a Ignite home.
 /// </summary>
 /// <param name="dir">Directory.</param>
 /// <returns>Value indicating whether specified dir looks like a Ignite home.</returns>
 private static bool IsIgniteHome(DirectoryInfo dir)
 {
     return dir.Exists &&
            (dir.EnumerateDirectories().Count(x => x.Name == "examples" || x.Name == "bin") == 2 &&
             dir.EnumerateDirectories().Count(x => x.Name == "modules" || x.Name == "platforms") == 1)
            || // NuGet home
            (dir.EnumerateDirectories().Any(x => x.Name == "Libs") &&
             (dir.EnumerateFiles("Apache.Ignite.Core.dll").Any() ||
              dir.EnumerateFiles("Apache.Ignite.*.nupkg").Any()));
 }
Ejemplo n.º 2
0
    public static void Main(string[] args)
    {
      var statistics = new Dictionary<string, int>();

      IImageBinarizer binarizer = new ImageBinarizer();
      var directoryInfo = new DirectoryInfo(Environment.CurrentDirectory).Parent.Parent.Parent;
      var path = Path.Combine(directoryInfo.FullName, Program.DataDirectoryName);
      directoryInfo = new DirectoryInfo(path);

      var imageClassifier = new ImageClassifier(binarizer, Program.Size * Program.Size);
      //Train
      foreach (DirectoryInfo directory in directoryInfo.EnumerateDirectories())
      {
        foreach (var file in directory.EnumerateFiles("*.bmp"))
        {
          string fileName = Path.GetFileNameWithoutExtension(file.FullName);
          imageClassifier.Train(new ImageUnit { Id = fileName, Image = new Bitmap(file.FullName) });
        }
      }

      foreach (DirectoryInfo directory in directoryInfo.EnumerateDirectories())
      {
        foreach (var file in directory.EnumerateFiles("*.bmp"))
        {
          string fileName = Path.GetFileNameWithoutExtension(file.FullName);
          var patternDirectory = directory.EnumerateDirectories().FirstOrDefault(p => p.Name == ("Randomized_" + fileName));
          foreach (var patternFile in patternDirectory.EnumerateFiles("*.bmp"))
          {
            string patternFileName = Path.GetFileNameWithoutExtension(patternFile.FullName);
            string[] nameParts = patternFileName.Split(new[] { "_" }, StringSplitOptions.RemoveEmptyEntries);
            string percentValue = nameParts[1];
            if (statistics.ContainsKey(percentValue) == false)
            {
              statistics.Add(percentValue, 0);
            }
            string classificationResult = imageClassifier.Classify(new Bitmap(patternFile.FullName));
            if (classificationResult.Equals(fileName, StringComparison.CurrentCulture))
            {
              statistics[percentValue] += 1;
            }
          }
        }
      }

      Console.WriteLine("Classification result: ");

      foreach (var statistic in statistics)
      {
        Console.WriteLine("Percent - {0} Match - {1}", statistic.Key, statistic.Value);
      }

      Console.ReadLine();
    }
        public IObservable<FileSystemEntity> Iterate(string directoryFullName)
        {
            DirectoryInfo entry = new DirectoryInfo(directoryFullName);

            //Create a new data stream of FileSystemEntities (becoming our core data stream)
            var observableFileSystemEntities = Observable.Empty<FileSystemEntity>();

            //Create a new data stream of DirectoryInfos from the command root directory
            var observableDirectories = entry.EnumerateDirectories("*", SearchOption.AllDirectories).ToObservable();

            //Create a new data stream of FileSystemEntities based on the files laying inside the command root top level directory
            var observableFirstLevelFiles = entry.EnumerateFiles("*", SearchOption.TopDirectoryOnly)
                                                .ToObservable()
                                                .Select(x => new FileSystemEntity(x));

            //merge previous data stream into our core data stream of FileSystemEntities
            observableFileSystemEntities = observableFileSystemEntities.Merge(observableFirstLevelFiles);

            //Based on our stream of DirectoryInfos, project it into a stream of FileSystemEntities and merge it
            //into our core data stream
            observableFileSystemEntities = observableFileSystemEntities.Merge(observableDirectories.Select(x => new FileSystemEntity(x)));

            //Based on our stream of DirectoryInfos, project each stream of FileInfos into a flat stream
            //of FileInfos, project this into a stream of FileSystemEntities and merge it into our core stream
            var observableFiles = observableDirectories.SelectMany(x => x.EnumerateFiles().ToObservable()).Select(x => new FileSystemEntity(x));
            observableFileSystemEntities = observableFileSystemEntities.Merge(observableFiles);

            //return our core data stream
            return observableFileSystemEntities;
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Alls this instance.
        /// </summary>
        /// <returns></returns>
        public IEnumerable<DataModel.Release> All()
        {
            DirectoryInfo dir = new DirectoryInfo(Utilities.PathUtilities.MapPath(_configurationManager.HoardeBaseDirectory));
            return dir.EnumerateDirectories("*", SearchOption.TopDirectoryOnly).Select(x =>
            {
                string version = "";
                var versionMatches = VERSION_PARSER.Match(x.Name);

                if (versionMatches.Success)
                {
                    var matchedVersion = versionMatches.Groups[0];
                    version = matchedVersion.Value;
                }

                return new DataModel.Release
                {
                    CreatedOn = DateTime.Now,
                    Description = x.Name,
                    Id = x.Name.Replace(version, string.Empty).Trim('.'),
                    Version = version.Trim('.'),
                    UpdatedOn = DateTime.Now,
                    Title = x.Name,
                    Summary = string.Empty,
                    IconUrl = string.Empty,
                    Listed = true,
                    Published = DateTime.Now,
                    ReleaseNotes = string.Empty,
                    SHA1 = string.Empty,
                    Tags = string.Empty
                };
            })
            .Where(r => !r.Id.Equals(DreyConstants.ConfigurationPackageName, StringComparison.OrdinalIgnoreCase));
        }
        /// <summary>
        /// Recurse into the directory structure looking for files which need compiler directives to ignore XML comment violations.
        /// </summary>
        /// <param name="directoryInfo">The current directory level.</param>
        private void RecurseIntoDirectory(DirectoryInfo directoryInfo)
        {
            // This is the recursion part.  Look into every subdirectory at the current level for files that need the compiler directive.
            foreach (DirectoryInfo subDirectoryInfo in directoryInfo.EnumerateDirectories())
            {
                this.RecurseIntoDirectory(subDirectoryInfo);
            }

            // At the current directory level, look for intermediate files and add the directive that will inhibit the check for comments.
            foreach (FileInfo fileInfo in directoryInfo.EnumerateFiles(IgnoreGeneratedFilesBuildTask.SearchPattern))
            {
                // Read the entire file into a string buffer.
                string fileContent = File.ReadAllText(fileInfo.FullName);

                // Don't add the pragma if the code has already been modified.
                if (!fileContent.StartsWith("#pragma warning disable 1591", StringComparison.Ordinal))
                {
                    // If this module has been auto-generated (and hasn't already been modified), then add the directives at the start and end of the
                    // document that will prevent any documentation errors from kicking out of the analyzer.
                    if (fileContent.Contains("<auto-generated>"))
                    {
                        fileContent = "#pragma warning disable 1591\n" + fileContent + "#pragma warning restore 1591";
                        File.WriteAllText(fileInfo.FullName, fileContent);
                    }
                }
            }
        }
Ejemplo n.º 6
0
        public static void Visit(IFileSystemVisitor visitor, DirectoryInfo folder, bool recurse)
        {
            if (Visit(visitor, folder))
            {
                FileInfo[] fileitems;
                DirectoryInfo[] diritems;
                //try
                //{
                    fileitems = folder.EnumerateFiles().ToArray();
                    diritems = (recurse) ? folder.EnumerateDirectories().ToArray() : null;
                //}
                //catch (Exception ex)
                //{
                //    visitor.OnException(folder, ex);
                //    fileitems = new FileInfo[0];
                //    diritems = new DirectoryInfo[0];
                //}

                foreach (var file in fileitems)
                {
                    Visit(visitor, file);
                }

                Visited(visitor, folder);

                if (recurse)
                {
                    foreach (var subfolder in diritems)
                    {
                        Visit(visitor, subfolder, recurse);
                    }
                }
            }
        }
Ejemplo n.º 7
0
        private void DeleteEmptyFolders(string path)
        {
            try
            {
                foreach (var folder in Directory.EnumerateDirectories(path))
                {
                    DirectoryInfo folderInfo = new DirectoryInfo(folder);

                    foreach (var fileInfo in folderInfo.EnumerateFiles().Where(x => ext.Any(i => x.Extension != i)))
                    {
                        if (File.Exists(Path.Combine(path, fileInfo.Name))) File.Delete(Path.Combine(path, fileInfo.Name));
                        File.Move(fileInfo.FullName, Path.Combine(path, fileInfo.Name));
                    }

                    if (folderInfo.EnumerateFiles().Any()) return;
                    if (folderInfo.EnumerateDirectories().Any()) DeleteEmptyFolders(folder);

                    Directory.Delete(folder);
                    DeleteEmptyFolders(folder);
                }
            }
            catch (IOException ex)
            {
                Logger.WriteLine("An error occured while trying to delete empty folders in {0}: {1}", path, ex);
            }
        }
Ejemplo n.º 8
0
 public static void ProcessDir(DirectoryInfo directoryInfo, string outDir)
 {
     if (!Directory.Exists(outDir)) Directory.CreateDirectory(outDir);
     //
     DirectoryInfo outDirInfo = new DirectoryInfo(outDir);
     //
     // Directories:
     //
     ObsoleteDirs obsoleteDirs = new ObsoleteDirs(outDirInfo);
     foreach (DirectoryInfo subDirectoryInfo in directoryInfo.EnumerateDirectories())
     {
         obsoleteDirs.RemoveDirFromObsoleteList(subDirectoryInfo);
         //
         ProcessDir(subDirectoryInfo, Path.Combine(outDir, subDirectoryInfo.Name));
     }
     obsoleteDirs.DeleteDirs();
     //
     // Files:
     //
     ObsoleteFiles obsoleteFiles = new ObsoleteFiles(outDirInfo);
     foreach (FileInfo fileInfo in directoryInfo.EnumerateFiles())
     {
         string outFileName = processFile(fileInfo, outDir);
         obsoleteFiles.RemoveFileFromObsoleteList(outFileName);
     }
     obsoleteFiles.DeleteFiles();
 }
Ejemplo n.º 9
0
        private Dictionary <DirectoryInfo, List <string> > GetItemsToProcess()
        {
            var rootDirectory  = new System.IO.DirectoryInfo(_ftpFolderPath);
            var itemsToProcess = new Dictionary <System.IO.DirectoryInfo, List <string> >();

            foreach (var leve2bDirectory in rootDirectory.EnumerateDirectories())
            {
                if (leve2bDirectory.Name.ToLower() == _processed)
                {
                    continue;
                }

                foreach (var leve3bDirectory in leve2bDirectory.EnumerateDirectories())
                {
                    foreach (var file in leve3bDirectory.EnumerateFiles(_fileTypesToEnumerate))
                    {
                        if (itemsToProcess.ContainsKey(leve2bDirectory))
                        {
                            itemsToProcess[leve2bDirectory].Add(file.FullName);
                        }
                        else
                        {
                            var fileList = new List <string>();
                            fileList.Add(file.FullName);
                            itemsToProcess.Add(leve2bDirectory, fileList);
                        }
                    }
                }
            }

            return(itemsToProcess);
        }
Ejemplo n.º 10
0
        protected DirectoryInfo GetReferenceFileDirectory(params string[] subDirectories)
        {
            var dir = new DirectoryInfo(Directory.GetCurrentDirectory());
            while (dir != null)
            {
                var refDir = dir.EnumerateDirectories().FirstOrDefault(x => x.Name == "reference");

                if (refDir != null)
                {

                    if (subDirectories == null || subDirectories.Length == 0)
                        dir = refDir;
                    else
                    {
                        foreach (var directory in subDirectories)
                        {
                            if (refDir != null)
                                refDir = refDir.EnumerateDirectories().FirstOrDefault(x => x.Name == directory);
                        }
                        dir = refDir;
                    }
                    break;
                }

                dir = dir.Parent;
            }

            return dir;
        }
Ejemplo n.º 11
0
        public void GetApplicationFolderReturnsSubfolderFromVarTmpIfTmpDirIsTooLongInNonWindows()
        {
            if (!ApplicationFolderProvider.IsWindowsOperatingSystem())
            {
                string longDirectoryName = Path.Combine(this.testDirectory.FullName, new string('A', 300));
                var    varTmpdir         = new System.IO.DirectoryInfo(NonWindowsStorageProbePathVarTmp);

                // Initialize ApplicationfolderProvider
                var environmentVariables = new Hashtable
                {
                    { "TMPDIR", longDirectoryName },
                };

                var provider = new ApplicationFolderProvider(environmentVariables);

                IPlatformFolder applicationFolder = provider.GetApplicationFolder();

                // Evaluate
                Assert.IsNotNull(applicationFolder);
                Assert.IsFalse(Directory.Exists(longDirectoryName), "TEST ERROR: This directory should not be created.");
                Assert.IsTrue(Directory.Exists(varTmpdir.FullName), "TEST ERROR: This directory should be created.");
                Assert.IsTrue(varTmpdir.GetDirectories().Any(r => r.Name.Equals("Microsoft")), "TEST FAIL: TEMP subdirectories were not created");
                varTmpdir.EnumerateDirectories().ToList().ForEach(d => { if (d.Name == "Microsoft")
                                                                         {
                                                                             d.Delete(true);
                                                                         }
                                                                  });
            }
        }
Ejemplo n.º 12
0
        public string print(string path)
        {
            if (File.Exists(path))
            {
                StringBuilder sb = new StringBuilder();

                FileAttributes fas = File.GetAttributes(path);
                if ((fas & FileAttributes.Directory) == FileAttributes.Directory)
                {

                    DirectoryInfo di = new DirectoryInfo(path);
                    AppendLeaf(sb, 0, di.Name);

                    foreach (FileInfo fileInfo in di.EnumerateFiles())
                    {
                        AppendLeaf(sb, 1, fileInfo.Name);
                    }

                    foreach (DirectoryInfo dirInfo in di.EnumerateDirectories())
                    {
                        AppendLeaf(sb, 1, dirInfo.Name);
                    }

                    Console.WriteLine("Given path is directory");
                }
                else
                {
                    // is path to a file
                    AppendLeaf(sb, 0, path);
                    return sb.ToString();
                }

            }
            throw new ArgumentException("No such path exists");
        }
Ejemplo n.º 13
0
 protected IEnumerable<KeyValuePair<string, IEnumerable<KeyValuePair<string, string>>>> RenderDirectoryTree(DirectoryInfo rootDirectory, DirectoryInfo currentDirectory)
 {
     return currentDirectory
         .EnumerateDirectories()
         .SelectMany(directoryInfo => RenderDirectoryTree(rootDirectory, directoryInfo))
         .Concat(Enumerable.Repeat(RenderDirectoryViews(rootDirectory, currentDirectory), 1));
 }
Ejemplo n.º 14
0
        internal IEnumerable<FileInfo> GetFilesRecursive(DirectoryInfo rootDirectory)
        {
            foreach (var directory in rootDirectory.EnumerateDirectories())
            {
                if (directory.Name.StartsWith("_"))
                {
                    continue;
                }

                foreach (var file in GetFilesRecursive(directory))
                {
                    if (!file.Name.StartsWith("_"))
                    {
                        yield return file;
                    }
                }
            }

            foreach (var file in rootDirectory.EnumerateFiles())
            {
                if (file.Name.StartsWith("_")) continue;

                yield return file;
            }
        }
        public override InteriorField[,] GetLayout()
        {
            OpenFileDialog openFileDialog = new OpenFileDialog();
            openFileDialog.DefaultExt = "txt";
            DirectoryInfo currentDir = new DirectoryInfo(Environment.CurrentDirectory);
            openFileDialog.InitialDirectory = (currentDir.EnumerateDirectories().FirstOrDefault(d => d.Name == DataSubdirName) ?? currentDir).FullName;
            if (openFileDialog.ShowDialog().GetValueOrDefault())
            {
                this.LayoutIdentifier = openFileDialog.FileName;
                using (StreamReader readLines = new StreamReader(openFileDialog.OpenFile()))
                {
                    List<List<InteriorField>> layout = readLines
                        .ReadToEnd()
                        .Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)
                        .Select(s => s
                            .Select(c => this.CreateField(c)).ToList()).ToList();

                    int columnsCount = layout.Max(l => l.Count);
                    InteriorField[,] result = new InteriorField[layout.Count, columnsCount];
                    for (int row = 0; row < layout.Count; row++)
                    {
                        for (int col = 0; col < layout[row].Count; col++)
                        {
                            result[row, col] = layout[row][col];
                        }
                    }
                    return result;
                }
            }
            else
            {
                return null;
            }
        }
Ejemplo n.º 16
0
        private void BindData()
        {
            var directoryInfo = new DirectoryInfo(baseFolder);

            gwRepos.DataSource = directoryInfo.EnumerateDirectories(string.Format("*.{0}", Git.GIT_EXTENSION), SearchOption.AllDirectories);
            gwRepos.DataBind();
        }
Ejemplo n.º 17
0
        public static Tuple<DirectoryEntry, ImmutableList<ProjectEntry>> Create(DirectoryInfo dir, string relativePath)
        {
            if (relativePath == "packages")
                return new Tuple<DirectoryEntry, ImmutableList<ProjectEntry>>(PackagesEntry.Create(dir), null);

            if (relativePath != null && File.Exists(Path.Combine(dir.FullName, "project.json")))
                return ProjectEntry.Create(dir, relativePath);

            var dirsAndProjects = from d in dir.EnumerateDirectories()
                                  where !d.IsHidden()
                                  orderby d.Name
                                  select Create(d, Path.Combine(relativePath, d.Name));

            var dirs = ImmutableList.CreateBuilder<DirectoryEntry>();
            var projects = ImmutableList.CreateBuilder<ProjectEntry>();
            foreach (var dap in dirsAndProjects)
            {
                if (dap.Item2 != null)
                    projects.AddRange(dap.Item2);
                dirs.Add(dap.Item1);
            }

            var files = from f in dir.EnumerateFiles()
                        where !f.IsHidden()
                        orderby f.Name
                        select (Entry)FileEntry.Create(f, Path.Combine(relativePath, f.Name));

            return new Tuple<DirectoryEntry, ImmutableList<ProjectEntry>>(
                new DirectoryEntry(relativePath, false, dir,
                    dirs.ToImmutable(), files.ToImmutableList()),
                projects.ToImmutable());
        }
Ejemplo n.º 18
0
		public List<FileInfo> EnumerateAllJPGs(String Path)
		{
			List<FileInfo> Output = new List<FileInfo>();
			#region enumerate all .jpg in ./pics
			DirectoryInfo diTop = new DirectoryInfo(Path);
			foreach (var di in diTop.EnumerateDirectories("*"))
			{
				try
				{
					foreach (var fi in di.EnumerateFiles("*", SearchOption.AllDirectories))
					{
						try
						{
							if (fi.Extension.ToUpper() == ".JPG")
								Output.Add(fi);
						}
						catch (UnauthorizedAccessException UnAuthFile)
						{
						}
					}
				}
				catch (UnauthorizedAccessException UnAuthSubDir)
				{
				}
			}
			#endregion
			return Output;
		}
Ejemplo n.º 19
0
        private void button2_Click(object sender, EventArgs e)
        {
            try
            {
                textBox2.Clear();
                string path = textBox1.Text;
                if (string.IsNullOrEmpty(path) || string.IsNullOrWhiteSpace(path))
                {
                    MessageBox.Show("Hatalı Dizin Adresi / Directory Path should be checked.");
                }
                else
                {
                    path.Trim();
                    DirectoryInfo d = new DirectoryInfo(path);

                    IEnumerable<DirectoryInfo> fi = d.EnumerateDirectories();
                    textBox1.ScrollBars = ScrollBars.Vertical;
                    foreach (var directory in fi)
                    {
                        DirSortProcess dp = new DirSortProcess();
                        textBox2.Text += directory.Name + "\r\n";
                        textBox2.Text += dp.GetDirections(directory.FullName);



                    }
                }
            }


            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
Ejemplo n.º 20
0
        private static IEnumerable<FileInfo> FindFiles(DirectoryInfo directory, Regex pattern)
        {
            if (directory.Exists)
            {
                try
                {
                    return directory.EnumerateFiles("*.*")
                        .Where(x =>
                        {
                            try
                            {
                                return pattern.IsMatch(x.FullName);
                            }
                            catch (PathTooLongException)
                            {
                            }
                            catch (UnauthorizedAccessException)
                            {
                            }

                            return false;
                        })
                        .Concat(directory.EnumerateDirectories().SelectMany(x => FindFiles(x, pattern)));
                }
                catch (PathTooLongException)
                {
                }
                catch (UnauthorizedAccessException)
                {
                }
            }

            return Enumerable.Empty<FileInfo>();
        }
Ejemplo n.º 21
0
 private void run(DirectoryInfo baseDir)
 {
     try
     {
         foreach (var file in baseDir.EnumerateFiles(fileNameTemplate))
         {
             if (OnFoundFile != null)
                 OnFoundFile(file);
         }
         foreach (var dir in baseDir.EnumerateDirectories())
         {
             run(dir);
         }
     }
     catch (SecurityException e)
     {
         if (OnException != null)
             OnException(e);
     }
     catch (DirectoryNotFoundException e)
     {
         if (OnException != null)
             OnException(e);
     }
     catch (System.UnauthorizedAccessException e)
     {
         if (OnException != null)
             OnException(e);
     }
 }
        public void ForceDelete(string path)
        {
            if (!Directory.Exists(path))
            {
                return;
            }

            var baseFolder = new DirectoryInfo(path);

            foreach (var item in baseFolder.EnumerateDirectories("*", SearchOption.AllDirectories))
            {
                ResetAttributes(item);
            }

            foreach (var item in baseFolder.EnumerateFiles("*", SearchOption.AllDirectories))
            {
                ResetAttributes(item);
            }

            try
            {
                baseFolder.Delete(true);
            }
            catch (Exception exception)
            {
                Logger.LogInfrastructureError(string.Format(Messages.ErrorDirectoryDeletion, baseFolder.FullName), exception);
            }
        }
Ejemplo n.º 23
0
        private static Dictionary<Version, string> FindPythonSdkFromDirectories(params string[] directories)
        {
            var pythonSdkMap = new Dictionary<Version, string>();

            try {
                if (directories != null) {
                    for (int i = 0; i < directories.Length; i++) {
                        var rootDirectoryInfo = new DirectoryInfo(directories[i]);

                        if (rootDirectoryInfo.Exists) {
                            foreach (var dirInfo in rootDirectoryInfo.EnumerateDirectories()) {
                                Version pythonUwpVersion;

                                if (Version.TryParse(dirInfo.Name, out pythonUwpVersion)) {
                                    var prefixPath = dirInfo.GetDirectories(PythonUwpConstants.InterpreterRelativePath).FirstOrDefault();
                                    if (prefixPath.Exists) {
                                        var targetsFile = prefixPath?.GetFiles(PythonUwpConstants.InterpreterFile).FirstOrDefault();
                                        var libPath = prefixPath?.GetDirectories(PythonUwpConstants.InterpreterLibPath).FirstOrDefault();

                                        if (targetsFile != null && libPath != null) {
                                            // Note, the order of discovery is important.  The last one wins.
                                            pythonSdkMap[pythonUwpVersion] = prefixPath.FullName;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            } catch (IOException) {
                // IOException is not critical here, just means we cannot interrogate for factories at this point
            }

            return pythonSdkMap;
        }
        private static Model.DirectoryInfo Map(string absoluteFilePath, string rootPath)
        {
            var result = new Model.DirectoryInfo();

            if (Directory.Exists(absoluteFilePath))
            {
                var d = new System.IO.DirectoryInfo(absoluteFilePath);
                var r = d.FullName.RelativePath(rootPath);

                result.Name     = d.Name;
                result.Path     = r.ToBase64();
                result.FullName = r;

                foreach (var f in d.EnumerateFiles())
                {
                    result.Files.Add(Map(f, rootPath));
                }

                foreach (var enumerateDirectory in d.EnumerateDirectories())
                {
                    result.Directories.Add(Map(enumerateDirectory.FullName, rootPath));
                }
            }
            else
            {
                var f = new System.IO.FileInfo(absoluteFilePath);

                result.Files.Add(Map(f, rootPath));
            }

            return(result);
        }
Ejemplo n.º 25
0
        public void GIVEN__FilesAreCreatedOnDisk__WHEN__RootFtpFolderIsEnumerated__THEN__FilesToProcessAreDiscovered()
        {
            //Arrange
            string rootPath                 = @"C:\Users\Dave\Documents\Visual Studio 2013\Projects\XMLFeedImporter\XMLFeedImporter\ftp";
            var    rootDirectory            = new System.IO.DirectoryInfo(rootPath);
            var    subDirectoryFiles        = new List <string>();
            bool   filesToProcessDiscovered = false;

            //Act
            foreach (var leve2bDirectory in rootDirectory.EnumerateDirectories())
            {
                foreach (var leve3bDirectory in leve2bDirectory.EnumerateDirectories())
                {
                    foreach (var file in leve3bDirectory.EnumerateFiles("*.xml"))
                    {
                        subDirectoryFiles.Add(file.FullName);
                    }
                }
            }

            filesToProcessDiscovered = subDirectoryFiles.Count() > 0;

            //Assert
            Assert.IsTrue(filesToProcessDiscovered);
        }
Ejemplo n.º 26
0
        //main function, returns the XML of a entire directory (subdirectories included)
        internal static XElement GetDirectoryXml(String dir, string[] fileExtensions)
        {
            //Create DirectoryInfo
            DirectoryInfo Dir = new DirectoryInfo(dir);

            //Will be used to store the bad files
            List<FileInfo> BadFiles = new List<FileInfo>();

            //Will be used to store the processed files
            List<FileInfo> AlreadyProcessedFiles = new List<FileInfo>();

            //Mandatory to avoid invalid xml
            var info = new XElement("Root");

            //Gather file information
            ComputeFileInfo(Dir.EnumerateFiles().Where(f => fileExtensions.Contains(f.Extension.ToLower())).ToArray(),
                            ref info,
                            BadFiles,
                            AlreadyProcessedFiles,
                            fileExtensions);

            foreach (var subDir in Dir.EnumerateDirectories())
            {
                info.Add(GetDirectoryXml(subDir.FullName, fileExtensions));
            }

            return info;
        }
Ejemplo n.º 27
0
 public static void ClearDirectory(string dir)
 {
     try
     {
         if (string.IsNullOrWhiteSpace(dir))
         {
             return;
         }
         DirectoryInfo di = new DirectoryInfo(dir);
         if (!di.Exists)
         {
             return;
         }
         foreach (var item in di.EnumerateDirectories())
         {
             //item.Delete(true);
             DeleteDirectoryCheck(item.FullName);
         }
         foreach (var item in di.EnumerateFiles())
         {
             //item.Delete();
             DeleteFileCheck(item.FullName);
         }
     }
     catch(Exception ex)
     {
         System.Diagnostics.Debug.Assert(false);
         _logger.Error(null, ex);
     }
 }
Ejemplo n.º 28
0
        private static void PrepareDirectory(DirectoryInfo sourcePath, DirectoryInfo targetPath)
        {
            if (!sourcePath.Exists)
            {
                throw new DirectoryNotFoundException("Source directory " + sourcePath.FullName + " does not exist.");
            }

            targetPath.Create();

            foreach (var file in sourcePath.EnumerateFiles())
            {
                var overwrite = !file.Extension.Equals("yml", StringComparison.OrdinalIgnoreCase);
                var target = Path.Combine(targetPath.FullName, file.Name);

                // If file exists and should not be directly overwritten, just remember the user to manually update the file as needed.
                if (File.Exists(target) && !overwrite)
                {
                    var oldTarget = target;
                    target += ".dist";
                    Console.Error.WriteLine(
                        "WARNING: File {0} needs a manual update! Compare with {1} and rewrite your file.", oldTarget,
                        target);
                }

                file.CopyTo(target, overwrite);
            }

            foreach (var subdirectory in sourcePath.EnumerateDirectories())
            {
                PrepareDirectory(subdirectory, targetPath.CreateSubdirectory(subdirectory.Name));
            }
        }
Ejemplo n.º 29
0
        /// <summary>
        /// Downloads one or more packages.
        /// </summary>
        /// <param name="packageContainer">
        /// The packageto downloaded.
        /// </param>
        /// <param name="repositoryDirectory">
        /// The directory to which to download the packages.
        /// </param>
        /// <param name="overwrite">
        /// If set to <see langword="true"/>, any existing directory will be deleted.
        /// </param>
        /// <returns>
        /// A <see cref="Task"/> that represents the asynchronous operation
        /// </returns>
        public static async Task<DirectoryInfo> DownloadAndExtract(IArchiveContainer packageContainer, DirectoryInfo repositoryDirectory, bool overwrite)
        {
            // Create the directory into which to extract
            string directoryName = $"{packageContainer.Name}-{packageContainer.Revision}";

            // Figure out whether that directory already exists.
            DirectoryInfo targetDirectory;
            targetDirectory = repositoryDirectory.EnumerateDirectories(directoryName).SingleOrDefault();

            // If it does, proceed based on the value of the overwrite flag
            if (targetDirectory != null)
            {
                if (overwrite)
                {
                    // Delete the directory & proceed as usual.
                    targetDirectory.Delete(true);
                    targetDirectory = null;
                }
                else
                {
                    // Nothing left to do.
                    return targetDirectory;
                }
            }

            targetDirectory = repositoryDirectory.CreateSubdirectory(directoryName);

            foreach (var package in packageContainer.Archives)
            {
                Console.WriteLine($"Downloading package {package.Url} for {package.HostOs}");
                await package.DownloadAndExtract(targetDirectory);
            }

            return targetDirectory;
        }
Ejemplo n.º 30
0
        private static void FindAllFoldersAndFiles(DirectoryInfo di, Folder root)
        {
            try
            {
                var files = di.EnumerateFiles();
                foreach (var file in files)
                {
                    var currentFile = new File(file.Name, file.Length);
                    root.Files.Add(currentFile);
                }

                var folders = di.EnumerateDirectories();
                foreach (var folder in folders)
                {
                    var currentFolder = new Folder(folder.Name);
                    root.ChildFolders.Add(currentFolder);

                    FindAllFoldersAndFiles(folder, currentFolder);
                }
            }
            catch (UnauthorizedAccessException e)
            {
                Console.WriteLine(e.Message);
            }
        }
Ejemplo n.º 31
0
		private static async Task ServeDirectoryListingAsync(DirectoryInfo root, DirectoryInfo directory, HttpListenerResponse response)
		{
			StringBuilder listBuilder = new StringBuilder();

			foreach (FileInfo file in directory.EnumerateFiles())
			{
				String target = directory.IsSameDirectory(root) ? file.Name
				                                                : Path.Combine(directory.Name, file.Name);
				listBuilder.AppendFormat("<li><a href=\"{0}\">{1}</a></li>", target, file.Name);
			}

			foreach (DirectoryInfo subDirectory in directory.EnumerateDirectories())
			{
				String target = directory.IsSameDirectory(root) ? subDirectory.Name
				                                                : Path.Combine(directory.Name, subDirectory.Name);
				listBuilder.AppendFormat("<li><a href=\"{0}\">{1}</a></li>", target, subDirectory.Name);
			}

			String htmlResponse = String.Format("<ul>{0}</ul>", listBuilder.ToString());

			response.ContentType = "text/html";
			response.ContentLength64 = htmlResponse.Length;
			response.AddHeader("Date", DateTime.Now.ToString("r"));

			response.StatusCode = (Int32)HttpStatusCode.OK; // Must be set before writing to OutputStream.

			using (StreamWriter writer = new StreamWriter(response.OutputStream))
			{
				await writer.WriteAsync(htmlResponse).ConfigureAwait(false);
			}
		}
Ejemplo n.º 32
0
        public Form1()
        {
            InitializeComponent();

            //カレントディレクトリ内のフォルダ列挙
            System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(System.IO.Directory.GetCurrentDirectory());
            IEnumerable <System.IO.DirectoryInfo> files =
                di.EnumerateDirectories("*", System.IO.SearchOption.TopDirectoryOnly);

            //ファイルを列挙する
            foreach (System.IO.DirectoryInfo f in files)
            {
                systemList.Items.Add(f.Name);
            }

            StreamReader sr = new StreamReader(Directory.GetCurrentDirectory()
                                               + "/" + "SystemFolder"
                                               + "/" + "system.txt",
                                               Encoding.GetEncoding("Shift_JIS"));

            string str = sr.ReadToEnd();

            sr.Close();

            for (int no = 0; no < colorMode.Items.Count; no++)
            {
                if (str == colorMode.Items[no].ToString())
                {
                    colorMode.SelectedIndex = no;
                    break;
                }
            }

            isEdit = true;
        }
Ejemplo n.º 33
0
 private void RecurseChildDirectories(DirectoryInfo directory, List<FileInfo> files)
 {
     foreach (DirectoryInfo dir in directory.EnumerateDirectories())
     {
         files.AddRange(GetProjectFiles(dir));
     }
 }
Ejemplo n.º 34
0
        public static JObject Browse(string path = null)
        {
            if (path == null)
                path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

            var dir = new DirectoryInfo(path);
            var dirs = from d in dir.EnumerateDirectories()
                       select new JObject(
                           new JProperty("name", new JValue(d.Name)),
                           new JProperty("type", new JValue("dir")),
                           new JProperty("path", new JValue(d.FullName))
                        );
            var files = from f in dir.EnumerateFiles()
                        select new JObject(
                            new JProperty("name", new JValue(f.Name)),
                            new JProperty("type", new JValue("file")),
                            new JProperty("path", new JValue(f.FullName))
                        );

            if (dir.Parent != null)
                dirs = new[] { new JObject(
                           new JProperty("name", new JValue("..")),
                           new JProperty("type", new JValue("dir")),
                           new JProperty("path", new JValue(dir.Parent.FullName))
                        ) }.Concat(dirs);

            return new JObject(
                new JProperty("name", new JValue("browse")),
                new JProperty("title", new JValue("Open project")),
                new JProperty("path", new JValue(path)),
                new JProperty("folders", new JArray(dirs.ToArray())),
                new JProperty("files", new JArray(files.ToArray()))
            );
        }
Ejemplo n.º 35
0
 private void EnumerateFilesRecursiveAsync(DirectoryInfo folder, AccountFile destDirectory, AsyncTask task, CancellationToken token)
 {
     foreach (var file in folder.EnumerateFiles())
     {
         if (token.IsCancellationRequested)
             return;
         //var newTask = task == null
         //    ? new UploadFileTask(Account, AccountName, 0, null, file.FullName, destDirectory)
         //    : new UploadFileTask(Account, AccountName, 0, new[] { task }, file.FullName, null);
         var newTask = new UploadFileTask(Account, AccountName, 0, new[] { task }, file.FullName, null);
         AddTask(newTask);
         lastTask.AddParent(newTask);
     }
     foreach (var dir in folder.EnumerateDirectories())
     {
         if (token.IsCancellationRequested)
             return;
         //var newTask = task == null
         //    ? new CreateFolderTask(Account, AccountName, 0, null, dir.Name, destDirectory)
         //    : new CreateFolderTask(Account, AccountName, 0, new[] { task }, dir.Name, null);
         var newTask = new CreateFolderTask(Account, AccountName, 0, new[] { task }, dir.Name, null);
         AddTask(newTask);
         lastTask.AddParent(newTask);
         EnumerateFilesRecursiveAsync(dir, destDirectory, newTask, token);
     }
     OnProgress(new AsyncTaskProgressEventArgs(0, null));
 }
Ejemplo n.º 36
0
        private void ProcessDirectory(LocalDirectory parentDirectory, IO.DirectoryInfo directoryInfo)
        {
            if (parentDirectory == null)
            {
                throw new ArgumentNullException(nameof(parentDirectory));
            }

            if (directoryInfo == null)
            {
                throw new ArgumentNullException(nameof(directoryInfo));
            }

            try
            {
                LocalDirectory directory = (LocalDirectory)parentDirectory.GetSubdirectory(directoryInfo.Name);

                if (directory == null)
                {
                    directory = parentDirectory.CreateSubDirectory(directoryInfo.Name, directoryInfo.FullName);
                }

                foreach (var fileInfo in directoryInfo.EnumerateFiles().Where(f => !f.Name.StartsWith(".")))
                {
                    IndexingFile?.Invoke(this, new FilenameEventArgs(fileInfo.FullName));

                    LocalFile file = (LocalFile)directory.GetFile(fileInfo.Name);
                    if (file == null)
                    {
                        file = directory.CreateFile(fileInfo);
                    }
                    else
                    {
                        // XXX: Update file info
                    }

                    if (string.IsNullOrEmpty(file.InfoHash))
                    {
                        this.hasher.HashFile(file);
                    }
                }

                foreach (var subDirectoryInfo in directoryInfo.EnumerateDirectories().Where(d => !d.Name.StartsWith(".")))
                {
                    //ProcessDirectory(directory, subDirectoryInfo);
                    this.queue.Add(new QueueItem(directory, subDirectoryInfo), this.cancellation.Token);
                }
            }
            catch (ThreadAbortException)
            {
                // Canceled, ignore error.
            }
            catch (Exception ex)
            {
                this.loggingService.LogError("Error while re-indexing shared files:", ex);

                ErrorIndexing?.Invoke(this, new ErrorEventArgs(ex));
            }
        }
Ejemplo n.º 37
0
        private void InitPresets(string directory)
        {
            var dir = new System.IO.DirectoryInfo(Path.Combine("AppData", "Presets"));

            foreach (var item in dir.EnumerateDirectories())
            {
                this.Presets.Add(new Preset(item.Name, item.FullName));
            }
        }
Ejemplo n.º 38
0
        public WorldLoaderState(DwarfGame Game) :
            base(Game)
        {
            this.ProceedButtonText = "Load";
            this.NoItemsText       = "No worlds found.";
            this.InvalidItemText   = "This world was saved by an earlier version of DwarfCorp and is not compatible.";

            this.ValidateItem = (item) =>
            {
                return(NewOverworldFile.CheckCompatibility(item) ? "" : "Incompatible save file.");
            };

            this.GetItemName = (item) =>
            {
                return(NewOverworldFile.GetOverworldName(item));
            };

            this.ItemSource = () =>
            {
                System.IO.DirectoryInfo worldDirectory = System.IO.Directory.CreateDirectory(DwarfGame.GetWorldDirectory());
                var dirs = worldDirectory.EnumerateDirectories().ToList();
                dirs.Sort((a, b) =>
                {
                    var aMeta = a.GetFiles("meta.txt");
                    var bMeta = b.GetFiles("meta.txt");
                    if (aMeta.Length > 0 && bMeta.Length > 0)
                    {
                        return(bMeta[0].LastWriteTime.CompareTo(aMeta[0].LastWriteTime));
                    }

                    return(b.LastWriteTime.CompareTo(a.LastWriteTime));
                });
                return(dirs);
            };

            this.ScreenshotSource = (path) =>
            {
                try
                {
                    return(AssetManager.LoadUnbuiltTextureFromAbsolutePath(path + global::System.IO.Path.DirectorySeparatorChar + "screenshot.png"));
                }
                catch (Exception exception)
                {
                    Console.Error.WriteLine(exception.ToString());
                    return(null);
                }
            };

            this.OnProceedClicked = (path) =>
            {
                var file = NewOverworldFile.Load(path);
                GameStateManager.PopState();
                var genState = new WorldGeneratorState(Game, file.CreateSettings(), WorldGeneratorState.PanelStates.Launch);
                GameStateManager.PushState(genState);
            };
        }
Ejemplo n.º 39
0
        static void RecursiveDirectoryDelete(System.IO.DirectoryInfo baseDir)
        {
            if (!baseDir.Exists)
            {
                return;
            }

            foreach (var dir in baseDir.EnumerateDirectories())
            {
                RecursiveDirectoryDelete(dir);
            }
            baseDir.Delete(true);
        }
Ejemplo n.º 40
0
 static public int EnumerateDirectories(IntPtr l)
 {
     try {
         System.IO.DirectoryInfo self = (System.IO.DirectoryInfo)checkSelf(l);
         var ret = self.EnumerateDirectories();
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Ejemplo n.º 41
0
        /// <summary>

        /// Search a directory or archive and add any files or sub-directories

        /// to the list of candidates currently being resolved

        /// </summary>

        /// <param name="candidates">Candidates currently being resolved</param>
        public void Explode(SubmissionCandidates candidates, string workingDirectory)
        {
            if (IsArchive)
            {
                // Archives in Archives!!
                if (IsArchivedFile)
                {
                    string exportPath = Path.Combine(workingDirectory, HunterConfig.GalileoDefaultDataFolder + Path.DirectorySeparatorChar + "galileo_" + Guid.ToString() + FileExtension);

                    ArchiveInfo.Extract(ReadPath, exportPath);
                    _resolvePath = exportPath;
                }

                if (_fileType == FileTypes.Types.Zip)
                {
                    _archiveInfo     = new ZipArchiveInfo(ReadPath);
                    _archiveChildren = new List <SubmissionCandidate>(10);

                    if (_archiveInfo.IsOpen == false)
                    {
                        // Probably best to do something better than this?
                        throw new Exception("Could not open archive???");
                    }

                    foreach (var fileName in _archiveInfo)
                    {
                        SubmissionCandidate candidate = candidates.Add(fileName, _depth + 1, this);
                        _archiveChildren.Add(candidate);
                    }

                    // We leave _archiveInfo open, because later the files
                    // will want to be inspected and possibly extracted.
                }
            }
            else if (IsDirectory)
            {
                System.IO.DirectoryInfo info = new System.IO.DirectoryInfo(ReadPath);
                foreach (var file in info.EnumerateFiles())
                {
                    candidates.Add(file.FullName, _depth + 1, this);
                }
                foreach (var directory in info.EnumerateDirectories())
                {
                    candidates.Add(directory.FullName, _depth + 1, this);
                }
            }
        }
Ejemplo n.º 42
0
        private void SystemList_SelectedIndexChanged(object sender, EventArgs e)
        {
            scenarioList.Items.Clear();

            systemName.Text = systemList.SelectedItem.ToString();

            System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(System.IO.Directory.GetCurrentDirectory()
                                                                     + "/" + systemName.Text);
            IEnumerable <System.IO.DirectoryInfo> files =
                di.EnumerateDirectories("*", System.IO.SearchOption.TopDirectoryOnly);

            //ファイルを列挙する
            foreach (System.IO.DirectoryInfo f in files)
            {
                scenarioList.Items.Add(f.Name);
            }
        }
Ejemplo n.º 43
0
        public string GetFileServerProjectPath(Entity.Store store)
        {
            var programMappedPath = Configuration.ConfigHandler.InstanceOf.FileServerMappings.Where(
                x => x.Key == store.Program);

            string result = "";

            foreach (var pair in programMappedPath)
            {
                var path = new System.IO.DirectoryInfo(pair.Value);

                Logger.LoggerAsync.InstanceOf.GeneralLogger.Info("Preparing to enumerate directories under {0} looking for {1}", path.FullName, store.ProjectNumber);

                try {
                    var subFolders = path.EnumerateDirectories("*" + store.ProjectNumber + "*", System.IO.SearchOption.TopDirectoryOnly);

                    if (subFolders.Count() > 1)
                    {
                        foreach (var folder in subFolders)
                        {
                            result = this.GetFileServerProjectPath(store);
                        }
                    }
                    else if (subFolders.Count() < 1)
                    {
                        continue;
                    }
                    else
                    {
                        var folder = subFolders.First();

                        var rfi = this.FindFileServerRfi(folder);

                        result = rfi.FullName;
                    }
                } catch (Exception x) {
                    Logger.LoggerAsync.InstanceOf.GeneralLogger.Error(x);

                    throw x;
                }
            }

            this.path = result;

            return(result);
        }
Ejemplo n.º 44
0
 static public int EnumerateDirectories__String__SearchOption(IntPtr l)
 {
     try {
         System.IO.DirectoryInfo self = (System.IO.DirectoryInfo)checkSelf(l);
         System.String           a1;
         checkType(l, 2, out a1);
         System.IO.SearchOption a2;
         checkEnum(l, 3, out a2);
         var ret = self.EnumerateDirectories(a1, a2);
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Ejemplo n.º 45
0
        public static void DirectoryInfoTest()
        {
            Console.WriteLine("\n ------------ DIRECTORYINFO CLASS TEST ++++++++++++ ");

            var path  = Directory.GetCurrentDirectory() + "\\DirInfo";
            var path2 = Directory.GetCurrentDirectory() + "\\DirInfo2";

            /*Creation */
            DirectoryInfo di = new System.IO.DirectoryInfo(path);  // via ctrol

            di.Create();
            di.CreateSubdirectory("SubDir");

            var dinfo = Directory.CreateDirectory(path + "\\newDir"); //via Directory.CreateDirectory

            FileAttributes fileAttributes = di.Attributes;            //enum

            Console.WriteLine(fileAttributes.ToString());

            //di.CreateObjRef todo: wtf
            Console.WriteLine("Created: {0}", di.CreationTime.ToShortTimeString());
            //di.Delete();
            //di.EnumerateDirectories();
            var dirs = di.EnumerateDirectories(searchPattern: "*", searchOption: SearchOption.AllDirectories);// IEnumerable<DirInfo>

            Parallel.ForEach(dirs, (dir) => { Console.WriteLine(dir); });

            var files = di.EnumerateFiles(searchPattern: "*.txt");    // IEnumerable<FileInfo>

            Parallel.ForEach(files, (file) => { Console.WriteLine(file); });;

            IEnumerable <FileSystemInfo> filesSystemInfo = di.EnumerateFileSystemInfos(searchPattern: "*");

            Console.WriteLine("Exists: {0} ", di.Exists);
            Console.WriteLine("Extension: {0}", di.Extension);
            Console.WriteLine(di.FullName);
            DirectoryInfo[] dis = di.GetDirectories();
            di.GetFiles(searchOption: SearchOption.AllDirectories, searchPattern: "*.txt");
            // object lts = di.GetLifetimeService(); todo: wtf
            //di.GetObjectData()  wtf
            //di.MoveTo()



            di.InitializeLifetimeService();  //todo
        }
Ejemplo n.º 46
0
 private System.IO.DirectoryInfo ClearTempFolder()
 {
     System.IO.DirectoryInfo tempDirectory = new System.IO.DirectoryInfo(System.IO.Path.Combine(ResourceManager.Root, "temp"));
     if (!tempDirectory.Exists)
     {
         tempDirectory.Create();
     }
     foreach (System.IO.DirectoryInfo directory in tempDirectory.EnumerateDirectories())
     {
         try
         {
             directory.Delete(true);
         }
         catch (System.Exception ex_50)
         {
         }
     }
     return(tempDirectory);
 }
Ejemplo n.º 47
0
        public void GetApplicationFolderReturnsSubfolderFromVarTmpFolderIfTmpDirIsNotAvailableInNonWindows()
        {
            if (!ApplicationFolderProvider.IsWindowsOperatingSystem())
            {
                var dir      = new System.IO.DirectoryInfo(NonWindowsStorageProbePathVarTmp);
                var provider = new ApplicationFolderProvider();

                IPlatformFolder applicationFolder = provider.GetApplicationFolder();

                Assert.IsNotNull(applicationFolder);
                Assert.IsTrue(dir.GetDirectories().Any(r => r.Name.Equals("Microsoft")));


                dir.EnumerateDirectories().ToList().ForEach(d => { if (d.Name == "Microsoft")
                                                                   {
                                                                       d.Delete(true);
                                                                   }
                                                            });
            }
        }
Ejemplo n.º 48
0
        private System.IO.DirectoryInfo FindFileServerRfi(System.IO.DirectoryInfo folder)
        {
            try {
                var rfiFolder = folder.EnumerateDirectories("*RFI*");

                if (rfiFolder.Count() > 1)
                {
                    var ex = new ArgumentOutOfRangeException("FindFileServerRfi", "There cannot be more than one RFI folder per project");

                    Logger.LoggerAsync.InstanceOf.GeneralLogger.Error("Error at FindFileServerRfi {0}", ex);

                    throw ex;
                }

                return(rfiFolder.FirstOrDefault());
            } catch (Exception x) {
                Logger.LoggerAsync.InstanceOf.GeneralLogger.Error(x);

                throw x;
            }
        }
Ejemplo n.º 49
0
        public async Task <FolderItem> GetFolderDetail(string hostUrl, string relativeFolderPath)
        {
            if (Hosts.TryGetValue(hostUrl, out var host))
            {
                var ServiceAddress = OperationContext.Current.IncomingMessageHeaders.To;
                var UrlBuilder     = new UriBuilder(host.UrlRoot)
                {
                    Host = ServiceAddress.Host
                };

                var folder = new System.IO.DirectoryInfo(System.IO.Path.Combine(host.LocalFilePath ?? ".", relativeFolderPath.Trim('\\', '/')));
                if (folder.Exists)
                {
                    var folders = folder.EnumerateDirectories()
                                  .Select(x => new FolderItem
                    {
                        Name         = x.Name,
                        FullPath     = $"{UrlBuilder.ToString()}{relativeFolderPath}{host.DirectorySeparatorChar.ToString()}{x.Name }",
                        RelativePath = $"{relativeFolderPath}{host.DirectorySeparatorChar.ToString()}{x.Name }",
                    });

                    var files = folder.EnumerateFiles()
                                .Select(x => new FileItem
                    {
                        Name         = x.Name,
                        FullPath     = $"{UrlBuilder.ToString()}{relativeFolderPath}{host.DirectorySeparatorChar.ToString()}{x.Name }",
                        RelativePath = $"{relativeFolderPath}{host.DirectorySeparatorChar.ToString()}{x.Name }",
                    });
                    return(await Task.FromResult(new FolderItem
                    {
                        FullPath = folder.FullName,
                        Name = folder.Name,
                        Files = new Collection <FileItem>(files.ToList()),
                        Folders = new Collection <FolderItem>(folders.ToList()),
                        RelativePath = relativeFolderPath
                    }));
                }
            }
            return(null);
        }
Ejemplo n.º 50
0
        public void GetApplicationFolderReturnsSubfolderFromTmpFolderIfVarTmpIsNotAvailableInNonWindows()
        {
            if (!ApplicationFolderProvider.IsWindowsOperatingSystem())
            {
                var dir = new System.IO.DirectoryInfo(NonWindowsStorageProbePathTmp);

                var provider            = new ApplicationFolderProvider();
                var vartmpPathFieldInfo = provider.GetType().GetField("nonWindowsStorageProbePathVarTmp", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
                vartmpPathFieldInfo.SetValue(provider, "");

                IPlatformFolder applicationFolder = provider.GetApplicationFolder();

                Assert.IsNotNull(applicationFolder);
                Assert.IsTrue(dir.GetDirectories().Any(r => r.Name.Equals("Microsoft")));


                dir.EnumerateDirectories().ToList().ForEach(d => { if (d.Name == "Microsoft")
                                                                   {
                                                                       d.Delete(true);
                                                                   }
                                                            });
            }
        }
Ejemplo n.º 51
0
        public IActionResult Index(string path = "")
        {
            path = ValidatePath(path);

            path = path.Replace('!', '/');

            var baseDir = new System.IO.DirectoryInfo(path);
            var model   = new RssListViewModel
            {
                CurrentDir  = baseDir,
                Directories = baseDir.EnumerateDirectories()
                              .Where(x => !x.Attributes.HasFlag(FileAttributes.Hidden))
                              .Take(100)
                              .OrderBy(x => x.Name),
                Files = baseDir.EnumerateFiles()
                        .Where(x => !x.Attributes.HasFlag(FileAttributes.Hidden))
                        .Take(100)
                        .OrderBy(x => x.Name),
            };

            model.DisplayParentLink = path != _baseDir && model.CurrentDir.Parent != null;

            return(View(model));
        }
Ejemplo n.º 52
0
 public IEnumerable <IDirectoryInfo> EnumerateDirectories()
 {
     return(_inner.EnumerateDirectories().Select(Wrap).WhereNotNull());
 }
        private Dictionary <string, string> MergeImage(System.IO.DirectoryInfo di, Guid requestId)
        {
            var resultFiles = new Dictionary <string, string>();
            var resultDir   = di.EnumerateDirectories($"{requestId}").FirstOrDefault();

            if (resultDir != null)
            {
                foreach (var dir in resultDir.EnumerateDirectories())
                {
                    var imageFiles   = dir.EnumerateFiles("*.png").ToList();
                    var manifestFile = dir.EnumerateFiles($@"{dir.Name}.json").FirstOrDefault();

                    if (imageFiles.Any() && manifestFile != null)
                    {
                        var ssInfo = JsonConvert.DeserializeObject <ScreenshotDetail>(System.IO.File.ReadAllText(manifestFile.FullName));

                        var imageInfo = imageFiles.First();
                        var image     = System.Drawing.Image.FromFile($"{imageInfo.FullName}");

                        var width            = image.Width;
                        var height           = image.Height;
                        var canvasFullHeight = image.Height * imageFiles.Count;

                        var resutingImage = new System.Drawing.Bitmap(width, canvasFullHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb);

                        using (var g = System.Drawing.Graphics.FromImage(resutingImage))
                        {
                            var index             = 0;
                            var accumulatedHeight = 0d;

                            foreach (var imgInf in imageFiles)
                            {
                                var posY = index * height;

                                var img = System.Drawing.Image.FromFile($"{imgInf.FullName}");
                                var advanceAccumulatedHeight = accumulatedHeight + ssInfo.WindowHeight;

                                if (advanceAccumulatedHeight > ssInfo.DocHeight)
                                {
                                    var ratio  = height / ssInfo.WindowHeight;
                                    var offset = (ssInfo.DocHeight - accumulatedHeight) * ratio;

                                    var cropRect  = new System.Drawing.Rectangle(0, (int)Math.Ceiling((offset - height) * -1), width, (int)Math.Ceiling(offset));
                                    var cropedImg = new System.Drawing.Bitmap(cropRect.Width, cropRect.Height);

                                    using (var gc = System.Drawing.Graphics.FromImage(cropedImg))
                                    {
                                        gc.DrawImage(
                                            img,
                                            new System.Drawing.Rectangle(0, 0, cropedImg.Width, cropedImg.Height),
                                            cropRect,
                                            System.Drawing.GraphicsUnit.Pixel);
                                    }

                                    g.DrawImage(cropedImg, new System.Drawing.Point(0, posY));

                                    cropedImg.Dispose();
                                }
                                else
                                {
                                    g.DrawImage(img, new System.Drawing.Point(0, posY));
                                }



                                img.Dispose();

                                index++;
                                accumulatedHeight = advanceAccumulatedHeight;
                            }
                        }

                        image.Dispose();

                        var filepath = $@"{di.FullName}\{dir.Name}.png";

                        resutingImage.Save(filepath);
                        resutingImage.Dispose();

                        resultFiles.Add(dir.Name, filepath);
                    }
                }
            }

            return(resultFiles);
        }
Ejemplo n.º 54
0
 public IEnumerable <IDirectoryInfo> EnumerateDirectories()
 {
     return(inner.EnumerateDirectories().Select(Wrap));
 }
Ejemplo n.º 55
0
 /// <summary>
 /// Returns an enumerable collection of directory information in the current
 /// directory.
 /// </summary>
 /// <returns>
 /// An enumerable collection of directories in the current directory.
 /// </returns>
 /// <exception cref=" <exception cref="System.IO.DirectoryNotFoundException">">
 /// The path encapsulated in the System.IO.DirectoryInfo object is invalid (for
 /// example, it is on an unmapped drive).
 /// </exception>
 /// <exception cref="System.Security.SecurityException">
 /// The caller does not have the required permission.
 /// </exception>
 public IEnumerable <System.IO.DirectoryInfo> EnumerateDirectories()
 {
     return(_directoryInfo.EnumerateDirectories());
 }