void ProcessFiles(string msg)
{
lock (_locker) if (_inBatch)
{
return;
}
//Open the folder and keep going until there are any files left
//Skip any locked files
try {
if (LockPath(_inputFolder))
{
Log.Debug("{0} ({1}\\{2})", msg, _inputFolder, _info.Filter);
StartBatch();
FileSystemEnumerator fse = new FileSystemEnumerator(_inputFolder, _info.Filter ?? "*", includeSubDirs: false);
int i = 0;
foreach (FileInfo f in fse.Matches())
{
if (!IsLocked(f.FullName))
{
EnqueueFile(f.FullName, f.Name);
++i;
}
}
Log.Debug("{0} - enqueued {1} files", msg, i);
StopBatch();
UnlockPath(_inputFolder);
}
} catch (Exception e) {
Log.Error("Exception processing files. ERROR: {0}", e.ToString().Replace("\n", " "));
}
}
/// <summary>
/// Finds all files within the CSData folder and loads them to memory
/// </summary>
/// <returns>Lazy loading coroutine, loading on demand</returns>
private IEnumerator FindAllFiles()
{
string localPath = CSUtils.CSDataPath;
Log($"Locating all files in CSData folder (@{localPath})");
//Locate data folder
if (!Directory.Exists(localPath))
{
Debug.LogWarning(DebugPrefix + "CSData folder could not be located. Creating new one.");
Directory.CreateDirectory(localPath);
yield break; //Created folder will be empty
}
//Enumerate through all files in all the folders starting at the root folder
using (FileSystemEnumerator e = new FileSystemEnumerator(localPath, "*", true))
{
//Loop through all "normal" files
foreach (FileInfo file in e.Matches().Where(f => f.Attributes == FileAttributes.Normal && !string.IsNullOrEmpty(f.Extension)))
{
this.loadingbar.SetLabel("Locating file " + file.FullName);
List <FileInfo> files;
string jsonExt = Path.GetExtension(file.Name);
//If there is a secondary extension, assume it's a potential Json file
if (!string.IsNullOrEmpty(jsonExt))
{
Dictionary <string, List <FileInfo> > jsonFiles;
if (!this.jsonFilesByExt.TryGetValue(file.Extension, out jsonFiles))
{
jsonFiles = new Dictionary <string, List <FileInfo> >();
this.jsonFilesByExt.Add(file.Extension, jsonFiles);
}
if (!jsonFiles.TryGetValue(jsonExt, out files))
{
files = new List <FileInfo>();
jsonFiles.Add(jsonExt, files);
}
files.Add(file);
}
//If .dll file
if (file.Extension == ".dll")
{
this.dlls.Add(file);
}
//Add to normal extension dict
if (!this.filesByExt.TryGetValue(file.Extension, out files))
{
files = new List <FileInfo>();
this.filesByExt.Add(file.Extension, files);
}
files.Add(file);
this.allFiles.Add(file);
Log("Located " + file.FullName);
yield return(null);
}
}
}
private Glob(string text, SegmentSequence[] segments)
{
this.text = text;
this.segments = segments;
this.regexCache = new Lazy<Regex>(MakeRegex);
this.Enumerator = MakeEnumerator();
}
protected Glob(string text)
{
_TryParse(text, out segments);
Glob g = Glob.Parse(text);
this.text = text;
this.regexCache = new Lazy<Regex>(MakeRegex);
this.Enumerator = MakeEnumerator();
}
public void TestMethod1()
{
var currentDirectory = Path.Combine(Directory.GetCurrentDirectory(), "assets");
var fileSystemEnumerator = new FileSystemEnumerator(currentDirectory);
var mySink = new FileSystemEventSink();
fileSystemEnumerator.RegisterEventSink(mySink);
fileSystemEnumerator.Start();
}
/// <summary>
/// ProcessSolicit
/// </summary>
public void ProcessSolicit(string requestId)
{
IDocumentManager documentManager;
IRequestManager requestManager;
AppendAuditLogEvent("Enter SolicitFilesFromFolder.ProcessSolicit({0})",
requestId);
GetServiceImplementation(out requestManager);
GetServiceImplementation(out documentManager);
string sourceFolderPath;
if (!ConfigurationArguments.TryGetValue(SOURCE_FOLDER_PATH, out sourceFolderPath))
{
throw new ArgumentException("SOURCE_FOLDER_PATH configuration key not set");
}
if (!Directory.Exists(sourceFolderPath))
{
throw new DirectoryNotFoundException(string.Format("SOURCE_FOLDER_PATH does not exist: {0}",
sourceFolderPath));
}
DataRequest dataRequest = requestManager.GetDataRequest(requestId);
int docCount = 1;
DateTime docsNewerThan = DateTime.MinValue;
string stateId = null;
if (dataRequest.Parameters.IsByName)
{
TryGetParameterByName(dataRequest, PARAM_STATE_ID, ref stateId);
TryGetParameterByName(dataRequest, PARAM_DOCUMENT_COUNT, ref docCount);
TryGetParameterByName(dataRequest, PARAM_DOCUMENTS_NEWER_THAN, ref docsNewerThan);
}
else
{
TryGetParameterByIndex(dataRequest, 0, ref stateId);
TryGetParameterByIndex(dataRequest, 1, ref docCount);
TryGetParameterByIndex(dataRequest, 2, ref docsNewerThan);
}
if (!string.IsNullOrEmpty(stateId))
{
sourceFolderPath = Path.Combine(sourceFolderPath, stateId);
if (!Directory.Exists(sourceFolderPath))
{
throw new DirectoryNotFoundException(string.Format("State folder path does not exist: {0}",
stateId));
}
}
if (docCount < 0)
{
throw new ArgumentException("Invalid document count specified: {0}", docCount.ToString());
}
if (docsNewerThan > DateTime.Now.AddHours(2))
{
throw new ArgumentException("Invalid documents-newer-than date specified: {0}", docsNewerThan.ToString());
}
AppendAuditLogEvent("PARAM_DOCUMENT_COUNT ({0}), PARAM_DOCUMENTS_NEWER_THAN ({1})",
docCount.ToString(), docsNewerThan.ToString());
List <KeyValuePair <string, DateTime> > docPaths = new List <KeyValuePair <string, DateTime> >();
using (FileSystemEnumerator enumerator = new FileSystemEnumerator(sourceFolderPath, "*", false,
FileSystemEnumerator.EReturnTypes.eReturnFiles))
{
foreach (string path in enumerator)
{
// Check date
DateTime fileTime = File.GetLastWriteTime(path);
if (fileTime > docsNewerThan)
{
docPaths.Add(new KeyValuePair <string, DateTime>(path, fileTime));
}
}
if (docPaths.Count > 0)
{
docPaths.Sort(delegate(KeyValuePair <string, DateTime> x, KeyValuePair <string, DateTime> y)
{
return(y.Value.CompareTo(x.Value));
});
if (docPaths.Count > docCount)
{
if (docCount > 0)
{
// Only return the # requested
docPaths.RemoveRange(docCount, docPaths.Count - docCount);
}
}
}
}
if (docPaths.Count > 0)
{
AppendAuditLogEvent("Found {0} document(s) to add to solicit request",
docPaths.Count.ToString());
documentManager.AddDocument(dataRequest.TransactionId, CommonTransactionStatusCode.Processed,
string.Empty, GetSolictZipFile(docPaths));
}
else
{
AppendAuditLogEvent("Didn't find any documents to add to solicit request");
}
AppendAuditLogEvent("Exit SolicitFilesFromFolder.ProcessSolicit({0})",
requestId);
}
public FileSystemTreeViewItemViewModel(DirectoryInfo folder)
: this(null, folder, _ => FileSystemEnumerator.EnumerateChildren(folder))
{
}
public override IEnumerable<Item> Enumerate(
IEnumerable<Item> items, FileSystemEnumerator enumerator)
{
return items.Where(t => t.Item1.Length == 1 && (t.Item1[0] == Path.DirectorySeparatorChar
|| t.Item1[0] == Path.AltDirectorySeparatorChar));
}
public override IEnumerable<Item> Enumerate(IEnumerable<Item> items,
FileSystemEnumerator enumerator)
{
return new [] { new Item(text, FileSystemEntity.File) };
}
public override IEnumerable<Item> Enumerate(IEnumerable<Item> items, FileSystemEnumerator enumerator)
{
Queue<Item> results = new Queue<Item>(items.OnlyDirectories());
while (results.Count > 0) {
Item item = results.Dequeue();
yield return item;
IEnumerable<Item> descendents = enumerator(FileSystemEntity.Directory, item.Item1);
foreach (Item d in descendents)
results.Enqueue(d);
}
}
public override IEnumerable<Item> Enumerate(IEnumerable<Item> items, FileSystemEnumerator enumerator)
{
var result = items.SelectMany(t => enumerator.Invoke(FileSystemEntity.FileOrDirectory, t.Item1)).Where(t => this.regex.IsMatch(t.Item1));
return result;
}
public override IEnumerable<Item> Enumerate(IEnumerable<Item> items,
FileSystemEnumerator enumerator)
{
foreach (Segment s in this.segments) {
items = s.Enumerate(items, enumerator);
}
return items;
}
public override IEnumerable<Item> Enumerate(
IEnumerable<Item> items, FileSystemEnumerator enumerator)
{
string deviceName = (device + ":" + Path.DirectorySeparatorChar);
return items.Concat(new [] { new Item(deviceName, FileSystemEntity.Directory) });
// return items.Where(t => string.Equals(t.Item1, device + ":", StringComparison.OrdinalIgnoreCase));
}
public override IEnumerable<Item> Enumerate(
IEnumerable<Item> items, FileSystemEnumerator enumerator)
{
return items.SelectMany(t => enumerator.Invoke(FileSystemEntity.Directory, t.Item1));
}
public abstract IEnumerable<Item> Enumerate(IEnumerable<Item> items,
FileSystemEnumerator enumerator);
internal static IEnumerable<string> FilterDirectories(Glob glob,
IEnumerable<string> directories,
FileSystemEntity resultType,
FileSystemEnumerator enumerator)
{
IEnumerable<Item> items = Enumerable.Empty<Item>();
IEnumerable<Item> subItemsStart = directories.Select(
t => new Item(ExpandEnvironmentVariables(t), FileSystemEntity.Directory)).ToArray();
foreach (SegmentSequence sub in glob.segments) {
IEnumerable<Item> subItems = subItemsStart;
subItems = sub.Enumerate(subItems, enumerator);
items = items.Concat(subItems);
}
// TODO Should inform the last segment of the result type rather than filter here
return items
.Where(t => t.Item2 == resultType)
.Select(t => t.Item1)
.Distinct();
}
