/// <summary>
/// Search one folder, add to results
/// </summary>
/// <param name="crit"></param>
/// <param name="folder"></param>
/// <param name="extFilter"></param>
/// <param name="results"></param>
protected virtual void SearchFolder(ICollection<Criterion> crit, Folder folder, Expression<Func<FileInfo, bool>> extFilter, InstanceRefList results)
{
DirectoryInfo dir = new DirectoryInfo(folder.Path);
var query = (from file in dir.EnumerateFiles() select file).AsQueryable();
if (extFilter != null)
{
query = query.Where(extFilter);
}
query = ApplyFileInfoCriteria(crit, query, folder);
foreach (FileInfo f in query.ToList()) // TODO speed up; taking 14% of search time
{
if (results.List.Count >= MaxSearchResults)
break;
if (Valid(f, crit)) // apply other criteria that need to be done on the file content
{
FileFolderInstance i = CreateInstance();
// populate properties
// Method to be overridden in subclass. Default = filename without extension.
i.ID = MapFileToId(f, folder);
i.EntityName = EntityName;
i.FileName = f.Name;
i.Status = MapFileToStatus(f, folder);
i.UniqueId = MapFileToUniqueId(f, folder);
i.UpdateDate = f.LastWriteTime;
i.ArrivalDate = f.CreationTime;
i.Location = folder.Name + "/" + f.Name;
i.Path = folder.Path + "/" + f.Name;
i.FileSize = f.Length;
i.User = User;
i.Password = Password;
PopulateCustomProperties(i);
InstanceRef iref = Memory.AddRef(i, this);
results.AddInstanceRef(iref);
}
}
}
private void AddSubFolders(Folder folder, List<Folder> list, string parentName)
{
DirectoryInfo parent = new DirectoryInfo(folder.Path);
foreach (var subdir in parent.EnumerateDirectories())
{
string prefix = (parentName != null) ? parentName + "/" : "";
string name = prefix + subdir.Name;
var child = new Folder(name, folder.Status, subdir.FullName);
list.Add(child);
AddSubFolders(child, list, name); // recursion to nested folders
}
}
// Use folder status as the default status.
protected virtual string MapFileToStatus(FileInfo f, Folder folder)
{
return folder.Status;
}
// Use folder + filename as the default Unique ID.
protected virtual string MapFileToUniqueId(FileInfo f, Folder folder)
{
return folder.Name + "/" + f.Name;
}
/// <summary>
/// Should we search subfolders?
/// </summary>
/// <param name="folder">parent folder in question</param>
/// <returns></returns>
protected virtual bool IncludeSubFolders(Folder folder)
{
return IncludeSubfolders;
}
// Use basename of file as the default ID.
protected virtual string MapFileToId(FileInfo f, Folder folder)
{
return Util.Basename(f);
}
// Should we search this folder, given the criteria?
// Default: assumes folder status is based on folder name, including mapping in config file
// Only support equal and not equal operations for folder/status values.
// Also considers folder status if we're doing a "STUCK" search.
protected virtual bool IncludeFolder(Folder folder, ICollection<Criterion> crit)
{
// First check STUCK criteria (skip Final folders)
if (Criterion.HasStuckCriterion(crit) && !CheckForStuck(folder))
return false;
// Now check STATUS criteria (maps to folders)
var statusCrit = (from c in crit where c.FieldName == Field.InstanceStatus select c).ToList();
var notEqualThisFolder =
(from c in statusCrit
where (c.Operation == Criterion.NotEqual && c.Value.Equals(folder.Status, StringComparison.InvariantCultureIgnoreCase))
select c).Any();
if (notEqualThisFolder)
return false;
bool hasEqual = (from c in statusCrit where c.Operation == Criterion.Equal select c).Any();
bool equalThisFolder =
(from c in statusCrit
where (c.Operation == Criterion.Equal && c.Value.Equals(folder.Status, StringComparison.InvariantCultureIgnoreCase))
select c).Any();
if (hasEqual && !equalThisFolder)
return false;
return true;
}
/// <summary>
/// Get the relevant subfolders in the specified parent folder.
/// Includes recursively nested folders.
/// </summary>
/// <param name="folder"></param>
/// <returns></returns>
protected virtual List<Folder> GetSubFolders(Folder folder)
{
var list = new List<Folder>();
AddSubFolders(folder, list, null);
return list;
}
/// <summary>
/// Is this a folder where we should check for Stuck entities?
/// </summary>
protected virtual bool CheckForStuck(Folder folder)
{
return folder.Status != Constants.StatusComplete && folder.Status != Constants.StatusArchive;
}
protected virtual IQueryable<FileInfo> ApplyFileInfoCriteria(ICollection<Criterion> crit, IQueryable<FileInfo> query, Folder folder)
{
foreach (Criterion c in crit)
{
if (c.FieldName == Field.EntityId)
{
query = ApplyRequestIdCriteria(query, c);
}
else if (c.FieldName == Field.InstanceUpdateDate)
{
query = ApplyUpdateDateCriteria(query, c);
}
else if (c.FieldName == Field.InstanceArrivalDate)
{
query = ApplyArrivalDateCriteria(query, c);
}
else if (c.Operation == Criterion.Stuck)
{
query = ApplyStuckCriteria(query, c);
}
}
return query;
}
/// <summary>
/// initialization using data in ConfigData object.
/// This should be called immediately after the constructor.
/// Each Station subclass should call base.initialize(configData, memory) from its own initialize() method.
/// </summary>
public override void Initialize(ConfigData configData, InstanceMemory memory, Resolver commandResolver)
{
base.Initialize(configData, memory, commandResolver);
// do any other Station specific initialization here
HomePath = configData.RequiredValue("homePath");
if (!(HomePath.EndsWith(@"\") || HomePath.EndsWith(@"/")))
HomePath += "/";
User = configData.Value("user");
Password = configData.Value("password");
IncludeSubfolders = configData.BoolValue("includeSubfolders", false);
string possibleError;
var unc = ConnectUnc(out possibleError);
try
{
EntityName = configData.RequiredValue("entityName");
List<ConfigData> folderConfigs = configData.GetConfigSections("folder");
if (folderConfigs.Count == 0)
throw new Exception("No folders configured for station " + this.GetType());
foreach (ConfigData folderConfig in folderConfigs)
{
string name = folderConfig.RequiredValue("name");
string status = folderConfig.Value("status");
if (status == null) status = name;
string path = HomePath + name;
if (Directory.Exists(path))
{
Folder f = new Folder(name, status, path);
Folders.Add(f);
}
else
{
Console.Error.WriteLine("WARNING: Directory not found: {0}", path);
}
}
if (Folders.Count == 0)
{
string error = "No folders accessible for station " + this.GetType();
if (possibleError != null)
error += "; " + possibleError;
throw new Exception(error);
}
List<ConfigData> extConfigs = configData.GetConfigSections("extension");
foreach (ConfigData extConfig in extConfigs)
{
string ext = extConfig.Value();
if (string.IsNullOrEmpty(ext))
{
throw new Exception("Property is empty: extension");
}
Extensions.Add(ext);
}
}
finally
{
if (unc != null) unc.Dispose();
}
}
