public async Task <IActionResult> AddPracticeOrder([FromForm] AddPracticeOrderInput request)
{
var currentUser = await _currentUserProvider.GetCurrentUser();
if (currentUser is null)
{
return(Json(ActionOutput.Error("Пользователь не найден")));
}
request.UserId = currentUser.Id;
return(await _dispatcher.DispatchAsync(request));
}
protected override ICollection <ApplicationUser> GetOnlyResponsableUsers(WorkEvent workEvent,
ICollection <ApplicationUser> users)
{
var currentUser = _currentUserProvider.GetCurrentUser();
var responsibleUsers = users.Where(x => x.Id != currentUser.Id);
if (_previousEvents.Count == 5)
{
_previousEvents.Clear();
}
if (IsSpecialEvent(workEvent))
{
_previousEvents.Add(workEvent);
}
if (workEvent.Type == EventType.WorkItemChanged)
{
var events = _previousEvents.Where(IsSpecialEvent).ToArray();
if (events.Any())
{
responsibleUsers = responsibleUsers.Where(x => events.All(ev => ev.Data != x.Id));
_previousEvents.Clear();
}
}
return(responsibleUsers.ToArray());
}
public ConfiguredFeaturesCollection GetFeatureFlags()
{
var features = _innerFeatureFlagProvider.GetFeatureFlags();
var currentUser = _currentUserProvider.GetCurrentUser();
// All admins get VenuesDataManagement
if (currentUser.IsAdmin)
{
features = features.With(FeatureFlags.VenuesDataManagement);
}
// If the user is bound to a provider on the beta testers list, they get VenuesDataManagement
if (currentUser.CurrentProviderUkprn.HasValue &&
_betaTestingProviderUkprns.Contains(currentUser.CurrentProviderUkprn.Value))
{
features = features.With(FeatureFlags.VenuesDataManagement);
}
// If any of '{Courses|Venues}DataManagement' features are defined
// then also define the root 'DataManagement' feature
if (features.HaveFeature(FeatureFlags.CoursesDataManagement) ||
features.HaveFeature(FeatureFlags.VenuesDataManagement))
{
features = features.With(FeatureFlags.DataManagement);
}
return(features);
}
public async Task <IActionResult> Index(EditApprenticeshipViewModel model)
{
if (model.ApprenticeshipId.HasValue)
{
var result = await _sqlQueryDispatcher.ExecuteQuery(new GetApprenticeship { ApprenticeshipId = model.ApprenticeshipId.Value });
await _sqlQueryDispatcher.ExecuteQuery(new UpdateApprenticeship()
{
ApprenticeshipId = result.ApprenticeshipId,
ApprenticeshipLocations = result.ApprenticeshipLocations.Select(CreateApprenticeshipLocation.FromModel),
ApprenticeshipWebsite = model.ContactUsURL,
ContactEmail = model.Email,
ContactTelephone = model.Telephone,
ContactWebsite = model.WebSite,
MarketingInformation = model.Information,
Standard = result.Standard,
UpdatedBy = _currentUserProvider.GetCurrentUser(),
UpdatedOn = _clock.UtcNow
});
return(RedirectToAction("Index", "PublishApprenticeships"));
}
return(View("Error", new ErrorViewModel {
RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier
}));
}
public async Task <IOutput> Handle(ChangeRoleInput request, CancellationToken cancellationToken)
{
var currentUesrId = (await _currentUserProvider.GetCurrentUser()).Id;
var user = await _userManager.FindByIdAsync(request.UserId.ToString());
if (user is null)
{
return(ActionOutput.Error("Пользователя не существует."));
}
if (user.Id == currentUesrId)
{
return(ActionOutput.Error("Нельзя менять себе роль"));
}
var newRole = request.NewRole;
var userRoles = await _userManager.GetRolesAsync(user);
var addResult = await _userManager.AddToRoleAsync(user, Enum.GetName(newRole));
var removeResult = await _userManager.RemoveFromRolesAsync(user, userRoles);
return(ActionOutput.Success);
}
public async Task <IOutput> Handle(AddCommentInput request, CancellationToken cancellationToken)
{
var currentUser = await _currentUserProvider.GetCurrentUser();
if (currentUser is null)
{
return(ActionOutput.Error("Пользователь не найден"));
}
var lesson = await _context.Lessons.FirstOrDefaultAsync(
x => x.Id == request.LessonId,
cancellationToken : cancellationToken);
if (lesson is null)
{
return(ActionOutput.Error("Урок не найден"));
}
var comment = new Entity.Comment(request.Text, currentUser, lesson);
await _context.Comments.AddAsync(comment, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
return(ActionOutput.SuccessData(comment.Id));
}
public async Task <Success> Handle(Command request, CancellationToken cancellationToken)
{
ThrowIfFlowStateNotValid();
var journeyInstance = _journeyInstanceProvider.GetInstance <AddVenueJourneyModel>();
var venueId = Guid.NewGuid();
var providerUkprn = _providerContextProvider.GetProviderContext().ProviderInfo.Ukprn;
await _cosmosDbQueryDispatcher.ExecuteQuery(new CreateVenue()
{
VenueId = venueId,
ProviderUkprn = providerUkprn,
Name = journeyInstance.State.Name,
Email = journeyInstance.State.Email,
Telephone = journeyInstance.State.Telephone,
Website = journeyInstance.State.Website,
AddressLine1 = journeyInstance.State.AddressLine1,
AddressLine2 = journeyInstance.State.AddressLine2,
Town = journeyInstance.State.Town,
County = journeyInstance.State.County,
Postcode = journeyInstance.State.Postcode,
Latitude = journeyInstance.State.Latitude,
Longitude = journeyInstance.State.Longitude,
CreatedBy = _currentUserProvider.GetCurrentUser(),
CreatedDate = _clock.UtcNow
});
journeyInstance.UpdateState(state => state.VenueId = venueId);
// Complete JourneyInstance so state can no longer be changed
journeyInstance.Complete();
return(new Success());
}
public async Task <Success> Handle(Command request, CancellationToken cancellationToken)
{
var result = await _cosmosDbQueryDispatcher.ExecuteQuery(new UpdateVenue()
{
VenueId = request.VenueId,
Name = _journeyInstance.State.Name,
Email = _journeyInstance.State.Email,
PhoneNumber = _journeyInstance.State.PhoneNumber,
Website = _journeyInstance.State.Website,
AddressLine1 = _journeyInstance.State.AddressLine1,
AddressLine2 = _journeyInstance.State.AddressLine2,
Town = _journeyInstance.State.Town,
County = _journeyInstance.State.County,
Postcode = _journeyInstance.State.Postcode,
Latitude = _journeyInstance.State.Latitude,
Longitude = _journeyInstance.State.Longitude,
UpdatedDate = _clock.UtcNow,
UpdatedBy = _currentUserProvider.GetCurrentUser()
});
var venue = (Venue)result.Value;
await _sqlDataSync.SyncVenue(venue);
return(new Success());
}
private void CheckUserPermissions()
{
var currentUser = _currentUserProvider.GetCurrentUser();
if (currentUser.Role == RoleNames.ProviderUser)
{
throw new NotAuthorizedException();
}
}
public async Task <OneOf <ModelWithErrors <ViewModel>, Success> > Handle(
Command request,
CancellationToken cancellationToken)
{
ThrowIfFlowStateNotValid();
var tLevelId = Guid.NewGuid();
var currentUser = _currentUserProvider.GetCurrentUser();
var now = _clock.UtcNow;
var result = await _sqlQueryDispatcher.ExecuteQuery(
new CreateTLevel()
{
CreatedBy = currentUser,
CreatedOn = now,
EntryRequirements = _journeyInstance.State.EntryRequirements,
HowYoullBeAssessed = _journeyInstance.State.HowYoullBeAssessed,
HowYoullLearn = _journeyInstance.State.HowYoullLearn,
LocationVenueIds = _journeyInstance.State.LocationVenueIds,
ProviderId = request.ProviderId,
StartDate = _journeyInstance.State.StartDate.Value,
TLevelDefinitionId = _journeyInstance.State.TLevelDefinitionId.Value,
TLevelId = tLevelId,
Website = _journeyInstance.State.Website,
WhatYouCanDoNext = _journeyInstance.State.WhatYouCanDoNext,
WhatYoullLearn = _journeyInstance.State.WhatYoullLearn,
WhoFor = _journeyInstance.State.WhoFor,
YourReference = _journeyInstance.State.YourReference
});
if (result.Value is CreateTLevelFailedReason reason)
{
if (reason == CreateTLevelFailedReason.TLevelAlreadyExistsForDate)
{
var vm = await CreateViewModel();
var validationResult = new ValidationResult(new[]
{
new ValidationFailure(
nameof(ViewModel.StartDate),
"T Level already exists, enter a new start date")
});
return(new ModelWithErrors <ViewModel>(vm, validationResult));
}
throw new NotImplementedException(
$"Unknown {nameof(CreateTLevelFailedReason)}: '{reason}'.");
}
_journeyInstance.UpdateState(state => state.SetCreatedTLevel(tLevelId));
// Complete JourneyInstance so state can no longer be changed
_journeyInstance.Complete();
return(new Success());
}
public override void OnActionExecuting(ActionExecutingContext context)
{
var currentUser = _currentUserProvider.GetCurrentUser();
if (!AuthorizationRules.CanUpdateProviderType(currentUser))
{
throw new NotAuthorizedException();
}
}
public Task <TResponse> Handle(
TRequest request,
CancellationToken cancellationToken,
RequestHandlerDelegate <TResponse> next)
{
var currentUser = _currentUserProvider.GetCurrentUser();
if (currentUser != null && (currentUser.IsDeveloper || currentUser.IsHelpdesk))
{
return(next());
}
throw new NotAuthorizedException();
}
public async Task <OneOf <NotFound, Success> > Handle(OnboardProviderCommand request, CancellationToken cancellationToken)
{
var result = await _cosmosDbQueryDispatcher.ExecuteQuery(new UpdateProviderOnboarded
{
ProviderId = request.ProviderId,
UpdatedBy = _currentUserProvider.GetCurrentUser(),
UpdatedDateTime = _clock.UtcNow.ToLocalTime()
});
return(result.Match <OneOf <NotFound, Success> >(
notFound => notFound,
_ => new Success(),
success => success));
}
public async Task <ViewModel> Handle(Query request, CancellationToken cancellationToken)
{
var cosmosProvider = await _cosmosDbQueryDispatcher.ExecuteQuery(new CosmosQueries.GetProviderById()
{
ProviderId = request.ProviderId
});
var sqlProvider = await _sqlQueryDispatcher.ExecuteQuery(new SqlQueries.GetProviderById()
{
ProviderId = request.ProviderId
});
if (cosmosProvider == null)
{
throw new ResourceDoesNotExistException(ResourceType.Provider, request.ProviderId);
}
var currentUser = _currentUserProvider.GetCurrentUser();
var providerTLevelDefinitions = cosmosProvider.ProviderType.HasFlag(ProviderType.TLevels)
? await _sqlQueryDispatcher.ExecuteQuery(new SqlQueries.GetTLevelDefinitionsForProvider {
ProviderId = request.ProviderId
})
: Enumerable.Empty <SqlModels.TLevelDefinition>();
return(new ViewModel()
{
ProviderId = request.ProviderId,
ProviderName = cosmosProvider.ProviderName,
CourseDirectoryStatus = cosmosProvider.ProviderStatus,
Ukprn = cosmosProvider.Ukprn,
TradingName = cosmosProvider.Alias,
DisplayName = sqlProvider.DisplayName,
CanChangeDisplayName = sqlProvider.HaveAlias && AuthorizationRules.CanUpdateProviderDisplayName(currentUser),
ProviderType = cosmosProvider.ProviderType,
CanChangeProviderType = AuthorizationRules.CanUpdateProviderType(currentUser),
MarketingInformation = cosmosProvider.MarketingInformation != null?
Html.SanitizeHtml(cosmosProvider.MarketingInformation) :
null,
ShowMarketingInformation = cosmosProvider.ProviderType.HasFlag(ProviderType.Apprenticeships),
CanUpdateMarketingInformation = AuthorizationRules.CanUpdateProviderMarketingInformation(currentUser),
ProviderTLevelDefinitions = providerTLevelDefinitions.Select(d => new TLevelDefinitionViewModel
{
TLevelDefinitionId = d.TLevelDefinitionId,
Name = d.Name
})
});
}
public async Task <CommandResponse> Handle(
Command request,
CancellationToken cancellationToken)
{
var currentUser = _currentUserProvider.GetCurrentUser();
if (currentUser.IsHelpdesk)
{
throw new NotAuthorizedException();
}
var maybeSubmission = await _sqlQueryDispatcher.ExecuteQuery(
new GetLatestApprenticeshipQASubmissionForProvider()
{
ProviderId = request.ProviderId
});
var submission = maybeSubmission.Match(
notfound => throw new InvalidStateException(InvalidStateReason.InvalidApprenticeshipQASubmission),
found => found);
// Cannot hide passed notification if qa status is not passed
if (submission.Passed != true)
{
throw new InvalidStateException(InvalidStateReason.InvalidApprenticeshipQAStatus);
}
// Cannot hide notification if it has already been hidden
if (submission.HidePassedNotification)
{
throw new InvalidStateException();
}
// Hide notification
var hideDialog = await _sqlQueryDispatcher.ExecuteQuery(
new UpdateHidePassedNotification()
{
ApprenticeshipQASubmissionId = submission.ApprenticeshipQASubmissionId,
HidePassedNotification = true
});
return(hideDialog.Match(
notfound => throw new InvalidStateException(InvalidStateReason.InvalidApprenticeshipQASubmission),
success => success));
}
public IActionResult Index([FromServices] ICurrentUserProvider currentUserProvider)
{
if (!User.Identity.IsAuthenticated)
{
return(View("Start"));
}
var currentUser = currentUserProvider.GetCurrentUser();
if (currentUser.IsAdmin)
{
return(RedirectToAction("Dashboard", "HelpdeskDashboard"));
}
else // Provider user
{
return(RedirectToAction("Index", "ProviderDashboard"));
}
}
public async Task <CommandResponse> Handle(
Command request,
CancellationToken cancellationToken)
{
var currentUser = _currentUserProvider.GetCurrentUser();
if (currentUser.IsHelpdesk)
{
throw new NotAuthorizedException();
}
var latestSubmission = await _sqlQueryDispatcher.ExecuteQuery(
new GetLatestApprenticeshipQASubmissionForProvider()
{
ProviderId = _providerContextProvider.GetProviderId()
});
if (latestSubmission == null)
{
throw new InvalidStateException(InvalidStateReason.InvalidApprenticeshipQASubmission);
}
// Cannot hide passed notification if qa status is not passed
if (latestSubmission.Passed != true)
{
throw new InvalidStateException(InvalidStateReason.InvalidApprenticeshipQAStatus);
}
// Cannot hide notification if it has already been hidden
if (latestSubmission.HidePassedNotification)
{
throw new InvalidStateException();
}
// Hide notification
await _sqlQueryDispatcher.ExecuteQuery(
new UpdateHidePassedNotification()
{
ApprenticeshipQASubmissionId = latestSubmission.ApprenticeshipQASubmissionId,
HidePassedNotification = true
});
return(new Success());
}
public async Task <OneOf <ModelWithErrors <ViewModel>, SuccessViewModel> > Handle(Command request, CancellationToken cancellationToken)
{
var ukprn = await GetUkprnForCourse(request.CourseId);
var(course, courseRun) = await GetCourseAndCourseRun(request.CourseId, request.CourseRunId, ukprn);
if (!request.Confirm)
{
var vm = await CreateViewModel(course, courseRun);
var validationResult = new ValidationResult(new[]
{
new ValidationFailure(nameof(request.Confirm), "Confirm you want to delete the course")
});
return(new ModelWithErrors <ViewModel>(vm, validationResult));
}
await _cosmosDbQueryDispatcher.ExecuteQuery(new DeleteCourseRunQuery()
{
CourseId = request.CourseId,
CourseRunId = request.CourseRunId,
ProviderUkprn = ukprn,
UpdatedBy = _currentUserProvider.GetCurrentUser().UserId,
UpdatedDate = _clock.UtcNow,
});
// The next page needs this info - stash it in the JourneyModel
// since it will no longer able to query for it.
_journeyInstance.UpdateState(new JourneyModel()
{
CourseName = courseRun.CourseName,
ProviderId = (await _providerInfoCache.GetProviderIdForUkprn(ukprn)).Value,
ProviderUkprn = ukprn
});
_journeyInstance.Complete();
return(new SuccessViewModel()
{
CourseId = request.CourseId,
CourseRunId = request.CourseRunId,
CourseName = courseRun.CourseName
});
}
public async Task <TResponse> Handle(
TRequest request,
CancellationToken cancellationToken,
RequestHandlerDelegate <TResponse> next)
{
var providerId = _descriptor.GetProviderId(request);
var currentUser = _currentUserProvider.GetCurrentUser();
if (!AuthorizationRules.CanSubmitQASubmission(currentUser, providerId))
{
throw new NotAuthorizedException();
}
var qaStatus = await _sqlQueryDispatcher.ExecuteQuery(
new GetProviderApprenticeshipQAStatus()
{
ProviderId = providerId
});
var effectiveQaStatus = qaStatus.ValueOrDefault();
// Ignore UnableToComplete here
var qaStatusIsValid = (effectiveQaStatus & ~ApprenticeshipQAStatus.UnableToComplete) switch
{
ApprenticeshipQAStatus.NotStarted => true,
ApprenticeshipQAStatus.Failed => true,
_ => false
};
var providerInfo = await _providerInfoCache.GetProviderInfo(providerId);
var providerTypeIsValid = providerInfo.ProviderType.HasFlag(ProviderType.Apprenticeships);
if (!qaStatusIsValid || !providerTypeIsValid)
{
throw new InvalidStateException(InvalidStateReason.InvalidApprenticeshipQAStatus);
}
return(await next());
}
}
private bool IsAuthorized(Guid?providerId)
{
var currentUser = _currentUserProvider.GetCurrentUser();
if (currentUser == null)
{
return(false);
}
if (currentUser.Role == RoleNames.Developer || currentUser.Role == RoleNames.Helpdesk)
{
return(true);
}
if ((currentUser.Role == RoleNames.ProviderUser || currentUser.Role == RoleNames.ProviderSuperUser) &&
currentUser.CurrentProviderId == providerId)
{
return(true);
}
return(false);
}
public async Task <OneOf <ModelWithErrors <ViewModel>, Success> > Handle(Command request, CancellationToken cancellationToken)
{
_journeyInstance.ThrowIfCompleted();
var apprenticeship = await GetApprenticeship(request.ApprenticeshipId);
if (!request.Confirm)
{
var vm = CreateViewModel(apprenticeship);
var validationResult = new ValidationResult(new[]
{
new ValidationFailure(nameof(request.Confirm), "Confirm you want to delete the Apprenticeship")
});
return(new ModelWithErrors <ViewModel>(vm, validationResult));
}
await _sqlQueryDispatcher.ExecuteQuery(new DeleteApprenticeshipQuery()
{
ApprenticeshipId = request.ApprenticeshipId,
DeletedBy = _currentUserProvider.GetCurrentUser(),
DeletedOn = _clock.UtcNow
});
_providerOwnershipCache.OnApprenticeshipDeleted(request.ApprenticeshipId);
// The next page needs this info - stash it in the JourneyModel
// since it will no longer able to query for it.
_journeyInstance.UpdateState(new JourneyModel()
{
ApprenticeshipId = apprenticeship.ApprenticeshipId,
ProviderId = apprenticeship.ProviderId,
ApprenticeshipTitle = apprenticeship.Standard.StandardName,
NotionalNVQLevelv2 = apprenticeship.Standard.NotionalNVQLevelv2
});
_journeyInstance.Complete();
return(new Success());
}
public async Task <OneOf <ModelWithErrors <ViewModel>, Success> > Handle(Command request, CancellationToken cancellationToken)
{
_journeyInstance.ThrowIfCompleted();
var tLevel = await GetTLevel(request.TLevelId);
if (!request.Confirm)
{
var vm = CreateViewModel(tLevel);
var validationResult = new ValidationResult(new[]
{
new ValidationFailure(nameof(request.Confirm), "Confirm you want to delete the T Level")
});
return(new ModelWithErrors <ViewModel>(vm, validationResult));
}
await _sqlQueryDispatcher.ExecuteQuery(new DeleteTLevelQuery()
{
TLevelId = request.TLevelId,
DeletedBy = _currentUserProvider.GetCurrentUser(),
DeletedOn = _clock.UtcNow
});
_providerOwnershipCache.OnTLevelDeleted(request.TLevelId);
// The next page needs this info - stash it in the JourneyModel
// since it will no longer able to query for it.
_journeyInstance.UpdateState(new JourneyModel()
{
TLevelName = tLevel.TLevelDefinition.Name,
ProviderId = tLevel.ProviderId,
YourReference = tLevel.YourReference
});
_journeyInstance.Complete();
return(new Success());
}
public async Task <Success> Handle(Command request, CancellationToken cancellationToken)
{
await _sqlQueryDispatcher.ExecuteQuery(new UpdateVenue()
{
VenueId = request.VenueId,
ProviderVenueRef = _journeyInstance.State.ProviderVenueRef,
Name = _journeyInstance.State.Name,
Email = _journeyInstance.State.Email,
Telephone = _journeyInstance.State.PhoneNumber,
Website = _journeyInstance.State.Website,
AddressLine1 = _journeyInstance.State.AddressLine1,
AddressLine2 = _journeyInstance.State.AddressLine2,
Town = _journeyInstance.State.Town,
County = _journeyInstance.State.County,
Postcode = _journeyInstance.State.Postcode,
Latitude = _journeyInstance.State.Latitude,
Longitude = _journeyInstance.State.Longitude,
UpdatedOn = _clock.UtcNow,
UpdatedBy = _currentUserProvider.GetCurrentUser()
});
return(new Success());
}
public async Task <IOutput> Handle(CheckInput request, CancellationToken cancellationToken)
{
var user = await _currentUserProvider.GetCurrentUser();
if (user is null)
{
return(ActionOutput.Error("Вы не авторизованы"));
}
if (user.IsBanned == true)
{
_logger.LogInformation("User {name} tried to enter with ban", user.Mail);
return(ActionOutput.Error("Пользователь забанен."));
}
var identity = _dataProvider.GetIdentity(user.Mail);
if (identity is null)
{
return(ActionOutput.Error("Пользователь не найден"));
}
return(ActionOutput.SuccessData(new { token = _dataProvider.GetJwtByIdentity(identity) }));
}
public async Task <OneOf <UploadFailedResult, UploadSucceededResult> > Handle(
Command request,
CancellationToken cancellationToken)
{
var validator = new CommandValidator();
var result = await validator.ValidateAsync(request);
if (!result.IsValid)
{
return(new UploadFailedResult(await CreateViewModel(), result));
}
var providerId = _providerContextProvider.GetProviderId();
using var stream = request.File.OpenReadStream();
var saveFileResult = await _fileUploadProcessor.SaveVenueFile(
providerId,
stream,
_currentUserProvider.GetCurrentUser());
if (saveFileResult.Status == SaveVenueFileResultStatus.InvalidFile)
{
return(new UploadFailedResult(
await CreateViewModel(),
"The selected file must be a CSV"));
}
else if (saveFileResult.Status == SaveVenueFileResultStatus.InvalidRows)
{
return(new UploadFailedResult(
await CreateViewModel(),
"The selected file must use the template"));
}
else if (saveFileResult.Status == SaveVenueFileResultStatus.InvalidHeader)
{
return(new UploadFailedResult(
await CreateViewModel(),
"Enter headings in the correct format",
saveFileResult.MissingHeaders));
}
else if (saveFileResult.Status == SaveVenueFileResultStatus.EmptyFile)
{
return(new UploadFailedResult(
await CreateViewModel(),
"The selected file is empty"));
}
else if (saveFileResult.Status == SaveVenueFileResultStatus.ExistingFileInFlight)
{
// UI Should stop us getting here so a generic error is sufficient
throw new InvalidStateException();
}
Debug.Assert(saveFileResult.Status == SaveVenueFileResultStatus.Success);
// Wait for a little bit to see if the file gets processed quickly
// (so we can skip the In Progress UI)
try
{
using var cts = new CancellationTokenSource(_optionsAccessor.Value.ProcessedImmediatelyThreshold);
var uploadStatus = await _fileUploadProcessor.WaitForVenueProcessingToCompleteForProvider(providerId, cts.Token);
return(uploadStatus == UploadStatus.ProcessedWithErrors ?
UploadSucceededResult.ProcessingCompletedWithErrors :
UploadSucceededResult.ProcessingCompletedSuccessfully);
}
catch (OperationCanceledException)
{
return(UploadSucceededResult.ProcessingInProgress);
}
}
public async Task <IActionResult> Upload(IFormFile bulkUploadFile)
{
var sw = Stopwatch.StartNew();
try
{
var UKPRN = HttpContext.Session.GetInt32("UKPRN");
if (UKPRN == null)
{
return(RedirectToAction("Index", "Home", new { errmsg = "Please select a Provider." }));
}
if (!Validate.ValidateFile(bulkUploadFile, out var errorMessage))
{
return(View(new BulkUploadViewModel {
errors = new[] { errorMessage }
}));
}
await using var ms = new MemoryStream();
bulkUploadFile.CopyTo(ms);
ms.Position = 0;
if (Validate.IsBinaryStream(ms))
{
return(View(new BulkUploadViewModel {
errors = new[] { "Invalid file content." }
}));
}
ApprenticeshipBulkUploadResult result = default;
try
{
ms.Position = 0;
result = await _apprenticeshipBulkUploadService.ValidateAndUploadCSV(
bulkUploadFile.FileName,
ms,
_currentUserProvider.GetCurrentUser(),
UKPRN.Value);
}
catch (HeaderValidationException he)
{
var errors = new[] { ApprenticeshipBulkUploadService.FirstSentence(he) };
return(View(new BulkUploadViewModel {
errors = errors
}));
}
catch (BadDataException be)
{
var errors = be.Message.Split(';');
return(View(new BulkUploadViewModel {
errors = errors
}));
}
catch (Exception e)
{
var errors = new[] { e.Message };
return(View(new BulkUploadViewModel {
errors = errors
}));
}
if (result.Errors.Count != 0)
{
var errors = result.Errors;
return(RedirectToAction("WhatDoYouWantToDoNext", "BulkUploadApprenticeships", new
{
message = $"Your file contained {errors.Count} error{(errors.Count > 1 ? "s" : "")}. You must resolve all errors before your apprenticeship training information can be published.",
errorCount = errors.Count
}
));
}
if (result.ProcessedSynchronously)
{
// All good => redirect to BulkCourses action
return(RedirectToAction("PublishYourFile", "BulkUploadApprenticeships"));
}
else
{
return(RedirectToAction("Pending"));
}
}
finally
{
sw.Stop();
}
}
public async Task <OneOf <ModelWithErrors <ViewModel>, Success> > Handle(
CompleteCommand request,
CancellationToken cancellationToken)
{
ValidateFlowState();
var providerId = request.ProviderId;
var provider = await _providerInfoCache.GetProviderInfo(providerId);
var validator = new CompleteValidator();
var validationResult = await validator.ValidateAsync(_flow.State);
if (!validationResult.IsValid)
{
var vm = await CreateViewModel(provider);
return(new ModelWithErrors <ViewModel>(vm, validationResult));
}
var currentUser = _currentUserProvider.GetCurrentUser();
var now = _clock.UtcNow;
var apprenticeshipId = _flow.State.ApprenticeshipId.GetValueOrDefault(Guid.NewGuid());
var providerUkprn = provider.Ukprn;
var providerVenues = await _cosmosDbQueryDispatcher.ExecuteQuery(
new GetVenuesByProvider()
{
ProviderUkprn = providerUkprn
});
var locations = CreateLocations(providerVenues, providerUkprn);
if (_flow.State.ApprenticeshipId.HasValue)
{
// Update existing apprenticeship
await _cosmosDbQueryDispatcher.ExecuteQuery(
new UpdateApprenticeship()
{
ApprenticeshipLocations = locations,
ApprenticeshipTitle = _flow.State.ApprenticeshipStandardOrFramework.StandardOrFrameworkTitle,
ApprenticeshipType = _flow.State.ApprenticeshipStandardOrFramework.IsStandard ?
ApprenticeshipType.StandardCode :
ApprenticeshipType.FrameworkCode,
ContactEmail = _flow.State.ApprenticeshipContactEmail,
ContactTelephone = _flow.State.ApprenticeshipContactTelephone,
ContactWebsite = _flow.State.ApprenticeshipContactWebsite,
UpdatedBy = currentUser,
UpdatedDate = now,
Id = _flow.State.ApprenticeshipId.Value,
MarketingInformation = _flow.State.ApprenticeshipMarketingInformation,
ProviderUkprn = providerUkprn,
StandardOrFramework = _flow.State.ApprenticeshipStandardOrFramework,
Url = _flow.State.ApprenticeshipWebsite
});
}
else
{
// Create apprenticeship
await _cosmosDbQueryDispatcher.ExecuteQuery(
new CreateApprenticeship()
{
ApprenticeshipLocations = locations,
ApprenticeshipTitle = _flow.State.ApprenticeshipStandardOrFramework.StandardOrFrameworkTitle,
ApprenticeshipType = _flow.State.ApprenticeshipStandardOrFramework.IsStandard ?
ApprenticeshipType.StandardCode :
ApprenticeshipType.FrameworkCode,
ContactEmail = _flow.State.ApprenticeshipContactEmail,
ContactTelephone = _flow.State.ApprenticeshipContactTelephone,
ContactWebsite = _flow.State.ApprenticeshipContactWebsite,
CreatedByUser = currentUser,
CreatedDate = now,
Id = apprenticeshipId,
MarketingInformation = _flow.State.ApprenticeshipMarketingInformation,
ProviderId = request.ProviderId,
ProviderUkprn = providerUkprn,
StandardOrFramework = _flow.State.ApprenticeshipStandardOrFramework,
Url = _flow.State.ApprenticeshipWebsite,
Status = 2 // Pending
});
}
// Create QA submission
await _sqlQueryDispatcher.ExecuteQuery(
new CreateApprenticeshipQASubmission()
{
ProviderId = request.ProviderId,
Apprenticeships = new List <CreateApprenticeshipQASubmissionApprenticeship>()
{
new CreateApprenticeshipQASubmissionApprenticeship()
{
ApprenticeshipId = apprenticeshipId,
ApprenticeshipMarketingInformation = _flow.State.ApprenticeshipMarketingInformation,
ApprenticeshipTitle = _flow.State.ApprenticeshipStandardOrFramework.StandardOrFrameworkTitle,
Locations = locations.Select(l => l.ApprenticeshipLocationType switch
{
ApprenticeshipLocationType.ClassroomBased => new CreateApprenticeshipQASubmissionApprenticeshipLocation(
new CreateApprenticeshipQASubmissionApprenticeshipClassroomLocation()
{
DeliveryModes = l.DeliveryModes,
Radius = l.Radius.Value,
VenueName = providerVenues.Single(v => v.Id == l.VenueId).VenueName
}),
ApprenticeshipLocationType.EmployerBased => new CreateApprenticeshipQASubmissionApprenticeshipLocation(
l.National == true ?
new CreateApprenticeshipQASubmissionApprenticeshipEmployerLocation(new National()) :
new CreateApprenticeshipQASubmissionApprenticeshipEmployerLocation(
new CreateApprenticeshipQASubmissionApprenticeshipEmployerLocationRegions()
{
SubRegionIds = l.Regions.ToList()
})),
_ => throw new NotSupportedException()
}).ToList()
public async Task <OneOf <ModelWithErrors <ViewModel>, PublishResult> > Handle(Command request, CancellationToken cancellationToken)
{
var providerId = _providerContextProvider.GetProviderId();
if (!request.Confirm)
{
var(uploadRows, uploadStatus) = await _fileUploadProcessor.GetCourseUploadRowsForProvider(providerId);
var vm = await CreateViewModel(uploadRows);
var validationResult = new ValidationResult(new[]
{
new ValidationFailure(nameof(request.Confirm), "Confirm you want to publish these courses")
});
return(new ModelWithErrors <ViewModel>(vm, validationResult));
}
var publishResult = await _fileUploadProcessor.PublishCourseUploadForProvider(providerId, _currentUserProvider.GetCurrentUser());
if (publishResult.Status == PublishResultStatus.Success)
{
var journeyInstance = _journeyInstanceProvider.GetOrCreateInstance(() => new PublishJourneyModel());
journeyInstance.UpdateState(state => state.CoursesPublished = publishResult.PublishedCount);
}
return(publishResult);
}
public async Task <IActionResult> CreateSubjectSertificate([FromBody] AddCertificateInput request)
{
request.UserId = (await _currentUserProvider.GetCurrentUser()).Id;
return(await _dispatcher.DispatchAsync(request));
}
public async Task RegisterNew(AuditedEntity entity)
{
var user = await currentUserProvider.GetCurrentUser();
entity.MarkAsNew(user);
}
