/// <summary>
/// Add a candidate for resolving.
/// If the candidates are currently being resolved, they will
/// also be resolved in the the 'next batch' of _nextProcessing
/// </summary>
/// <param name="path">Path to process</param>
/// <param name="depth">Current depth</param>
/// <param name="parent">Parent candidate if any </param>
public SubmissionCandidate Add(string path, int depth = 0, SubmissionCandidate parent = null)
{
if (depth > 20)
{
// @TODO
// Make this more user friendly.
// YUp. ...
throw new Exception("Hit maximum folder depth");
}
SubmissionCandidate candidate = new SubmissionCandidate(path, depth, parent);
if (_isProcessing)
{
lock (_nextProcessingObject)
{
_nextProcessing.Add(candidate);
}
}
else
{
_processing.Add(candidate);
}
return(candidate);
}
/// <summary>
/// Submission constructor
/// </summary>
/// <param name="session">Current session</param>
/// <param name="candidate">Candidate to work with</param>
internal Submission(HunterSession session, SubmissionCandidate candidate)
{
// Assign references
_session = session;
_candidate = candidate;
// Assign Defaults
FirstName = string.Empty;
LastName = string.Empty;
StudentID = string.Empty;
ContentLength = 0;
ContentHash = string.Empty;
Content = string.Empty;
MetaLastModifiedBy = string.Empty;
MetaCreator = string.Empty;
MetaUsername = string.Empty;
MetaDateLastPrinted = DateTime.MinValue;
MetaDateModified = DateTime.MinValue;
MetaDateCreated = DateTime.MinValue;
// Create our relative path based on the working directory (just remove it and add a directory character)
_relativePath = AbsolutePath.Replace(session.WorkingDirectory, string.Empty);
DetectName();
// Figure out the processor
_processor = candidate.FileType.CreateProcessor(this);
// Do a quick check of the meta data filling out some of our details
if (Processor != null)
{
Processor.Process();
}
// Check Processor
if (!Processor.IsProcessed())
{
_session.Log.Add("- " + Markdown.Emphasis("Unable to process this submission. Please confirm that it is a supported file type."));
}
// Create Checks
_checks = CheckFactory.CreateChecks(this, Processor.GetCheckTypes());
// Create simple ID
_guidHash = Core.Compare.Hash(_candidate.Guid.ToString()).Substring(0, 6);
}
/// <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);
}
}
}
/// <summary>
/// Run all the filters through a Candidate and return if it was
/// filtered or not.
/// </summary>
/// <param name="candidate">The candidate to filter against</param>
/// <returns></returns>
public bool ApplyFilter(SubmissionCandidate candidate)
{
if (_filters == null || _filters.Count == 0)
{
return(false);
}
foreach (var filter in _filters)
{
if (filter.Filter(candidate))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Constructor for Submission Candidate
/// </summary>
/// <param name="path">Path to the candidate</param>
/// <param name="depth">Current filesystem depth</param>
/// <param name="parent">Any parent submission</param>
public SubmissionCandidate(string path, int depth, SubmissionCandidate parent)
{
_guid = Guid.NewGuid();
_guidShorthand = _guid.ToString("N").Substring(0, 6);
_resolution = SubmissionCandidateResolution.None;
_depth = depth;
_path = path;
_parent = parent;
_fileType = FileTypes.Types.None;
_resolvePath = string.Empty;
// Initial set of naming information, before processing or exploding, useful
// for any sort of filtering that gets done prior to exploding
_fileName = Path.GetFileName(path);
_fileNameWithoutExtension = Path.GetFileNameWithoutExtension(_fileName);
_fileExtension = Path.GetExtension(_fileName);
}