private bool OnIsValidCacheItem(Compare.CompareValue compareValue)
{
if (compareValue.FileSize != 0 &&
!string.IsNullOrWhiteSpace(compareValue.Hash) &&
!string.IsNullOrWhiteSpace(compareValue.FileName) &&
compareValue.FileCreated != DateTime.MinValue &&
!string.IsNullOrWhiteSpace(compareValue.Extension) &&
!string.IsNullOrWhiteSpace(compareValue.Directory))
{
return(true);
}
return(false);
}
public bool StartJob(Job job, JobConfiguration config)
{
var ts = new CancellationTokenSource();
CancellationToken ct = ts.Token;
var task = Task.Run(async() =>
{
var duplicateConfig = await _repository.JobConfigurationDuplicates(job.Id);
if (duplicateConfig != null)
{
duplicates.SetSimilarMinValue((Compare.CompareValue.Types)duplicateConfig.CompareValueTypes);
}
_mainManager.SetStatusBarInfoText("Job running");
await _jobServiceRepository.ClearPathDuplicate(job.Id);
int lastCompareFiles = 0;
var paths = await _repository.GetJobCollectPath(job.Id);
Dictionary <string, bool> pathsToCollect = new Dictionary <string, bool>();
List <string> onlyPathsToCollect = new List <string>();
List <Models.PathCompareValue> pathCompares = new List <Models.PathCompareValue>();
foreach (var item in paths)
{
pathsToCollect.Add(item.Path, item.IncludeSubFolders);
onlyPathsToCollect.Add(item.Path);
List <Models.PathCompareValue> items;
if (item.IncludeSubFolders)
{
items = await _jobServiceRepository.GetsByDirectoryWithSubFolders(item.Path);
}
else
{
items = await _jobServiceRepository.Gets(onlyPathsToCollect.ToArray());
}
if (items != null && items.Count > 0)
{
pathCompares.AddRange(items);
}
}
var cache = new Dictionary <string, Compare.CompareValue>();
List <Models.PathCompareValue> invalidPathCompareItems = new List <Models.PathCompareValue>();
foreach (var item in pathCompares)
{
var cacheCompare = new Compare.CompareValue
{
Directory = item.Directory,
Extension = item.Extension,
FileName = item.FileName,
Hash = item.Hash,
FileCreated = item.FileCreated,
FileModified = item.FileModified,
FileSize = item.FileSize
};
if (OnIsValidCacheItem(cacheCompare))
{
cache.Add(item.FullFile, cacheCompare);
}
else
{
invalidPathCompareItems.Add(item);
}
}
if (invalidPathCompareItems.Count > 0)
{
foreach (var item in invalidPathCompareItems)
{
await _jobServiceRepository.Delete(item);
}
}
duplicates.SetCache(cache);
duplicates.Aborted += (object sender, EventArgs e) =>
{
_mainManager.SetStatusBarInfoText(null);
};
decimal currentMaxPercent = 0;
duplicates.PrepareCompareValuesProgressWithItems += (object sender, Compare.Duplicates.PrepareComareProgressItem e) =>
{
if (e.Progress > currentMaxPercent)
{
currentMaxPercent = e.Progress;
}
_mainManager.SetStatusBarInfoText($"Job prepare files ({currentMaxPercent}%)");
if (!isInSaveCompareFiles)
{
if (e.CompareFiles.Count > (lastCompareFiles + 20))
{
OnSaveCompareFiles(e.CompareFiles).GetAwaiter().GetResult();
}
}
if (e.Progress == 100)
{
try
{
_mainManager.SetStatusBarInfoText($"Job prepare files (100%)");
if (!isInSaveCompareFiles)
{
OnSaveCompareFiles(e.CompareFiles, true).GetAwaiter().GetResult();
}
else
{
Task.Run(async() =>
{
do
{
if (isInSaveCompareFiles)
{
await Task.Delay(100);
}
if (!isInSaveCompareFiles)
{
await OnSaveCompareFiles(e.CompareFiles, true);
}
} while (!isInSaveCompareFiles);
});
}
} catch (Exception ex)
{
_logger.Error(ex);
}
}
lastCompareFiles = e.CompareFiles.Count;
};
foreach (var item in pathsToCollect)
{
await duplicates.Collect(item.Value, item.Key);
}
await OnAfterCollect(job, config);
}, ct);
jobTasks.Add(job, ts);
return(true);
}
