public IActionResult UploadFiles(UploadFilesModel item)
{
if (item.Path.Length > 0)
{
var path = Path.Combine(_hostEnvironment.WebRootPath, "Images");
var filePath = Path.Combine(path, item.Path.FileName);
using (var stream = System.IO.File.Create(filePath))
{
item.Path.CopyTo(stream);
}
Image image = new Image();
image.Title = item.Title;
image.Description = item.Description;
image.Other = item.Other;
image.Path = filePath;
_appDbContext.Add(image);
_appDbContext.SaveChanges();
}
return(View());
}
public ActionResult Update(UploadFilesModel model)
{
// xボタンで削除されたファイルを実際に削除する
if (model.FileIdToRemove != null)
{
List <string> filesToRemove = model.FileIdToRemove.Split(',')
.Select(fid =>
{
// fileId から物理ファイル名に変換する処理
string actualPath = Path.Combine(folder, fid);
return(actualPath);
}).ToList();
foreach (var file in filesToRemove)
{
try
{
System.IO.File.Delete(file);
}
catch (Exception)
{
throw;
}
}
}
// アップロードされたファイルを保存する
List <HttpPostedFileWrapper> files = model.File.Where(f => f != null).ToList();
foreach (var file in files)
{
file.SaveAs(Path.Combine(folder, file.FileName));
}
return(RedirectToAction("Index"));
}
public ActionResult Index()
{
UploadFilesModel model = new UploadFilesModel();
var storedFile = Directory.GetFiles(folder).Select(f => new { name = Path.GetFileName(f), fileId = Server.UrlEncode(Path.GetFileName(f)) }).ToList();
model.StoredFileJson = JsonConvert.SerializeObject(storedFile);
return(View("UploadFiles", model));
}
public ActionResult UploadFiles(UploadFilesModel uploadFilesModel)
{
ViewBag.Info = string.Empty;
if (Request.Files != null && Request.Files.Count > 0)
{
}
else
{
}
return(Json(""));
}
public IActionResult UploadFiles([FromForm] UploadFilesModel model)
{
string rootPath = Path.Combine(_environment.ContentRootPath, "Uploads");
try {
var destFolder = _db.CajFolder.FirstOrDefault(x => x.Id == model.FolderId);
if (!System.IO.Directory.Exists(rootPath))
{
Directory.CreateDirectory(rootPath);
}
foreach (var file in model.Files)
{
var cajFile = new CajFile()
{
Created = DateTime.Now,
Id = Guid.NewGuid(),
Name = file.FileName,
};
_db.CajFile.Add(cajFile);
_db.CajFileInFolder.Add(new CajFileInFolder()
{
FkFile = cajFile.Id,
FkFolder = destFolder.Id,
Id = Guid.NewGuid()
});
string serverFilePath = Path.Combine(rootPath, cajFile.Id.ToString());
string serverTempFilePath = $"{serverFilePath}.tmp";
//copy temp to file
using (var fileStream = new FileStream(serverTempFilePath, FileMode.Create)) {
var fileMemoryStream = file.OpenReadStream();
fileMemoryStream.CopyTo(fileStream);
}
if (IOManager.Compress(serverTempFilePath, serverFilePath))
{
_db.SaveChanges();
IOManager.RemoveFile(serverTempFilePath);
}
}
} catch (Exception ex) {
_logger.Log(LogLevel.Information, $"Error uploading files: {ex}");
return(StatusCode(500));
}
return(StatusCode(200));
}
//TODO: Email on exception or let user know what happened
public async Task UploadFiles(UploadFilesModel model)
{
var reviewId = model.ReviewId;
var folder = await SpecialFolderProvider.GetReviewFolderAsync(model.ReviewId);
string importer = null;
int rowErrorCount = 0;
Action <Exception, int> onRowAddError = (ex, rowNum) =>
{
LogError(ex, "UploadFiles: OnRowAddError with {rowNum} in {importer} with {reviewId}", rowNum, importer, reviewId);
++rowErrorCount;
};
RowsTransferredEventHandler rowsTransferred = (sender, e) =>
{
LogInformation("UploadFiles: Loading progress. {rowCount} in {importer} with {reviewId}", e.RowsTransferred, importer, reviewId);
};
try
{
var allFiles =
model.PegasysFilePathsList
.Union(model.RetaFileList)
.Union(model.EasiFileList)
.Union(model.One92FileList)
.Union(model.CreditCardAliasCrosswalkFiles)
.Union(model.PegasysOpenItemsCreditCards)
.Union(model.WorkingCapitalFundReportFiles)
.Union(model.ActiveCardholderFiles)
.ToList();
LogInformation("Will ultimately process the following files:\n{filePaths}", allFiles.Format("\n", "\t{0}"));
importer = nameof(Load442sAsync);
foreach (var fn in model.PegasysFilePathsList)
{
using (var st = await folder.OpenFileReadStreamAsync(fn))
{
await Load442sAsync(reviewId, st, onRowAddError, rowsTransferred);
}
}
importer = nameof(LoadReta);
foreach (var fn in model.RetaFileList)
{
using (var st = await folder.OpenFileReadStreamAsync(fn))
{
LoadReta(reviewId, st, onRowAddError, rowsTransferred);
}
}
importer = nameof(LoadEasi);
foreach (var fn in model.EasiFileList)
{
using (var st = await folder.OpenFileReadStreamAsync(fn))
{
LoadEasi(reviewId, st, onRowAddError, rowsTransferred);
}
}
importer = nameof(Load192s);
foreach (var fn in model.One92FileList)
{
using (var st = await folder.OpenFileReadStreamAsync(fn))
{
Load192s(reviewId, st, onRowAddError, rowsTransferred);
}
}
importer = nameof(LoadCreditCardAliases);
foreach (var fn in model.CreditCardAliasCrosswalkFiles)
{
using (var st = await folder.OpenFileReadStreamAsync(fn))
{
LoadCreditCardAliases(reviewId, st, onRowAddError, rowsTransferred);
}
}
importer = nameof(LoadPegasysOpenItemsCreditCards);
foreach (var fn in model.PegasysOpenItemsCreditCards)
{
using (var st = await folder.OpenFileReadStreamAsync(fn))
{
LoadPegasysOpenItemsCreditCards(reviewId, st, onRowAddError, rowsTransferred);
}
}
importer = nameof(LoadCreateWorkingCapitalFundItems);
foreach (var fn in model.WorkingCapitalFundReportFiles)
{
using (var st = await folder.OpenFileReadStreamAsync(fn))
{
LoadCreateWorkingCapitalFundItems(reviewId, st, onRowAddError, rowsTransferred);
}
}
importer = nameof(LoadActiveCardholders);
foreach (var fn in model.ActiveCardholderFiles)
{
using (var st = await folder.OpenFileReadStreamAsync(fn))
{
LoadActiveCardholders(reviewId, st, onRowAddError, rowsTransferred);
}
}
}
catch (Exception ex)
{
LogError(ex, "Problem with UploadFiles in {reviewId}", reviewId);
throw;
}
finally
{
var level = rowErrorCount == 0 ? LogLevel.Information : LogLevel.Warning;
Logger.Log(level, "Importing of {reviewId} yielded {rowErrorCount}. Note, this does not indicate either overall success or failure.", reviewId, rowErrorCount);
}
}
//TODO: Email on exception or let user know what happened
public void UploadFiles(UploadFilesModel files)
{
var reviewId = files.ReviewId;
string importer = null;
int rowErrorCount = 0;
Action <Exception, int> onRowAddError = (ex, rowNum) =>
{
Log.Error(ex, "UploadFiles: OnRowAddError with {rowNum} in {importer} with {reviewId}", rowNum, importer, reviewId);
++rowErrorCount;
};
RowsTransferredEventHandler rowsTransferred = (sender, e) =>
{
Log.Information("UploadFiles: Loading progress. {rowCount} in {importer} with {reviewId}", e.RowsTransferred, importer, reviewId);
};
try
{
importer = nameof(Load442s);
foreach (var fn in files.PegasysFilePathsList)
{
Load442s(reviewId, fn, onRowAddError, rowsTransferred);
}
importer = nameof(LoadReta);
foreach (var fn in files.RetaFileList)
{
LoadReta(reviewId, fn, onRowAddError, rowsTransferred);
}
importer = nameof(LoadEasi);
foreach (var fn in files.EasiFileList)
{
LoadEasi(reviewId, fn, onRowAddError, rowsTransferred);
}
importer = nameof(Load192s);
foreach (var fn in files.One92FileList)
{
Load192s(reviewId, fn, onRowAddError, rowsTransferred);
}
importer = nameof(LoadCreditCardAliases);
foreach (var fn in files.CreditCardAliasCrosswalkFiles)
{
LoadCreditCardAliases(reviewId, fn, onRowAddError, rowsTransferred);
}
importer = nameof(LoadPegasysOpenItemsCreditCards);
foreach (var fn in files.PegasysOpenItemsCreditCards)
{
LoadPegasysOpenItemsCreditCards(reviewId, fn, onRowAddError, rowsTransferred);
}
importer = nameof(LoadActiveCardholders);
foreach (var fn in files.ActiveCardholderFiles)
{
LoadActiveCardholders(reviewId, fn, onRowAddError, rowsTransferred);
}
}
catch (Exception ex)
{
Log.Error(ex, "Problem with UploadFiles in {reviewId}", reviewId);
throw;
}
finally
{
var level = rowErrorCount == 0 ? Serilog.Events.LogEventLevel.Information : Serilog.Events.LogEventLevel.Warning;
Log.Write(level, "Importing of {reviewId} yielded {rowErrorCount}. Note, this does not indicate either overall success or failure.", reviewId, rowErrorCount);
}
}
public async Task <ActionResult> Create(
[Bind(new[] {
nameof(ReviewModel.RegionId),
nameof(ReviewModel.ReviewName),
nameof(ReviewModel.ReviewTypeId),
nameof(ReviewModel.ReviewScopeId),
nameof(ReviewModel.Comments),
nameof(ReviewModel.RegionChoices),
nameof(ReviewModel.ReviewDateInitiated)
})]
ReviewModel reviewModel)
{
bool errors = false;
var reviewTypeId = Enum.Parse <ReviewTypeEnum>(reviewModel.ReviewTypeId);
if (DB.Reviews.Any(r => r.ReviewName == reviewModel.ReviewName))
{
ModelState.AddModelError("ReviewName", "The name of this review is already in use.");
errors = true;
}
var requiredFileDesignators = ReviewFileDesignators.RequiredFileDesignatorsByReviewType.GetValue(reviewTypeId);
if (requiredFileDesignators == null)
{
throw new UnexpectedSwitchValueException(reviewTypeId);
}
var distinctFileTypes = Request.Form.Files.Where(f => f.Length > 0 && requiredFileDesignators.Contains(f.Name)).Select(f => f.Name).ToHashSet();
if (distinctFileTypes.Count != requiredFileDesignators.Count)
{
ModelState.AddModelError("Files", $"You must upload at least one of each type of file: {requiredFileDesignators.Format(", ")}");
errors = true;
}
var reviewScope = Enum.Parse <ReviewScopeEnum>(reviewModel.ReviewScopeId);
string workflowDefinitionName;
if (!PortalHelpers.TryGetGetWorkflowDefinitionName(reviewTypeId, reviewScope, out workflowDefinitionName))
{
ModelState.AddModelError("", $"Can't find workflowDefinitionName for scope={reviewScope}");
errors = true;
}
if (ModelState.IsValid && !errors)
{
var wd = await DB.WorkflowDefinitions.Where(z => z.IsActive && z.WorkflowDefinitionName == workflowDefinitionName).OrderByDescending(z => z.WorkflowDefinitionId).FirstOrDefaultAsync();
if (wd == null)
{
ModelState.AddModelError("", $"Can't find active workflowDefinition for workflowDefinitionName={workflowDefinitionName}");
errors = true;
goto ErrorReturn;
}
//content += "before review object create<br />";
var review = new Review
{
RegionId = reviewModel.RegionId,
ReviewName = reviewModel.ReviewName,
Status = Review.StatusNames.Creating,
ReviewTypeId = reviewTypeId,
Comments = reviewModel.Comments,
ReviewScopeId = reviewScope,
WorkflowDefinitionId = wd.WorkflowDefinitionId,
CreatedAtUtc = DateTime.UtcNow,
ReviewDateInitiated = reviewModel.ReviewDateInitiated
//ProjectDueDate = reviewModel.ProjectDueDate.Value,
};
DB.Reviews.Add(review);
await DB.SaveChangesAsync();
var uploadFiles = new UploadFilesModel(review.ReviewId);
var folder = await SpecialFolderProvider.GetReviewFolderAsync(review.ReviewId);
foreach (var formFile in Request.Form.Files)
{
if (formFile.Length == 0)
{
continue;
}
var name = formFile.FileName;
LogInformation("Storing review {reviewId} of type {typeName} with {size} for {fileName}", review.ReviewId, formFile.Name, formFile.Length, name);
var file = await folder.CreateFileAsync(name);
using (var dst = await file.OpenWriteAsync())
{
// read file to stream
await formFile.CopyToAsync(dst);
}
switch (formFile.Name)
{
case ReviewFileDesignators.PegasysFiles:
uploadFiles.PegasysFilePathsList.Add(name);
break;
case ReviewFileDesignators.RetaFiles:
uploadFiles.RetaFileList.Add(name);
break;
case ReviewFileDesignators.EasiFiles:
uploadFiles.EasiFileList.Add(name);
break;
case ReviewFileDesignators.One92Files:
uploadFiles.One92FileList.Add(name);
break;
case ReviewFileDesignators.ActiveCardholderFiles:
uploadFiles.ActiveCardholderFiles.Add(name);
break;
case ReviewFileDesignators.PegasysOpenItemsCreditCards:
uploadFiles.PegasysOpenItemsCreditCards.Add(name);
break;
case ReviewFileDesignators.WorkingCapitalFundFiles:
uploadFiles.WorkingCapitalFundReportFiles.Add(name);
break;
case ReviewFileDesignators.CreditCardAliasCrosswalkFiles:
uploadFiles.CreditCardAliasCrosswalkFiles.Add(name);
break;
default:
throw new UnexpectedSwitchValueException(formFile.FileName);
}
}
var uploadToSqlJob = BackgroundJobClient.Enqueue <IBackgroundTasks>(bt => bt.UploadFiles(uploadFiles));
var createWorkflowsJobs = BackgroundJob.ContinueJobWith <IBackgroundTasks>(
uploadToSqlJob,
bt => bt.CreateULOsAndAssign(review.ReviewId, review.WorkflowDefinitionId, review.ReviewDateInitiated.Value));
BackgroundJob.ContinueJobWith <IBackgroundTasks>(createWorkflowsJobs, bt => bt.AssignWorkFlows(review.ReviewId, PortalHelpers.SendBatchEmailsDuringAssignWorkflows));
AddPageAlert($"Upload for reviewId={review.ReviewId} was a success. Review will load during background jobs {uploadToSqlJob} and {createWorkflowsJobs}", false, RevolutionaryStuff.AspNetCore.PageAlert.AlertTypes.Success);
return(RedirectToIndex());
}
ErrorReturn:
var m = await CreateReviewModelAsync();
reviewModel.RegionChoices = m.RegionChoices;
reviewModel.ReviewTypes = m.ReviewTypes;
reviewModel.ReviewScopes = m.ReviewScopes;
return(View("Create", reviewModel));
}
public async Task <ActionResult> Create(
[Bind(Include =
nameof(ReviewModel.RegionId) + "," +
nameof(ReviewModel.ReviewName) + "," +
//nameof(ReviewModel.ReviewStatus)+","+
nameof(ReviewModel.ReviewTypeId) + "," +
nameof(ReviewModel.ReviewScopeId) + "," +
nameof(ReviewModel.Comments) + "," +
//nameof(ReviewModel.Review)+","+
nameof(ReviewModel.RegionChoices) + "," +
nameof(ReviewModel.ReviewDateInitiated))]
ReviewModel reviewModel)
{
bool errors = false;
if (DB.Reviews.Any(r => r.ReviewName == reviewModel.ReviewName))
{
ModelState.AddModelError("ReviewName", "The name of this review is already in use.");
errors = true;
}
var distinctFileTypes = new HashSet <string>();
foreach (string file in Request.Files)
{
var fileContent = Request.Files[file];
if (fileContent != null && fileContent.ContentLength > 0)
{
distinctFileTypes.Add(file);
}
}
if (distinctFileTypes.Count != ReviewFileDesignators.ReviewFileTypeCount)
{
ModelState.AddModelError("Files", "You must upload at least one of each type of file.");
errors = true;
}
var reviewScope = (ReviewScopeEnum)reviewModel.ReviewScopeId.GetValueOrDefault(-1);
string workflowDefinitionName;
if (!PortalHelpers.WorkflowDefinitionNameByReviewScope.TryGetValue(reviewScope, out workflowDefinitionName))
{
ModelState.AddModelError("", $"Can't find workflowDefinitionName for scope={reviewScope}");
errors = true;
}
if (ModelState.IsValid && !errors)
{
var wd = await DB.WorkflowDefinitions.Where(z => z.IsActive && z.WorkflowDefinitionName == workflowDefinitionName).OrderByDescending(z => z.WorkflowDefinitionId).FirstOrDefaultAsync();
if (wd == null)
{
ModelState.AddModelError("", $"Can't find active workflowDefinition for workflowDefinitionName={workflowDefinitionName}");
errors = true;
goto ErrorReturn;
}
//content += "before review object create<br />";
var review = new Review
{
RegionId = reviewModel.RegionId,
ReviewName = reviewModel.ReviewName,
Status = Review.StatusNames.Creating,
ReviewTypeId = reviewModel.ReviewTypeId.Value,
Comments = reviewModel.Comments,
ReviewScopeId = reviewModel.ReviewScopeId.Value,
WorkflowDefinitionId = wd.WorkflowDefinitionId,
CreatedAtUtc = DateTime.UtcNow,
ReviewDateInitiated = reviewModel.ReviewDateInitiated
//ProjectDueDate = reviewModel.ProjectDueDate.Value,
};
DB.Reviews.Add(review);
await DB.SaveChangesAsync();
var uploadFiles = new UploadFilesModel(review.ReviewId);
foreach (string file in Request.Files)
{
//content += "staring " + file + "upload <br />";
var fileContent = Request.Files[file];
if (fileContent != null && fileContent.ContentLength > 0)
{
var path = PortalHelpers.GetStorageFolderPath($"ReviewUploads/{review.ReviewId / 1024}/{review.ReviewId}/{Guid.NewGuid()}.dat");
using (var fileStream = System.IO.File.Create(path))
{
await fileContent.InputStream.CopyToAsync(fileStream);
}
switch (file)
{
case ReviewFileDesignators.PegasysFiles:
uploadFiles.PegasysFilePathsList.Add(path);
break;
case ReviewFileDesignators.RetaFiles:
uploadFiles.RetaFileList.Add(path);
break;
case ReviewFileDesignators.EasiFiles:
uploadFiles.EasiFileList.Add(path);
break;
case ReviewFileDesignators.One92Files:
uploadFiles.One92FileList.Add(path);
break;
case ReviewFileDesignators.ActiveCardholderFiles:
uploadFiles.ActiveCardholderFiles.Add(path);
break;
case ReviewFileDesignators.PegasysOpenItemsCreditCards:
uploadFiles.PegasysOpenItemsCreditCards.Add(path);
break;
case ReviewFileDesignators.CreditCardAliasCrosswalkFiles:
uploadFiles.CreditCardAliasCrosswalkFiles.Add(path);
break;
default:
throw new UnexpectedSwitchValueException(file);
}
}
}
var uploadFilesJobId = BackgroundJobClient.Enqueue <IBackgroundTasks>(bt => bt.UploadFiles(uploadFiles));
var jobId2 = BackgroundJob.ContinueWith <IBackgroundTasks>(uploadFilesJobId,
bt => bt.CreateULOsAndAssign(review.ReviewId, review.WorkflowDefinitionId, review.ReviewDateInitiated.Value));
BackgroundJob.ContinueWith <IBackgroundTasks>(jobId2, bt => bt.AssignWorkFlows(review.ReviewId, Properties.Settings.Default.SendBatchEmailsDuringAssignWorkflows));
return(RedirectToIndex());
}
ErrorReturn:
var m = await CreateReviewModelAsync();
reviewModel.RegionChoices = m.RegionChoices;
reviewModel.ReviewTypes = m.ReviewTypes;
reviewModel.ReviewScopes = m.ReviewScopes;
return(View(reviewModel));
}
private UploadFilesModel GetFiles()
{
var uploadDatas = HttpHelper.Get<UploadDatas>(string.Format(serviceBaseUri + "/UploadFiles"));
mapper = new AutoDataContractMapper();
var files = new UploadFilesModel();
mapper.MapList(uploadDatas, files, typeof(UploadModel));
Model = files;
return files;
}
