private async void OnChanged(object source, FileSystemEventArgs e)
{
if (e.ChangeType == WatcherChangeTypes.Created && e.Name.StartsWith("WOH"))
{
using (FileImportService service = new FileImportService())
{
var succeeded = await service.CreateAsync(new FileImport
{
FileName = e.Name
}, _source.Token);
}
}
else if (e.ChangeType == WatcherChangeTypes.Deleted && e.Name.StartsWith("WOH"))
{
using (FileImportService service = new FileImportService())
{
var found = await service.GetByFileNameAsync(e.Name);
if (found != null)
{
found.DateDeleted = DateTime.Now;
var succeeded = await service.UpdateAsync(found, _source.Token);
}
}
}
}
private void prepareViewModel(EditPurchaseImportDataMappingsViewModel model)
{
PrepareViewModel(model, EvolutionResources.bnrPurchaseImport, 0, 0);
model.LocationList = LookupService.FindLocationListItemModel(CurrentCompany);
model.HeadingList = FileImportService.GetHeadingList("Purchase.dat");
}
public When_Import_Is_Called_To_Import_LearningAimReferenceStaging()
{
var config = new MapperConfiguration(c => c.AddMaps(typeof(LearningAimReferenceStagingMapper).Assembly));
var mapper = new Mapper(config);
var logger = Substitute.For <ILogger <FileImportService <LearningAimReferenceStagingFileImportDto, LearningAimReferenceStagingDto, LearningAimReferenceStaging> > >();
_fileReader = Substitute.For <IFileReader <LearningAimReferenceStagingFileImportDto, LearningAimReferenceStagingDto> >();
_dataProcessor = Substitute.For <IDataProcessor <LearningAimReferenceStaging> >();
_repository = Substitute.For <IBulkInsertRepository <LearningAimReferenceStaging> >();
_repository.MergeFromStagingAsync().Returns(2);
_stagingFileImportDto = new LearningAimReferenceStagingFileImportDto
{
FileDataStream = new MemoryStream()
};
_fileReaderResults = Build(2);
_fileReader.ValidateAndParseFileAsync(_stagingFileImportDto)
.Returns(Task.FromResult(_fileReaderResults));
var service = new FileImportService <LearningAimReferenceStagingFileImportDto, LearningAimReferenceStagingDto, LearningAimReferenceStaging>(logger, mapper, _fileReader, _repository, _dataProcessor);
_result = service.BulkImportAsync(_stagingFileImportDto).GetAwaiter().GetResult();
}
private void prepareViewModel(EditSaleImportDataMappingsViewModel model)
{
PrepareViewModel(model, EvolutionResources.bnrSaleImport, 0, 0);
model.HeadingList = FileImportService.GetHeadingList("Sale.dat");
model.SOStatusList = LookupService.FindSalesOrderHeaderStatusListItemModel();
model.SourceList = LookupService.FindLOVItemsListItemModel(CurrentCompany, LOVName.OrderSource);
}
public ActionResult Upload(FileUploadViewModel model, string command)
{
Server.ScriptTimeout = 600; // Allow 10 minutes for an upload/import
if (command.ToLower() == "upload")
{
if (model.Files != null && model.Files.Count() > 0)
{
var targetFile = Path.GetTempPath();
var attachment = model.Files.FirstOrDefault();
string fileName = attachment.FileName;
if (!MediaServices.IsValidOrderImportType(fileName))
{
model.SetError(ErrorIcon.Error, EvolutionResources.errInvalidImportFile.Replace("%1", MediaServices.GetValidOrderImportTypes()));
}
else if (attachment != null && attachment.ContentLength > 0)
{
try {
targetFile += fileName.FileName();
attachment.SaveAs(targetFile);
var error = FileImportService.UploadFile(CurrentCompany, CurrentUser, targetFile,
model.FirstLineContainsHeader);
if (error.IsError)
{
model.SetError(ErrorIcon.Error, error.Message);
}
else
{
// Display the table
var mappingsModel = new EditSaleImportDataMappingsViewModel();
prepareViewModel(mappingsModel);
mappingsModel.Data = FileImportService.GetData(CurrentCompany, CurrentUser);
SalesService.ValidateOrders(CurrentCompany, CurrentUser, mappingsModel.Data.Headings, mappingsModel.DisplayDateFormat);
mappingsModel.Data = FileImportService.GetData(CurrentCompany, CurrentUser);
return(View("ImportMappings", mappingsModel));
}
} catch (Exception e1) {
model.SetError(ErrorIcon.Error, EvolutionResources.errFailedToUploadFile.Replace("%1", fileName).Replace("%2", e1.Message));
LogService.WriteLog(e1, Request.RawUrl);
}
}
prepareViewModel(model);
return(View("SaleImport", model));
}
}
return(RedirectToAction("Index"));
}
private async void CheckImportStatusAsync(object state)
{
var config = GetConfig();
if (config == null)
{
return;
}
using (FileImportService service = new FileImportService())
{
var list = await service.GetReadyToCheckImports(config.WaitInSeconds);
foreach (var file in list)
{
file.DateChecked = DateTime.Now;
string sumfile = Path.Combine(config.SummaryFolder, Path.GetFileNameWithoutExtension(file.FileName) + ".sum");
if (File.Exists(sumfile) && IsImportSucceeded(sumfile))
{
file.Result = "Imported";
}
else
{
file.Result = "Failed";
string body = GetAllErrors(file.FileName, config.ErrorFolder, config.SummaryFolder);
if (config.DefaultMail == "DbMail")
{
await service.SendDbMail(config.DbMail, config.EmailTos, "",
string.Format("Import Error - {0}", file.FileName), body);
}
else
{
await service.SendSmtpEmailAsync(config.SmtpMail, config.EmailTos,
string.Format("Import Error - {0}", file.FileName), body);
}
}
await service.UpdateAsync(file, _source.Token);
}
}
}
public ActionResult Import(EditSaleImportDataMappingsViewModel model, string command)
{
if (command.ToLower() == "import")
{
var error = SalesService.ValidateOrders(CurrentCompany, CurrentUser, model.Data.Headings, CurrentUser.DateFormat);
if (error.IsError)
{
prepareViewModel(model);
model.Data = FileImportService.GetData(CurrentCompany, CurrentUser);
model.SetError(ErrorIcon.Error, error.Message);
return(View("ImportMappings", model));
}
else
{
error = SalesService.ImportSales(CurrentCompany,
CurrentUser,
model.SOStatus,
model.SourceId,
model.Data.Headings,
CurrentUser.DateFormat,
model.TZ.ParseInt());
if (error.IsError)
{
prepareViewModel(model);
model.Data = FileImportService.GetData(CurrentCompany, CurrentUser);
model.SetError(ErrorIcon.Error, error.Message);
return(View("ImportMappings", model));
}
else
{
// Successfully imported, so redirect to purchase orders screen
return(RedirectToAction("Sales", "Sales", new { Area = "Sales" }));
}
}
}
else
{
return(RedirectToAction("Index"));
}
}
void prepareViewModel(FileUploadViewModel model)
{
PrepareViewModel(model,
EvolutionResources.bnrSaleImport,
0,
MenuOptionFlag.RequiresNoSale);
model.MaxUploadFileSize = GetMaxFileUploadSize();
model.ValidFileTypes = MediaServices.GetValidOrderImportTypes();
model.ColumnHeadings = "";
var headingList = FileImportService.GetHeadingList("Sale.dat", false, false);
for (int i = 0; i < headingList.Count(); i++)
{
if (i > 0)
{
model.ColumnHeadings += ", ";
}
model.ColumnHeadings += headingList[i].Id;
}
}
public CsvFileImportServiceDuplicateRowsTestFixture()
{
DataValidator = Substitute.For <IValidator <TImportDto> >();
DataValidator
.ValidateAsync(Arg.Any <TImportDto>())
.Returns(Task.FromResult(new ValidationResult()));
DataParser = Substitute.For <IDataParser <TDto> >();
DataParser.Parse(Arg.Any <TImportDto>()).Returns(info => TestHelper.GetDataParser <TDto>().Parse(info.Arg <TImportDto>()));
FunctionLogRepository = Substitute.For <IRepository <FunctionLog> >();
var csvfileReader = new CsvFileReader <TImportDto, TDto>
(
new NullLogger <CsvFileReader <TImportDto, TDto> >(),
DataParser,
DataValidator,
FunctionLogRepository
);
Repository = Substitute.For <IBulkInsertRepository <TEntity> >();
FileImportService = new FileImportService <TImportDto, TDto, TEntity>
(
new NullLogger <FileImportService <TImportDto, TDto, TEntity> >(),
TestHelper.GetMapper(),
csvfileReader,
Repository,
Substitute.For <IDataProcessor <TEntity> >()
);
var filePath = Path.Combine(TestHelper.GetTestExecutionDirectory(), $"Services\\FileImportService\\DuplicateRows\\{typeof(TEntity).Name}-DuplicateRows.csv");
using var stream = File.Open(filePath, FileMode.Open);
FileImportService.BulkImportAsync(new TImportDto
{
FileDataStream = stream
}).GetAwaiter().GetResult();
}
public ActionResult Import(EditDataMappingViewModel model, string command)
{
if (command.ToLower() == "import")
{
var error = ProductService.ValidateProducts(CurrentCompany, CurrentUser, model.Data.Headings);
if (error.IsError)
{
prepareViewModel(model);
model.Data = FileImportService.GetData(CurrentCompany, CurrentUser);
model.SetError(ErrorIcon.Error, error.Message);
return(View("ImportMappings", model));
}
else
{
error = ProductService.ImportProducts(CurrentCompany,
CurrentUser,
model.Data.Headings,
MembershipManagementService.GetProperty("ProdImportZip", ""));
if (error.IsError)
{
prepareViewModel(model);
model.Data = FileImportService.GetData(CurrentCompany, CurrentUser);
model.SetError(ErrorIcon.Error, error.Message);
return(View("ImportMappings", model));
}
else
{
// Successfully imported, so redirect to purchase orders screen
MembershipManagementService.SaveProperty("ProdImportZip", "");
return(RedirectToAction("Products", "Products", new { Area = "Products" }));
}
}
}
else
{
return(RedirectToAction("Index"));
}
}
public ActionResult Import(EditPurchaseImportDataMappingsViewModel model, string command)
{
if (command.ToLower() == "import")
{
var error = PurchasingService.ValidateOrders(CurrentCompany, CurrentUser, model.Data.Headings);
if (error.IsError)
{
prepareViewModel(model);
model.Data = FileImportService.GetData(CurrentCompany, CurrentUser);
model.SetError(ErrorIcon.Error, error.Message);
return(View("ImportMappings", model));
}
else
{
error = PurchasingService.ImportOrders(CurrentCompany,
CurrentUser,
model.LocationId,
model.Data.Headings);
if (error.IsError)
{
prepareViewModel(model);
model.Data = FileImportService.GetData(CurrentCompany, CurrentUser);
model.SetError(ErrorIcon.Error, error.Message);
return(View("ImportMappings", model));
}
else
{
// Successfully imported, so redirect to purchase orders screen
return(RedirectToAction("Purchases", "Purchasing", new { Area = "Purchasing" }));
}
}
}
else
{
return(RedirectToAction("Index"));
}
}
public ActionResult Upload(FileUploadViewModel model, string command)
{
Server.ScriptTimeout = 600; // Allow 10 minutes for an upload/import
if (command.ToLower() == "upload")
{
if (model.Files != null || model.Files.Count() == 1 &&
model.Images != null || model.Images.Count() == 1)
{
var targetFolder = Path.GetTempPath();
string prodFile = "",
zipFile = "";
try {
var attachment = model.Files.FirstOrDefault();
if (attachment != null)
{
string fileName = attachment.FileName;
if (!MediaServices.IsValidOrderImportType(fileName))
{
model.SetError(ErrorIcon.Error, EvolutionResources.errInvalidImportFile.Replace("%1", MediaServices.GetValidOrderImportTypes()));
}
else if (attachment.ContentLength > 0)
{
prodFile = targetFolder + fileName.FileName();
attachment.SaveAs(prodFile);
}
if (!model.Error.IsError)
{
attachment = model.Images.FirstOrDefault();
if (attachment != null)
{
fileName = attachment.FileName;
if (fileName.FileExtension().ToLower() != "zip")
{
model.SetError(ErrorIcon.Error, EvolutionResources.errInvalidImportFile.Replace("%1", "zip"));
}
else if (attachment.ContentLength > 0)
{
zipFile = targetFolder + fileName.FileName();
attachment.SaveAs(zipFile);
MembershipManagementService.SaveProperty("ProdImportZip", zipFile);
}
}
}
}
} catch (Exception e1) {
model.Error.SetError(e1);
}
if (!model.Error.IsError)
{
try {
model.Error = FileImportService.UploadFile(CurrentCompany, CurrentUser, prodFile,
model.FirstLineContainsHeader);
if (!model.Error.IsError)
{
// Display the table
var mappingsModel = new EditDataMappingViewModel();
prepareViewModel(mappingsModel);
mappingsModel.Data = FileImportService.GetData(CurrentCompany, CurrentUser);
ProductService.ValidateProducts(CurrentCompany, CurrentUser, mappingsModel.Data.Headings);
mappingsModel.Data = FileImportService.GetData(CurrentCompany, CurrentUser);
return(View("ImportMappings", mappingsModel));
}
} catch (Exception e1) {
model.SetError(ErrorIcon.Error, EvolutionResources.errFailedToUploadFile.Replace("%1", prodFile).Replace("%2", e1.Message));
LogService.WriteLog(e1, Request.RawUrl);
}
}
MediaService.MediaService.DeleteFile(prodFile);
MediaService.MediaService.DeleteFile(zipFile);
PrepareViewModel(model, EvolutionResources.bnrProductImport, 0, 0);
return(View("ProductImport", model));
}
}
return(RedirectToAction("Index"));
}
private void prepareViewModel(EditDataMappingViewModel model)
{
PrepareViewModel(model, EvolutionResources.bnrProductImport, 0, 0);
model.HeadingList = FileImportService.GetHeadingList("Product.dat");
}
