protected override void FetchExportData()
{
_args = (ToleranceExportArgs)Arguments;
if (_args.ExportNif)
{
_data = new CombinedInterchangeData(true);
}
var exportTaxonomyIds = _args.TaxonomyIds;
var exportTaxonomies = CurrentDb.TaxonomyInfos.Where(p => exportTaxonomyIds.Contains(p.ID)).ToList();
var allExportTaxonomies = exportTaxonomies.SelectMany(p => p.AllLeafChildren).Distinct().ToList();
foreach (var taxonomy in allExportTaxonomies)
{
ProcessTaxonomy(taxonomy);
}
ExportDataTables.Add(_toleranceTable);
}
private List <ImportWorkerBase> GetEligibleWorkerAndData(ImportArgs importArgs,
string importFilePath)
{
CurrentLogWriter.DebugFormat("{0}: Starting Get Eligible Worker And Data", Arguments.Id);
var eligibleImports = new List <ImportWorkerBase>();
var availableImports = ImportWorkerBase.GetAvailableImports();
var fileName = Path.GetFileName(importArgs.InputFilePath);
if (fileName == null)
{
return(new List <ImportWorkerBase>());
}
foreach (var importWorker in availableImports)
{
var currentImportWorker = importWorker;
currentImportWorker.CurrentFieldMappings = new Dictionary <string, int>();
var requiredTCurrentImportWorkerFields = currentImportWorker.GetRequiredFields();
if (fileName.EndsWith(".xml"))
{
if (ImportRecords == null)
{
CurrentLogWriter.DebugFormat("{0}: Reading XML Data", Arguments.Id);
var str = new StreamReader(importArgs.InputFilePath);
var xSerializer = new XmlSerializer(typeof(CombinedInterchangeData));
ImportRecords = (CombinedInterchangeData)xSerializer.Deserialize(str);
}
}
else
{
if (ImportRecords == null)
{
ImportRecords = new CombinedInterchangeData(true);
}
//eligible only if all the required field maps are available.
if (!requiredTCurrentImportWorkerFields.All(p => importArgs.FieldMappings.Keys.Contains(p)))
{
Summary.StatusMessage = string.Format("Not Eligible for Import : {0}",
currentImportWorker.GetType());
continue;
}
foreach (var requiredCurrentImportWorkerField in requiredTCurrentImportWorkerFields)
{
currentImportWorker.CurrentFieldMappings.Add(requiredCurrentImportWorkerField,
importArgs.FieldMappings[requiredCurrentImportWorkerField]);
}
//map all the optional fields
var optionalImportWorkerFields = currentImportWorker.GetOptionalFields();
foreach (
var optionalImportWorkerField in
optionalImportWorkerFields.Where(importArgs.FieldMappings.ContainsKey))
{
currentImportWorker.CurrentFieldMappings.Add(optionalImportWorkerField,
importArgs.FieldMappings[optionalImportWorkerField]);
}
var conf = GetCurrentConfiguration(importArgs, currentImportWorker.CurrentInterchangeRecordType);
//MOve this to base to somewhere common
using (var csvReader = new CsvReader(File.OpenText(importArgs.InputFilePath), conf))
{
CurrentLogWriter.DebugFormat("{0}: Reading Text Data for {1}", Arguments.Id, currentImportWorker.GetType().Name);
var inportData =
csvReader.GetRecordsWithNulls(currentImportWorker.CurrentInterchangeRecordType).ToList();
var method = ImportRecords.GetType().GetMethod("AddRecords");
var generic = method.MakeGenericMethod(currentImportWorker.CurrentInterchangeRecordType);
generic.Invoke(ImportRecords, new object[] { inportData });
}
}
eligibleImports.Add(currentImportWorker);
currentImportWorker.CurrentImportOptions = importArgs.CurrentImportOptions;
currentImportWorker.CurrentProjectId = importArgs.ProjectId;
currentImportWorker.ImportRequestedBy = importArgs.UserId;
currentImportWorker.InputFilePath = importFilePath;
currentImportWorker.FieldDelimiter = importArgs.FieldDelimiter;
currentImportWorker.CurrentFieldMappings = new Dictionary <string, int>();
currentImportWorker.JobDescription = importArgs.JobDescription;
currentImportWorker.ImportData = ImportRecords;
}
ImportRecords.DedupLists();
CurrentLogWriter.DebugFormat("{0}: Eligible Workers:", Arguments.Id);
foreach (var import in eligibleImports)
{
CurrentLogWriter.Debug(import.GetType().Name);
}
return(eligibleImports);
}
