|
public static EnumerateFiles ( string path ) : System.Collections.Generic.IEnumerable |
||
| path | string | |
| return | System.Collections.Generic.IEnumerable |
|
/// <summary>
/// The process for backing up a directory index is simple:
/// a) create hard links to all the files in the lucene directory in a temp director
/// that gives us the current snapshot, and protect us from lucene's
/// deleting files.
/// b) copy the hard links to the destination directory
/// c) delete the temp directory
/// </summary>
public void Execute()
{
foreach (var file in Directory.EnumerateFiles(tempPath))
{
Notify("Copying " + Path.GetFileName(file));
var fullName = new FileInfo(file).FullName;
FileCopy(file, Path.Combine(destination, Path.GetFileName(file)), fileToSize[fullName]);
Notify("Copied " + Path.GetFileName(file));
}
try
{
IOExtensions.DeleteDirectory(tempPath);
}
catch (Exception e) //cannot delete, probably because there is a file being written there
{
logger.WarnFormat(e, "Could not delete {0}, will delete those on startup", tempPath);
foreach (var file in Directory.EnumerateFiles(tempPath))
{
MoveFileEx(file, null, MoveFileDelayUntilReboot);
}
MoveFileEx(tempPath, null, MoveFileDelayUntilReboot);
}
}
/// <summary>
/// Examine the stylesheets and collect the font families they mention.
/// Note that the process used by ePub and bloomPub publication to
/// determine fonts is more complicated, using the DOM in an actual browser.
/// </summary>
/// <returns>Enumerable of font names</returns>
internal static IEnumerable <string> GetFontsUsed(string bookPath)
{
string bookHtmContent = null;
string defaultLangStylesContent = null;
var result = new HashSet <string>();
// Css for styles are contained in the actual html
foreach (var filePath in Directory.EnumerateFiles(bookPath, "*.*").Where(f => f.EndsWith(".css") || f.EndsWith(".htm") || f.EndsWith(".html")))
{
var fileContents = RobustFile.ReadAllText(filePath, Encoding.UTF8);
if (filePath.EndsWith(".htm"))
{
bookHtmContent = fileContents;
}
else if (filePath.EndsWith("defaultLangStyles.css"))
{
defaultLangStylesContent = fileContents;
// Delay processing defaultLangStyles to the end when we know we have the htm content.
continue;
}
HtmlDom.FindFontsUsedInCss(fileContents, result, false);
}
ProcessDefaultLangStyles(bookHtmContent, defaultLangStylesContent, result);
return(result);
}
public void Search_FilteredDirectoryFindedExcludeFileSystemEntry_RiseStartAndFinishEventsFindOnlyFiles()
{
// Arrange
var fsv = new FileSystemVisitor();
var isStartEventRised = false;
var isFinishEventRised = false;
fsv.Start += (sender, args) => { isStartEventRised = true; };
fsv.Finish += (sender, args) => { isFinishEventRised = true; };
fsv.FilteredDirectoryFinded += (sender, args) => { args.ExcludeFileSystemEntry = true; };
// Act
var findedEntries = fsv.Search(TestRootDirectoryName).ToArray();
// Assert
Assert.IsTrue(isStartEventRised);
Assert.IsTrue(isFinishEventRised);
var expectedEntries = DirectoryHelper.EnumerateFiles(TestRootDirectoryName, "*", SearchOption.AllDirectories).ToArray();
Assert.IsTrue(ArrayHelper.Compare(
expectedEntries,
findedEntries,
StringComparison)
);
}
private void CopyDirectory(string sourceFolder, string destinationFolder)
{
// check that source and destination folders exist
if (!sourceFolder.DirectoryExists() || !destinationFolder.DirectoryExists())
{
return;
}
// copy the files over
foreach (var file in Directory.EnumerateFiles(sourceFolder))
{
File.Copy(file, Path.Combine(destinationFolder, Path.GetFileName(file)), true);
}
// copy the directories over
foreach (var directory in Directory.EnumerateDirectories(sourceFolder))
{
var destinationDirName = Path.Combine(destinationFolder, Path.GetFileName(directory));
if (!Directory.Exists(destinationDirName))
{
Directory.CreateDirectory(destinationDirName);
}
CopyDirectory(directory, destinationDirName);
}
}
private RelationDefinition ReadDefinition()
{
var versionPath = Path.Combine("Definitions", "game.ver");
if (!File.Exists(versionPath))
{
throw new InvalidOperationException("Definitions\\game.ver must exist.");
}
var version = File.ReadAllText(versionPath).Trim();
var def = new RelationDefinition()
{
Version = version
};
foreach (var sheetFileName in Directory.EnumerateFiles("Definitions", "*.json"))
{
var json = File.ReadAllText(Path.Combine(sheetFileName), Encoding.UTF8);
var obj = JsonConvert.DeserializeObject <Newtonsoft.Json.Linq.JObject>(json);
var sheetDef = SheetDefinition.FromJson(obj);
def.SheetDefinitions.Add(sheetDef);
if (!_GameData.SheetExists(sheetDef.Name))
{
var msg = $"Defined sheet {sheetDef.Name} is missing.";
Debug.WriteLine(msg);
Console.WriteLine(msg);
}
}
return(def);
}
private static void GenerateIndex(string retroarchInstallPath)
{
Console.WriteLine("Generating system index...");
Helpers.DeleteFilesInFolder(IndexLocation);
var dbDir = $@"{retroarchInstallPath}\database\rdb\";
using (var indexOutputDir = FSDirectory.Open(IndexLocation))
{
using (var analyzer = new StandardAnalyzer(Version.LUCENE_30))
{
using (var writer = new IndexWriter(indexOutputDir, analyzer, IndexWriter.MaxFieldLength.UNLIMITED))
{
foreach (var dbPath in Directory.EnumerateFiles(dbDir, "*.rdb"))
{
var systemName = Path.GetFileNameWithoutExtension(dbPath);
var doc = new Document();
doc.Add(new Field("Name", systemName, Field.Store.YES, Field.Index.ANALYZED));
writer.AddDocument(doc);
}
writer.Optimize();
}
}
}
}
/// <summary>
/// The process for backing up a directory index is simple:
/// a) create hard links to all the files in the lucene directory in a temp director
/// that gives us the current snapshot, and protect us from lucene's
/// deleting files.
/// b) copy the hard links to the destination directory
/// c) delete the temp directory
/// </summary>
public void Execute()
{
if (allowOverwrite) // clean destination folder; we want to do this as close as possible to the actual backup operation
{
IOExtensions.DeleteDirectory(destination);
Directory.CreateDirectory(destination);
}
foreach (var file in Directory.EnumerateFiles(tempPath))
{
Notify("Copying " + Path.GetFileName(file), BackupStatus.BackupMessageSeverity.Informational);
var fullName = new FileInfo(file).FullName;
FileCopy(file, Path.Combine(destination, Path.GetFileName(file)), fileToSize[fullName]);
Notify("Copied " + Path.GetFileName(file), BackupStatus.BackupMessageSeverity.Informational);
}
try
{
IOExtensions.DeleteDirectory(tempPath);
}
catch (Exception e) //cannot delete, probably because there is a file being written there
{
logger.WarnException(
string.Format("Could not delete {0}, will delete those on startup", tempPath),
e);
foreach (var file in Directory.EnumerateFiles(tempPath))
{
MoveFileEx(file, null, MoveFileDelayUntilReboot);
}
MoveFileEx(tempPath, null, MoveFileDelayUntilReboot);
}
}
public static string CollectionIdFromCollectionFolder(string collectionFolder)
{
try
{
var settingsFilePath = Path.Combine(collectionFolder,
Path.ChangeExtension(Path.GetFileName(collectionFolder), "bloomCollection"));
if (!RobustFile.Exists(settingsFilePath))
{
// When we're joining a TC, we extract settings in to a temp folder whose name does not
// match the settings file.
var collections = Directory.EnumerateFiles(collectionFolder,
"*.bloomCollection").ToList();
if (collections.Count >= 1)
{
// Hopefully this repairs things.
settingsFilePath = collections[0];
}
else
{
return("");
}
}
var settingsContent = RobustFile.ReadAllText(settingsFilePath, Encoding.UTF8);
var xml = XElement.Parse(settingsContent);
return(ReadString(xml, "CollectionId", ""));
}
catch (Exception ex)
{
Bloom.Utils.MiscUtils.SuppressUnusedExceptionVarWarning(ex);
return("");
}
}
public void Restore()
{
var acls = IoDir.EnumerateFiles(_storeDir);
foreach (var acl in acls)
{
Restore(acl);
}
}
private void OnExecute()
{
var directory = Directory == "." ? Environment.CurrentDirectory : Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, Directory));
var outputPath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, Output));
var objFolder = $"{Path.DirectorySeparatorChar}obj{Path.DirectorySeparatorChar}";
var binFolder = $"{Path.DirectorySeparatorChar}bin{Path.DirectorySeparatorChar}";
var files = Dir
.EnumerateFiles(directory, "*.cs", SearchOption.AllDirectories)
.Where(path => !path.Contains(binFolder) &&
!path.Contains(objFolder));
if (Verbose)
{
Console.WriteLine("File found:");
foreach (var f in files)
{
Console.WriteLine(f);
}
}
var lines = files
.SelectMany(file => File.ReadAllLines(file));
var usings = lines
.Where(line => line.StartsWith("using"))
.Distinct();
var classes = lines.Where(line => !usings.Contains(line));
var outputDirectory = Path.GetDirectoryName(outputPath);
System.IO.Directory.CreateDirectory(outputDirectory);
using (var writer = File.CreateText(outputPath))
{
writer.WriteLine($"//Bundled {DateTime.Now}");
foreach (var line in usings)
{
writer.WriteLine(line);
}
writer.WriteLine();
foreach (var line in classes)
{
writer.WriteLine(line);
}
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"SUCCESS - Single source code file generated. {outputPath}");
Console.ResetColor();
}
public void HandleBookRename_CaseChangeOnly_WorksRight()
{
// Setup //
const string originalBookName = "A new book";
var bookBuilder = new BookFolderBuilder()
.WithRootFolder(_collectionFolder.FolderPath)
.WithTitle(originalBookName)
.WithHtm("<html><body>This is just a dummy</body></html>")
.Build();
string bookFolderPath = bookBuilder.BuiltBookFolderPath;
string htmlPath = bookBuilder.BuiltBookHtmPath;
TeamCollectionManager.ForceCurrentUserForTests("*****@*****.**");
_collection.PutBook(bookFolderPath);
var locked = _collection.AttemptLock(originalBookName);
Assert.That(locked, Is.True, "successfully checked out book to [email protected]");
// SUT: rename changes status in local collection folder, but not in shared repo folder
const string newBookName = "A New Book";
var newBookFolderPath = Path.Combine(_collectionFolder.FolderPath, newBookName);
File.Move(htmlPath, Path.Combine(bookFolderPath, newBookName + ".htm"));
// renaming directory doesn't work when names are 'the same'
var tempPath = Path.Combine(_collectionFolder.FolderPath, "tempxxyy");
Directory.Move(bookFolderPath, tempPath);
Directory.Move(tempPath, newBookFolderPath);
_collection.HandleBookRename(originalBookName, newBookName);
_collection.PutBook(newBookFolderPath, true);
var newRepoPath = Path.Combine(_sharedFolder.FolderPath, "Books", newBookName + ".bloom");
// It should not have been deleted! This is a regression test for BL-10156.
// The danger is that Windows considers the old and new names the same, so after
// we move the file to the new name, if we go to delete the old name, we get rid of the new one.
Assert.That(File.Exists(newRepoPath));
// Did it get renamed?
var matchingFiles = Directory.EnumerateFiles(Path.Combine(_sharedFolder.FolderPath, "Books"), newBookName + ".bloom").ToArray();
Assert.That(matchingFiles[0], Is.EqualTo(Path.Combine(_sharedFolder.FolderPath, "Books", newBookName + ".bloom")));
var newStatus = _collection.GetLocalStatus(newBookName);
var repoStatus = _collection.GetStatus(newBookName);
Assert.That(newStatus, Is.Not.Null, "local status of renamed book is not null");
Assert.That(repoStatus, Is.Not.Null, "repo status of renamed book is not null");
Assert.That(newStatus.checksum, Is.EqualTo(repoStatus.checksum), "checksums of local and remote match after rename");
Assert.That(newStatus.lockedBy, Is.EqualTo(null), "lockedBy of local and remote match after rename");
Assert.That(newStatus.oldName, Is.Null, "local status has original name cleared after commit");
}
public Dictionary <string, string[]> GetTemplates()
{
var files = IoDir.EnumerateFiles(_storeDirTemplate);
var dict = new Dictionary <string, string[]>();
foreach (var file in files)
{
dict[file] = File.ReadAllLines(file);
}
return(dict);
}
internal static void DeleteAllThumbnails()
{
foreach (var file in D.EnumerateFiles(ThumbnailFolderPath, "*", SearchOption.AllDirectories))
{
try
{
F.Delete(file);
}
catch
{
}
}
}
private bool CreateNeeded()
{
DirectoryPath = RequestPaths.GetPhysicalApplicationPath("App_Data\\nosql");
// ensure the import folder actually exists
if (!Directory.Exists(DirectoryPath))
{
new DirectoryInfo(DirectoryPath)
.mkdir()
.Attributes = FileAttributes.NotContentIndexed | FileAttributes.Hidden;
return(true);
}
return(!Directory.EnumerateFiles(DirectoryPath).Any());
}
public IEnumerable <DiscoveredFile> Discover(string path, HashSet <string> existingSources)
{
var files = _fileTypes.AsParallel().SelectMany(pattern =>
Directory.EnumerateFiles(path, pattern, SearchOption.TopDirectoryOnly)
);
var unprocessedFiles = files.Where(f => !existingSources.Contains(f.ToLower()))
.Select(filePath => new DiscoveredFile
{
Name = Path.GetFileName(filePath),
Extension = System.IO.Path.GetExtension(filePath),
Path = filePath,
Url = filePath
});
return(unprocessedFiles);
}
private static IEnumerable <string> EnumerateFilesInternal(
string path,
string searchPattern,
bool recursively)
{
var localPath = Requires.NotNullOrWhiteSpace(
path,
nameof(path));
var localSearchPattern = Requires.NotNullOrWhiteSpace(
searchPattern,
nameof(searchPattern));
return(FSDir.EnumerateFiles(
localPath,
localSearchPattern,
recursively ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly));
}
private static void Main()
{
var allVideos = Directory.EnumerateFiles(VideoPath)
.Where(file => file.ToLower().EndsWith(".mov")) // file.ToLower().EndsWith(".avi") ||
.ToList();
foreach (var videoFile in allVideos)
{
HandleFile(videoFile, true, VideoDestinationPath);
}
var allPictures = Directory.EnumerateFiles(PicturePath)
.Where(file => file.ToLower().EndsWith(".jpg"))
.ToList();
foreach (var picture in allPictures)
{
HandleFile(picture, false, PictureDestinationPath);
}
}
private void BuildFromWeiboWebPages()
{
var indexWriter = LuceneOperations.GetIndexWriter(WeiboConfigure.OutputPath);
//int totalWeiboCount = 0;
//int totalFileCount = 0;
foreach (var filename in Directory.EnumerateFiles(WeiboConfigure.InputPath, "*.txt", SearchOption.AllDirectories))
{
if (Path.GetFileName(filename).StartsWith("_"))
{
continue;
}
var parser = new WeiboParser(filename);
foreach (var weibo in parser.GetContainedWeibo())
{
Document doc = new Document();
doc.Add(new Field(WeiboLuceneFields.UserNickName, weibo.UserNickName, Field.Store.YES, Field.Index.ANALYZED));
doc.Add(new Field(WeiboLuceneFields.UserID, weibo.UserID, Field.Store.YES, Field.Index.ANALYZED));
doc.Add(new Field(WeiboLuceneFields.NewsArticleDescription, weibo.Content, Field.Store.YES, Field.Index.ANALYZED));
doc.Add(new Field(WeiboLuceneFields.DiscoveryStringTime, weibo.Time, Field.Store.YES, Field.Index.ANALYZED));
doc.Add(new Field(WeiboLuceneFields.Source, weibo.Source, Field.Store.YES, Field.Index.ANALYZED));
doc.Add(new Field(WeiboLuceneFields.UpCount, weibo.UpCount.ToString(), Field.Store.YES, Field.Index.ANALYZED));
doc.Add(new Field(WeiboLuceneFields.ForwardCount, weibo.ForwardCount.ToString(), Field.Store.YES, Field.Index.ANALYZED));
doc.Add(new Field(WeiboLuceneFields.CollectCount, weibo.CollectCount.ToString(), Field.Store.YES, Field.Index.ANALYZED));
doc.Add(new Field(WeiboLuceneFields.ReplyCount, weibo.ReplyCount.ToString(), Field.Store.YES, Field.Index.ANALYZED));
indexWriter.AddDocument(doc);
}
//Console.WriteLine(filename);
//var cnt = parser.GetContainedWeibo().Count;
//Console.WriteLine(cnt);
//totalWeiboCount += cnt;
//totalFileCount++;
}
//Console.WriteLine("Total count:" + totalWeiboCount);
//Console.WriteLine("Total file count: " + totalFileCount);
indexWriter.Optimize();
indexWriter.Close();
}
private static Task <IEnumerable <string> > EnumerateFilesInternalAsync(
string path,
string searchPattern,
bool recursively,
CancellationToken cancellationToken)
{
var localPath = Requires.NotNullOrWhiteSpace(
path,
nameof(path));
var localSearchPattern = Requires.NotNullOrWhiteSpace(
searchPattern,
nameof(searchPattern));
return(Work.OnThreadPoolAsync(
state => FSDir.EnumerateFiles(
state.Path,
state.Pattern,
state.Recursive),
(Path: localPath, Pattern: localSearchPattern, Recursive: recursively ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly),
cancellationToken));
}
private void RemoveDirectory(string directoryFolder)
{
// remove all files
foreach (var fileToBeRemoved in Directory.EnumerateFiles(directoryFolder))
{
fileToBeRemoved.TryHardToDelete();
}
// remove all subdirectories
foreach (var folderToBeRemoved in Directory.EnumerateDirectories(directoryFolder))
{
RemoveDirectory(folderToBeRemoved);
}
try
{
// now try to remove the directory
Directory.Delete(directoryFolder);
}
catch { }
}
[DataRow("iii")] // Missing substring
public void Search_FilteredDirectoryFindedWithSubstringFilter_RiseEventForEachFilteredSubdirectoryInDirectory(string substring)
{
// Arrange
var fsv = new FileSystemVisitor((path) => path.Contains(substring));
var filteredDirectories = new List <string>();
fsv.FilteredFileFinded += (sender, args) => { filteredDirectories.Add(args.Path); };
// Act
fsv.Search(TestRootDirectoryName).ToArray();
// Assert
var expectedEntries = DirectoryHelper.EnumerateFiles(TestRootDirectoryName, $"*{substring}*", SearchOption.AllDirectories).ToArray();
Assert.IsTrue(ArrayHelper.Compare(
expectedEntries,
filteredDirectories.ToArray(),
StringComparison)
);
}
public static IEnumerable <LuceneSearchModel> GetAllIndexRecords()
{
// validate search index
if (!Directory.EnumerateFiles(_luceneDir).Any())
{
return(new List <LuceneSearchModel>());
}
// set up lucene searcher
var searcher = new IndexSearcher(_directory, false);
IndexReader reader = IndexReader.Open(_directory, false);
var docs = new List <Document>();
TermDocs term = reader.TermDocs();
while (term.Next())
{
docs.Add(searcher.Doc(term.Doc));
}
reader.Dispose();
searcher.Dispose();
return(_mapLuceneToDataList(docs));
}
public static void CopyDirectory(string source, string destination)
{
IoDir.CreateDirectory(source);
IoDir.CreateDirectory(destination);
foreach (var dirPath in IoDir.EnumerateDirectories(source, "*", SearchOption.AllDirectories))
{
try {
IoDir.CreateDirectory(dirPath.Replace(source, destination));
}
catch (Exception) {
Bash.Execute($"mkdir -p {dirPath.Replace(source, destination)}", false);
}
}
foreach (var newPath in IoDir.EnumerateFiles(source, "*", SearchOption.AllDirectories))
{
try {
File.Copy(newPath, newPath.Replace(source, destination), true);
}
catch (Exception) {
Bash.Execute($"cp {newPath} {newPath.Replace(source, destination)}", false);
}
}
}
public bool DeleteEntries()
{
void DeleteCore(string path)
{
foreach (var file in D.EnumerateFiles(path))
{
File.Delete(file);
}
foreach (var dir in D.EnumerateDirectories(path))
{
DeleteCore(dir);
D.Delete(dir);
}
}
if (!this.Exists())
{
return(false);
}
DeleteCore(this.FullName);
return(true);
}
public IEnumerable <FilePath> EnumerateFiles(string searchPattern = "*") => D.EnumerateFiles(this.FullName, searchPattern).Select(x => new FilePath(x, false));
/// <summary>
/// Copies a directory to a new location including all files and folders beneath it.
/// Creates a new directory if necessary.
/// </summary>
/// <param name="path">The path of the directory to copy.</param>
/// <param name="newPath">The destination path to copy the directory to.</param>
/// <param name="overwrite">Whether to overwrite any existing files in the directory being copied to.</param>
/// <returns>True if the directory was copied. False otherwise.</returns>
static public bool Copy(string path, string newPath, bool overwrite = false)
{
if (!string.IsNullOrEmpty(path) && !string.IsNullOrEmpty(newPath))
{
// Ensure that the paths end in a slash.
if (!path.EndsWith(@"\"))
{
// Add the slash.
path += @"\";
}
if (!newPath.EndsWith(@"\"))
{
// Add the slash.
newPath += @"\";
}
// Determine if the path is a directory.
if (SystemDirectory.Exists(path))
{
// It is a directory.
try
{
// Check whether the directory to copy to exists.
if (!SystemDirectory.Exists(newPath))
{
// Clone a new directory to copy the directory into.
// This ensures we get the same permissions.
if (!Clone(path, newPath))
{
// The directory couldn't be cloned.
return(false);
}
}
// Copy the contents of subdirectories.
foreach (string directoryName in SystemDirectory.EnumerateDirectories(path))
{
// Get the name of the subdirectory.
string subDirectoryName = directoryName.Substring(path.Length);
// Recursively copy the directory.
if (!Copy(directoryName, newPath + subDirectoryName + @"\", overwrite))
{
// The directory couldn't be copied.
return(false);
}
}
// Copy any files in the directory.
foreach (string fileName in SystemDirectory.EnumerateFiles(path))
{
FileInfo originalFileInfo = new FileInfo(fileName);
if (!File.Copy(fileName, newPath, overwrite))
{
// The file couldn't be copied.
return(false);
}
}
return(true);
}
catch
{
// There was an error copying the directory or its contents.
return(false);
}
}
}
// The path or newPath were null, or the path to clone did not exist.
return(false);
}
private bool InstallNugetPackage(Package provider, Link link, string fastPath, BootstrapRequest request)
{
// download the nuget package
string downloadedNupkg = request.DownloadAndValidateFile(provider._swidtag);
if (downloadedNupkg != null)
{
// extracted folder
string extractedFolder = String.Concat(FilesystemExtensions.GenerateTemporaryFileOrDirectoryNameInTempDirectory());
try
{
//unzip the file
ZipFile.ExtractToDirectory(downloadedNupkg, extractedFolder);
if (Directory.Exists(extractedFolder))
{
string versionFolder = Path.Combine(request.DestinationPath(request), provider.Name, provider.Version);
// tool folder is where we find things like nuget.exe
string toolFolder = Path.Combine(extractedFolder, "tools");
string libFolder = Path.Combine(extractedFolder, "lib");
// create the directory version folder if not exist
if (!Directory.Exists(versionFolder))
{
Directory.CreateDirectory(versionFolder);
}
// copy the tools directory
if (Directory.Exists(toolFolder))
{
string destinationToolFolder = Path.Combine(versionFolder, "tools");
if (!Directory.Exists(destinationToolFolder))
{
Directory.CreateDirectory(destinationToolFolder);
}
foreach (string child in Directory.EnumerateFiles(toolFolder))
{
try
{
// try copy and overwrite
File.Copy(child, Path.Combine(destinationToolFolder, Path.GetFileName(child)), true);
}
catch (Exception e)
{
request.Debug(e.StackTrace);
if (!(e is UnauthorizedAccessException || e is IOException))
{
// something wrong, delete the version folder
versionFolder.TryHardToDelete();
return(false);
}
// otherwise this means the file is just being used. so just moves on to copy other files
}
}
}
// copy files from lib
if (Directory.Exists(libFolder))
{
// check that the lib folder has at most 1 dll
if (Directory.EnumerateFiles(libFolder).Count(file => String.Equals(Path.GetExtension(file), ".dll", StringComparison.OrdinalIgnoreCase)) > 1)
{
request.Warning(String.Format(CultureInfo.CurrentCulture, Resources.Messages.MoreThanOneDllExists, provider.Name));
return(false);
}
foreach (string child in Directory.EnumerateFiles(libFolder))
{
try
{
File.Copy(child, Path.Combine(versionFolder, Path.GetFileName(child)), true);
}
catch (Exception e)
{
request.Debug(e.StackTrace);
if (!(e is UnauthorizedAccessException || e is IOException))
{
// something wrong, delete the version folder
versionFolder.TryHardToDelete();
return(false);
}
// otherwise this means the file is just being used. so just moves on to copy other files
}
}
}
// target file name is the assembly provider
string targetFile = Path.Combine(versionFolder, Path.GetFileName(link.Attributes[Iso19770_2.Discovery.TargetFilename]));
if (File.Exists(targetFile))
{
request.Verbose(Resources.Messages.InstalledPackage, provider.Name, targetFile);
request.YieldFromSwidtag(provider, fastPath);
return(true);
}
}
}
finally
{
downloadedNupkg.TryHardToDelete();
extractedFolder.TryHardToDelete();
}
}
return(false);
}
public IEnumerable <FilePath> EnumerateAllFiles(string searchPattern = "*") => D.EnumerateFiles(this.FullName, searchPattern, SearchOption.AllDirectories).Select(x => new FilePath(x, false));
public IEnumerable <FileSystemPath> EnumerateAllEntries(string searchPattern = "*") => D.EnumerateDirectories(this.FullName, searchPattern, SearchOption.AllDirectories).Select(x => (FileSystemPath) new DirectoryPath(x, false)) .Concat(D.EnumerateFiles(this.FullName, searchPattern, SearchOption.AllDirectories).Select(x => (FileSystemPath) new FilePath(x, false)));
public void PerformSort()
{
var sourceFiles = Directory.EnumerateFiles(textBoxSourceFolder.Text, textBoxSearchPattern.Text);
foreach (var sourceFile in sourceFiles)
{
if (backgroundWorkerSort.CancellationPending)
{
return;
}
var sourceFilename = new FileInfo(sourceFile).Name;
var dateTaken = new DateTime();
using (var fs = new FileStream(sourceFile, FileMode.Open, FileAccess.Read, FileShare.Read))
{
var metadata = (BitmapMetadata)BitmapFrame.Create(fs).Metadata;
if (metadata != null)
{
DateTime.TryParse(metadata.DateTaken, out dateTaken);
}
if (dateTaken == DateTime.MinValue)
{
var fileInfo = new FileInfo(sourceFile);
dateTaken = fileInfo.LastWriteTime;
}
}
var targetDirectoryWithYear = Path.Combine(textBoxTargetFolder.Text, dateTaken.Year.ToString());
if (!Directory.Exists(targetDirectoryWithYear))
{
Directory.CreateDirectory(targetDirectoryWithYear);
}
var targetDirectoryWithYearAndMonth = string.Format("{0}", Path.Combine(targetDirectoryWithYear, dateTaken.Month.ToString().PadLeft(2, '0')));
if (!Directory.Exists(targetDirectoryWithYearAndMonth))
{
Directory.CreateDirectory(targetDirectoryWithYearAndMonth);
}
var imageLocation = GetImageLocation(sourceFile);
var targetDirectoryWithYearAndMonthAndLocation = targetDirectoryWithYearAndMonth;
if (!string.IsNullOrEmpty(imageLocation))
{
targetDirectoryWithYearAndMonthAndLocation = Path.Combine(targetDirectoryWithYearAndMonth, imageLocation);
if (!Directory.Exists(targetDirectoryWithYearAndMonthAndLocation))
{
Directory.CreateDirectory(targetDirectoryWithYearAndMonthAndLocation);
}
}
var targetDirectoryWithYearAndMonthAndLocationAndFilename = string.Format("{0}\\{1}",
targetDirectoryWithYearAndMonthAndLocation, sourceFilename);
File.Copy(sourceFile, targetDirectoryWithYearAndMonthAndLocationAndFilename, true);
var progressText = string.Format(@"File {0} copied", sourceFilename);
backgroundWorkerSort.ReportProgress(0, progressText);
}
}