public ActionResult ApprenticeshipUpload(BulkUploadViewModel model)
{
String[] validFileTypes = { ".csv" };
Boolean validFileType = false;
foreach (String fileType in validFileTypes)
{
if (model.File.FileName.ToLower().EndsWith(fileType))
{
validFileType = true;
break;
}
}
if (!validFileType)
{
ModelState.AddModelError("File", AppGlobal.Language.GetText(this, "CSVFilesOnly", "Please upload a CSV file"));
}
if (ModelState.IsValid)
{
model.InitiateBulkUpload(userContext, db);
model.Populate(userContext, db, Constants.BulkUpload_DataType.ApprenticeshipData);
return(View("PostApprenticeshipUpload", model));
}
model.Populate(userContext, db, Constants.BulkUpload_DataType.ApprenticeshipData);
return(View("Apprenticeships", model));
}
public BulkUpload()
{
NavigationPage.SetBackButtonTitle(this, "");
InitializeComponent();
BindingContext = _bulkUploadViewModel = new BulkUploadViewModel(Navigation);
_bulkUploadViewModel.Initialize();
}
private BulkUploadViewModel BuildAssetsForDisplay(string rawCsv, int tenantId)
{
string[] csvRawLines = ProcessCsvLines(rawCsv);
string[] csvHeader = ProcessCsvHeader(csvRawLines[0]);
IList <Asset> assets = new List <Asset>();
IList <List <string> > errors = new List <List <string> >();
string[] csvLines = RemoveBlankLines(csvRawLines);
for (int i = 1; i < csvLines.Length; i++)
{
ConvertedAsset convertedAsset = ProcessLineToAsset(csvHeader, csvLines[i], tenantId, i);
assets.Add(convertedAsset.Asset);
if (convertedAsset.Errors.Count > 0)
{
errors.Add(convertedAsset.Errors);
}
convertedAsset.Asset.TenantId = tenantId;
convertedAsset.Asset.AssetMakeId = convertedAsset.Asset.AssetMake.LookupId;
convertedAsset.Asset.CategoryId = convertedAsset.Asset.Category.LookupId;
convertedAsset.Asset.WarrantyPeriodId = convertedAsset.Asset.WarrantyPeriod.LookupId;
}
Mapper.CreateMap <Asset, AssetViewModel>();
var assetsForView = Mapper.Map <IList <AssetViewModel> >(assets);
BulkUploadViewModel response = new BulkUploadViewModel
{
Errors = errors,
Assets = assetsForView
};
return(response);
}
public FileContentResult ApprenticeshipDownload(BulkUploadViewModel model)
{
var transformedString = model.TransformToCsv(userContext, db, Constants.BulkUpload_DataType.ApprenticeshipData);
var fileName = model.GetCsvFileName(userContext, db, Constants.BulkUpload_DataType.ApprenticeshipData);
return(File(transformedString, "text/csv", fileName));
}
public IActionResult Index()
{
BulkUploadViewModel model = new BulkUploadViewModel();
model.bulkUpload.RTAsList = _bulkUploadService.FillRTAs();
model.bulkUpload.FileTypeList = _bulkUploadService.FillFileType();
InitAccessModel(model);
return(View(model));
}
public BulkUploadViewModel PrepareImport(HttpPostedFileBase importedCsv)
{
BulkImport bulkImportResponse = new BulkImport();
string csvRaw = ConvertCsvFileToString(importedCsv);
BatchId = BackupImport(csvRaw);
BulkUploadViewModel assetsToCommit = BuildAssetsForDisplay(csvRaw, 0);
return(assetsToCommit);
}
public BulkUploadViewModel PrepareImport(int batchId)
{
BulkImport bulkImport = BulkImportRepository.Single(x => x.BulkImportId == batchId);
if (bulkImport != null)
{
BulkUploadViewModel assetsToCommit = BuildAssetsForDisplay(bulkImport.ImportText, 0);
return(assetsToCommit);
}
return(new BulkUploadViewModel());
}
public ActionResult Apprenticeships()
{
if ((userContext.IsProvider() && Permission.HasPermission(false, true, Permission.PermissionName.CanBulkUploadProviderApprenticeshipFiles)) ||
(userContext.IsOrganisation() && Permission.HasPermission(false, true, Permission.PermissionName.CanBulkUploadOrganisationApprenticeshipFiles)))
{
var model = new BulkUploadViewModel();
model.Populate(userContext, db, Constants.BulkUpload_DataType.ApprenticeshipData);
return(View(model));
}
return(Redirect());
}
public ActionResult RefreshReview(int id)
{
ImportService importService = new ImportService(User.Identity.Name);
BulkUploadViewModel response = importService.PrepareImport(id);
IEnumerable <TenantViewModel> listOfTenants = GetTenants();
response.BatchId = id.ToString();
response.Tenants = listOfTenants;
Utilities.JsonCamelCaseResult result =
new Utilities.JsonCamelCaseResult(response, JsonRequestBehavior.AllowGet);
return(result);
}
public ActionResult ConfirmImport(BulkUploadViewModel batch)
{
ImportService importService = new ImportService(User.Identity.Name);
int countOfAssetsAdded = importService.ProcessCommit(batch.BatchId, batch.SelectedTenant);
Utilities.JsonCamelCaseResult result =
new Utilities.JsonCamelCaseResult(
new BulkUploadViewModel
{
Success = true,
Message = string.Format("{0} assets imported", countOfAssetsAdded)
},
JsonRequestBehavior.AllowGet);
return(result);
}
public ActionResult Upload(HttpPostedFileBase FileUpload)
{
ImportService importService = new ImportService(User.Identity.Name);
BulkUploadViewModel response = importService.PrepareImport(FileUpload);
string batchId = importService.BatchId;
IEnumerable <TenantViewModel> listOfTenants = GetTenants();
response.BatchId = batchId;
response.Tenants = listOfTenants;
Utilities.JsonCamelCaseResult result =
new Utilities.JsonCamelCaseResult(response, JsonRequestBehavior.AllowGet);
return(result);
}
public ActionResult ConfirmImport(BulkUploadViewModel batch)
{
ImportService importService = new ImportService(User.Identity.Name);
int countOfAssetsAdded = importService.ProcessCommit(batch.BatchId, batch.SelectedTenant);
Utilities.JsonCamelCaseResult result =
new Utilities.JsonCamelCaseResult(
new BulkUploadViewModel
{
Success = true,
Message = string.Format("{0} assets imported", countOfAssetsAdded)
},
JsonRequestBehavior.AllowGet);
return result;
}
public async Task <IActionResult> Upload()
{
var session = HttpContext.Session;
session.SetString("Option", "BulkUploadApprenticeships");
int?UKPRN;
if (session.GetInt32("UKPRN") != null)
{
UKPRN = session.GetInt32("UKPRN").Value;
}
else
{
return(RedirectToAction("Index", "Home", new { errmsg = "Please select a Provider." }));
}
var provider = await _cosmosDbQueryDispatcher.ExecuteQuery(new GetProviderByUkprn { Ukprn = UKPRN.Value });
if (provider == null)
{
return(RedirectToAction("Index", "Home", new { errmsg = "Failed to look up Provider details." }));
}
var courseCounts = await _courseService.GetCourseCountsByStatusForUKPRN(new CourseSearchCriteria(UKPRN));
var courseErrors = courseCounts.IsSuccess
? courseCounts.Value.Where(x => (int)x.Status == (int)RecordStatus.MigrationPending && x.Count > 0 || (int)x.Status == (int)RecordStatus.MigrationReadyToGoLive && x.Count > 0).Count()
: 500;
var model = new BulkUploadViewModel
{
HasMigrationErrors = courseErrors > 0 ? true : false,
};
if (provider.ApprenticeshipBulkUploadStatus != null)
{
model.BulkUploadBackgroundInProgress = provider.ApprenticeshipBulkUploadStatus.InProgress;
model.BulkUploadBackgroundRowCount = provider.ApprenticeshipBulkUploadStatus.TotalRowCount;
model.BulkUploadBackgroundStartTimestamp = provider.ApprenticeshipBulkUploadStatus.StartedTimestamp;
}
return(View(model));
}
public IActionResult Upload()
{
_session.SetString("Option", "BulkUpload");
int?UKPRN;
if (_session.GetInt32("UKPRN") != null)
{
UKPRN = _session.GetInt32("UKPRN").Value;
}
else
{
return(RedirectToAction("Index", "Home", new { errmsg = "Please select a Provider." }));
}
Provider provider = FindProvider(UKPRN.Value);
if (null == provider)
{
return(RedirectToAction("Index", "Home", new { errmsg = "Failed to look up Provider details." }));
}
var courseCounts = _courseService.GetCourseCountsByStatusForUKPRN(new CourseSearchCriteria(UKPRN)).Result;
var courseErrors = courseCounts.IsSuccess
? courseCounts.Value.Where(x => (int)x.Status == (int)RecordStatus.MigrationPending && x.Count > 0 || (int)x.Status == (int)RecordStatus.MigrationReadyToGoLive && x.Count > 0).Count()
: 500;
var model = new BulkUploadViewModel
{
HasMigrationErrors = courseErrors > 0 ? true : false,
};
if (null != provider.BulkUploadStatus)
{
model.BulkUploadBackgroundInProgress = provider.BulkUploadStatus.InProgress;
model.BulkUploadBackgroundRowCount = provider.BulkUploadStatus.TotalRowCount;
model.BulkUploadBackgroundStartTimestamp = provider.BulkUploadStatus.StartedTimestamp;
}
return(View(model));
}
public FileHandler(BulkUploadViewModel model)
{
_model = model;
_file = model.File;
}
public async Task <IActionResult> Upload(IFormFile bulkUploadFile)
{
int?UKPRN;
if (_session.GetInt32("UKPRN") != null)
{
UKPRN = _session.GetInt32("UKPRN").Value;
}
else
{
return(RedirectToAction("Index", "Home", new { errmsg = "Please select a Provider." }));
}
BulkUploadViewModel vm = new BulkUploadViewModel();
string errorMessage;
// COUR-1986 restoring delete for inline processing to fix issue with course errors accruing on the dashboard DQIs
// NB: TEST WITH VOLUME!!! - this may cause time outs again
var deleteResult = await _courseService.DeleteBulkUploadCourses(UKPRN.Value);
if (!deleteResult.IsSuccess)
{
vm.errors = new string[] { deleteResult.Error };
}
else
{
if (Validate.ValidateFile(bulkUploadFile, out errorMessage))
{
int providerUKPRN = UKPRN.Value;
string userId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
string bulkUploadFileNewName = string.Format(@"{0}-{1}", DateTime.Now.ToString("yyMMdd-HHmmss"),
bulkUploadFile.FileName);
MemoryStream ms = new MemoryStream();
bulkUploadFile.CopyTo(ms);
if (!Validate.IsBinaryStream(ms))
{
int csvLineCount = _bulkUploadService.CountCsvLines(ms);
bool processInline = (csvLineCount <= _blobService.InlineProcessingThreshold);
_logger.LogInformation(
$"Csv line count = {csvLineCount} threshold = {_blobService.InlineProcessingThreshold} processInline = {processInline}");
if (processInline)
{
bulkUploadFileNewName +=
"." + DateTime.UtcNow.ToString("yyyyMMddHHmmss") +
".processed"; // stops the Azure trigger from processing the file
}
Task task = _blobService.UploadFileAsync(
$"{UKPRN.ToString()}/Courses Bulk Upload/Files/{bulkUploadFileNewName}", ms);
task.Wait();
var errors = await _bulkUploadService.ProcessBulkUpload(ms, providerUKPRN, userId, processInline);
if (errors.Any())
{
vm.errors = errors;
return(View(vm));
}
else
{
if (processInline)
{
// All good => redirect to BulkCourses action
return(RedirectToAction("Index", "PublishCourses",
new { publishMode = PublishMode.BulkUpload, fromBulkUpload = true }));
}
else
{
return(RedirectToAction("Pending"));
}
}
}
else
{
vm.errors = new string[] { "Invalid file content." };
}
}
else
{
vm.errors = new string[] { errorMessage };
}
}
return(View(vm));
}
public async Task <IActionResult> BulkUpload(BulkUploadViewModel uf)
{
if (ModelState.IsValid)
{
_user = _userManager.GetUserAsync(User).GetAwaiter().GetResult();
CsvReader csv;
IEnumerable <BulkUploadDataViewModel> records;
IFormFile file = uf.BulkUploadFile;
if (file != null && file.Length > 0)
{
using (var reader = new StreamReader(file.OpenReadStream()))
{
try
{
csv = new CsvReader(reader);
records = csv.GetRecords <BulkUploadDataViewModel>();
foreach (BulkUploadDataViewModel budvm in records)
{
//Awesome - create a user for each row
User un = new User();
un.CompanyID = HttpContext.Session.GetInt32("CompanyID") ?? 0;
un.CompanyName = HttpContext.Session.GetString("CompanyName") ?? "";
un.Role = Roles.User;
un.EmailAddress = budvm.EmailAddress;
un.Name = budvm.Name;
un.PhoneNumber = budvm.PhoneNumber;
un.Gender = budvm.Gender;
un.InterfaceLanguage = budvm.InterfaceLanguage;
un.WebsiteLanguage = budvm.ArticleLanguages;
un.Topics = budvm.Topics;
un.Groups = budvm.Groups;
un.TypeOfUser = budvm.TypeOfUser;
un.Country = budvm.Country;
un.State = budvm.State;
un.City = budvm.City;
un.CreatedOn = DateTime.Now;
un.CreatedBy = _user.UserName;
//now for the tricky bit - have to do a normal asp.net registration and if a companyadmin or admin set the appropriate claim type
//Create the user
var user = new UserViewModel {
EmailAddress = budvm.EmailAddress, CompanyName = HttpContext.Session.GetString("CompanyName") ?? "", CompanyID = HttpContext.Session.GetInt32("CompanyID") ?? 0, Name = budvm.Name
};
if (CreateDotNetUser(user, "ChangePassword1!").Succeeded)
{
//Add the claim type - it will be exactly as per the type passed to the Index in the first place
var userForClaims = await _userManager.FindByEmailAsync(user.EmailAddress);
var ac = await _userManager.GetClaimsAsync(userForClaims);
if (ac.Count() <= 0)
{
await _userManager.AddToRoleAsync(userForClaims, "User");
await _userManager.AddClaimAsync(userForClaims, new Claim(ClaimTypes.Role, "User"));
}
//Add the user to the user table as well at the identity tables
_context.Add(un);
}
}
await _context.SaveChangesAsync();
ViewBag.Message = "Users successfully created";
return(RedirectToAction("Index", "Users", new { id = HttpContext.Session.GetString("ManageType") }));
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e);
ViewBag.Message = e + System.Environment.NewLine;
}
}
}
}
ViewBag.Message += " User creation failed";
return(View(uf));
}
private BulkUploadViewModel BuildAssetsForDisplay(string rawCsv, int tenantId)
{
string[] csvRawLines = ProcessCsvLines(rawCsv);
string[] csvHeader = ProcessCsvHeader(csvRawLines[0]);
IList<Asset> assets = new List<Asset>();
IList<List<string>> errors = new List<List<string>>();
string[] csvLines = RemoveBlankLines(csvRawLines);
for (int i = 1; i < csvLines.Length; i++)
{
ConvertedAsset convertedAsset = ProcessLineToAsset(csvHeader, csvLines[i], tenantId, i);
assets.Add(convertedAsset.Asset);
if (convertedAsset.Errors.Count > 0)
{
errors.Add(convertedAsset.Errors);
}
convertedAsset.Asset.TenantId = tenantId;
convertedAsset.Asset.AssetMakeId = convertedAsset.Asset.AssetMake.LookupId;
convertedAsset.Asset.CategoryId = convertedAsset.Asset.Category.LookupId;
convertedAsset.Asset.WarrantyPeriodId = convertedAsset.Asset.WarrantyPeriod.LookupId;
}
Mapper.CreateMap<Asset, AssetViewModel>();
var assetsForView = Mapper.Map<IList<AssetViewModel>>(assets);
BulkUploadViewModel response = new BulkUploadViewModel
{
Errors = errors,
Assets = assetsForView
};
return response;
}
public ActionResult ConfirmUpload(BulkUploadHistoryDetailViewModel bulkModel)
{
if ((userContext.IsProvider() && Permission.HasPermission(false, true, Permission.PermissionName.CanBulkUploadProviderFiles)) ||
(userContext.IsOrganisation() && Permission.HasPermission(false, true, Permission.PermissionName.CanBulkUploadOrganisationFiles)))
{
var history = db.BulkUploads.FirstOrDefault(b => b.BulkUploadId.Equals(bulkModel.BulkUploadId));
if (history == null)
{
return(HttpNotFound());
}
if (userContext.ItemId.HasValue)
{
if ((userContext.IsOrganisation() && history.UserOrganisationId != userContext.ItemId) ||
(userContext.IsProvider() && history.UserProviderId != userContext.ItemId))
{
return(HttpNotFound());
}
}
else
{
return(HttpNotFound());
}
// Check that the status is currently at "Needs Confirmation"
if (history
.BulkUploadStatusHistories
.OrderByDescending(x => x.CreatedDateTimeUtc)
.First()
.BulkUploadStatusId != (Int32)Constants.BulkUploadStatus.Needs_Confirmation)
{
return(HttpNotFound());
}
var model = new BulkUploadViewModel
{
Summary = new UploadSummary
{
TargetFileUrl = history.FilePath,
FileName = history.FileName
},
OverrideException = true
};
/*
* Matt - dev note
* ---------------------
* This section relates to replacing the in-application BulkUpload
* with a more efficient out-of-application service based system.
*
*/
try
{
var bulkUploadService = new BulkUploadWCFServiceClient();
var parameters = new ConfirmParameters
{
BulkUploadId = bulkModel.BulkUploadId,
UserId =
history
.BulkUploadStatusHistories
.OrderByDescending(x => x.CreatedDateTimeUtc)
.First()
.AspNetUser
.Id
};
bulkUploadService.Confirm(parameters);
}
catch (FaultException <BulkUploadFault> ex)
{
model.Message = String.Format("The bulk upload service reported an error: {0}", ex.Detail.Message);
}
/*
* end
*/
//model.InitiateBulkUpload(userContext, db);
string viewName;
if (history.FileContentType != null && history.FileContentType == (int)Constants.FileContentType.ApprenticeshipData)
{
viewName = "PostApprenticeshipUpload";
}
else
{
viewName = "PostCourseUpload";
}
// var viewName = (bulkModel.FileContentType == Constants.FileContentType.CourseData ? "PostCourseUpload" : "PostApprenticeshipUpload");
return(View(viewName, model));
}
return(Redirect());
}
