ProcessFiles.cs 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159
  1. using System;
  2. using System.Collections.Generic;
  3. using System.IO;
  4. using System.Linq;
  5. namespace ProcessFiles
  6. {
  7. public enum Result
  8. {
  9. File,
  10. Directory,
  11. Failure
  12. }
  13. public class ProcessFiles
  14. {
  15. private readonly List<string> errors = [];
  16. private readonly List<char> invalidCharactersForExtension = ['?', '*'];
  17. private Result WhatIsIt(string path)
  18. {
  19. if (!File.Exists(path) && !Directory.Exists(path))
  20. {
  21. errors.Add($"{path} doesn't exist!");
  22. return Result.Failure;
  23. }
  24. try
  25. {
  26. var attr = File.GetAttributes(path);
  27. return (attr & FileAttributes.Directory) == FileAttributes.Directory ? Result.Directory : Result.File;
  28. }
  29. catch (Exception e)
  30. {
  31. errors.Add($"Problem getting attributes of {path}: {e.Message} ({e.Source})");
  32. return Result.Failure;
  33. }
  34. }
  35. private string? GetExtension(string path)
  36. {
  37. var extension = Path.GetExtension(path).TrimStart('.');
  38. if (!string.IsNullOrWhiteSpace(extension)) return extension;
  39. errors.Add($"Can't establish extension of {path}!");
  40. return null;
  41. }
  42. private static bool CheckExtension(string extension, string[] validExtensions)
  43. {
  44. return validExtensions.Any(validExtension => extension.Equals(validExtension, StringComparison.OrdinalIgnoreCase));
  45. }
  46. private bool IsValid(string path, string[] fileExtensions)
  47. {
  48. var extension = GetExtension(path);
  49. if (extension == null)
  50. return false;
  51. if (CheckExtension(extension, fileExtensions)) return true;
  52. errors.Add($"Extension of {path} doesn't match any extension ({string.Join(", ", fileExtensions)})!");
  53. return false;
  54. }
  55. private void PerformAction(string path, Action<string> action)
  56. {
  57. try
  58. {
  59. action(path);
  60. }
  61. catch (Exception e)
  62. {
  63. errors.Add($"Problem performing action on {path}: {e.Message} ({e.Source})");
  64. }
  65. }
  66. private void ProcessFile(string path, string[] fileExtensions, Action<string> action)
  67. {
  68. if (!IsValid(path, fileExtensions))
  69. return;
  70. PerformAction(path, action);
  71. }
  72. private void ProcessDir(string path, string[] fileExtensions, Action<string> action, bool recursive = false)
  73. {
  74. if (!Directory.Exists(path))
  75. {
  76. errors.Add($"{path} doesn't exist!");
  77. return;
  78. }
  79. var searchOption = recursive switch
  80. {
  81. false => SearchOption.TopDirectoryOnly,
  82. true => SearchOption.AllDirectories,
  83. };
  84. string[] allFiles = [];
  85. try
  86. {
  87. allFiles = Directory.GetFiles(path, "*", searchOption);
  88. }
  89. catch (Exception e)
  90. {
  91. errors.Add($"Problem getting files: {e.Message} ({e.Source})");
  92. return;
  93. }
  94. var files = allFiles
  95. .Where(file => CheckExtension(Path.GetExtension(file).TrimStart('.'), fileExtensions))
  96. .Distinct()
  97. .ToList();
  98. if (files.Count == 0)
  99. {
  100. errors.Add($"There are no files in {path} with given extensions ({string.Join(", ", fileExtensions)})!");
  101. return;
  102. }
  103. foreach (var file in files)
  104. ProcessFile(file, fileExtensions, action);
  105. }
  106. private bool ValidExtension(string fileExtension) => !invalidCharactersForExtension.Any(fileExtension.Contains);
  107. private List<string> GetInvalidExtensions(string [] fileExtensions) => [.. fileExtensions.Where(x => !ValidExtension(x))];
  108. public List<string> Process(IEnumerable<string> arguments, string fileExtension, Action<string> action, bool recursive = false)
  109. {
  110. return Process(arguments, [fileExtension], action, recursive);
  111. }
  112. public List<string> Process(IEnumerable<string> arguments, string[] fileExtensions, Action<string> action, bool recursive = false)
  113. {
  114. var invalidExtensions = GetInvalidExtensions(fileExtensions);
  115. if (invalidExtensions.Count > 0) throw new ArgumentException($"Following extensions contain invalid characters ({string.Join(", ", invalidCharactersForExtension)}):\n{string.Join(Environment.NewLine, invalidExtensions)}");
  116. foreach (var argument in arguments)
  117. {
  118. switch (WhatIsIt(argument))
  119. {
  120. case Result.File:
  121. ProcessFile(argument, fileExtensions, action);
  122. break;
  123. case Result.Directory:
  124. ProcessDir(argument, fileExtensions, action, recursive);
  125. break;
  126. case Result.Failure:
  127. default:
  128. continue;
  129. }
  130. }
  131. return [.. errors];
  132. }
  133. }
  134. }