public async Task PublishReturnsCorrectViewModelWhenUserIsAuthorized()
{
const int campaignId = 100;
var viewModel = new PublishViewModel {
Id = campaignId
};
var mediator = new Mock <IMediator>();
mediator.Setup(mock => mock.SendAsync(It.Is <PublishViewModelQuery>(c => c.CampaignId == campaignId))).ReturnsAsync(viewModel);
mediator.Setup(x => x.SendAsync(It.IsAny <AuthorizableCampaignQuery>())).ReturnsAsync(new FakeAuthorizableCampaign(true, false, false, false));
var sut = new CampaignController(mediator.Object, null);
var view = (ViewResult)await sut.Publish(campaignId);
var resultViewModel = (PublishViewModel)view.ViewData.Model;
Assert.Equal(resultViewModel.Id, campaignId);
}
public async Task PublishConfirmedRedirectsToCorrectActionWithCorrectRouteValuesWhenUserIsAuthorized()
{
var viewModel = new PublishViewModel {
Id = 100, UserIsOrgAdmin = true
};
var mediator = new Mock <IMediator>();
mediator.Setup(x => x.SendAsync(It.IsAny <AuthorizableCampaignQuery>())).ReturnsAsync(new FakeAuthorizableCampaign(false, true, false, false));
var sut = new CampaignController(mediator.Object, null);
var routeValues = new Dictionary <string, object> {
["area"] = "Admin"
};
var result = await sut.PublishConfirmed(viewModel) as RedirectToActionResult;
Assert.Equal(nameof(CampaignController.Index), result.ActionName);
Assert.Equal(result.RouteValues, routeValues);
}
public async Task PublishConfirmedRedirectsToCorrectActionWithCorrectRouteValuesWhenUserIsOrgAdmin()
{
const int organizationId = 1;
var viewModel = new PublishViewModel {
Id = 100, UserIsOrgAdmin = true
};
var sut = new CampaignController(Mock.Of <IMediator>(), null);
sut.MakeUserAnOrgAdmin(organizationId.ToString());
var routeValues = new Dictionary <string, object> {
["area"] = "Admin"
};
var result = await sut.PublishConfirmed(viewModel) as RedirectToActionResult;
Assert.Equal(result.ActionName, nameof(CampaignController.Index));
Assert.Equal(result.RouteValues, routeValues);
}
public ActionResult PublishAll(PublishViewModel model)
{
model.ServerErrorMessage = string.Empty;
string targetTcmIdToPublish = "tcm:0-2-65538";
ReadOptions ro = new ReadOptions {
LoadFlags = LoadFlags.None
};
try
{
model.ComponentsList = (List <Component>)Session["ComponentsListPublish"];
PublishInstructionData instruction = new PublishInstructionData
{
ResolveInstruction = new ResolveInstructionData()
{
IncludeChildPublications = false
},
RenderInstruction = new RenderInstructionData()
};
Client.Publish(model.ComponentsList.Select(x => x.Id).ToArray(), instruction, new[] { targetTcmIdToPublish }, PublishPriority.Normal, ro);
model.IsSuccess = true;
model.IsPublishCompleted = true;
}
catch (Exception ex)
{
log.Error("PublishAll - Post Method Error", ex);
}
this.SetModel <PublishViewModel>(model);
return(Redirect("/Home/Publish?success=true"));
}
public async Task <ActionResult> ListPublish(TakeRateParameters parameters)
{
TakeRateParametersValidator
.ValidateTakeRateParameters(DataContext, parameters, TakeRateParametersValidator.NoValidation);
var filter = new TakeRateFilter()
{
FilterMessage = parameters.FilterMessage,
Action = TakeRateDataItemAction.Publish
};
filter.InitialiseFromJson(parameters);
var results = await PublishViewModel.GetModel(DataContext, filter);
var jQueryResult = new JQueryDataTableResultModel(results);
foreach (var result in results.AvailableFiles.CurrentPage)
{
jQueryResult.aaData.Add(result.ToJQueryDataTableResult());
}
return(Json(jQueryResult));
}
public async Task <ActionResult> PublishPage(TakeRateParameters parameters)
{
var filter = TakeRateFilter.FromTakeRateParameters(parameters);
return(View(await PublishViewModel.GetModel(DataContext, filter)));
}
public async Task <IActionResult> Index(PublishMode publishMode, string notificationTitle, Guid?courseId, Guid?courseRunId, bool fromBulkUpload)
{
int?UKPRN = Session.GetInt32("UKPRN");
if (!UKPRN.HasValue)
{
return(RedirectToAction("Index", "Home", new { errmsg = "Please select a Provider." }));
}
var coursesByUKPRN = (await _courseService.GetYourCoursesByUKPRNAsync(new CourseSearchCriteria(UKPRN))).Value;
// Only display courses that have Lars and Qualification titles
var courses = coursesByUKPRN.Value
.SelectMany(o => o.Value)
.SelectMany(i => i.Value)
.Where(c => !string.IsNullOrWhiteSpace(c.LearnAimRef) && !string.IsNullOrWhiteSpace(c.QualificationCourseTitle))
.ToList();
courses = GetErrorMessages(courses, ValidationMode.MigrateCourse).ToList();
PublishViewModel vm = new PublishViewModel();
switch (publishMode)
{
case PublishMode.Migration:
if (courses.Where(x => x.CourseRuns.Any(cr => cr.RecordStatus == RecordStatus.MigrationPending || cr.RecordStatus == RecordStatus.MigrationReadyToGoLive) && x.IsValid == false).Any())
{
vm.PublishMode = PublishMode.Migration;
var migratedCourses = courses.Where(x => x.CourseRuns.Any(cr => cr.RecordStatus == RecordStatus.MigrationPending || cr.RecordStatus == RecordStatus.MigrationReadyToGoLive));
var migratedCoursesWithErrors = GetErrorMessages(migratedCourses, ValidationMode.MigrateCourse).ToList();
vm.NumberOfCoursesInFiles = migratedCoursesWithErrors.SelectMany(s => s.CourseRuns.Where(cr => cr.RecordStatus == RecordStatus.MigrationPending ||
cr.RecordStatus == RecordStatus.MigrationReadyToGoLive)).Count();
vm.Courses = migratedCoursesWithErrors.OrderBy(x => x.QualificationCourseTitle);
vm.AreAllReadyToBePublished = CheckAreAllReadyToBePublished(migratedCoursesWithErrors, PublishMode.Migration);
vm.Venues = VenueHelper.GetVenueNames(vm.Courses, _cosmosDbQueryDispatcher).Result;
break;
}
else
{
return(View("../Migration/Complete/index"));
}
case PublishMode.BulkUpload:
vm.PublishMode = PublishMode.BulkUpload;
var bulkUploadedCourses = courses.Where(x => x.CourseRuns.Any(cr => cr.RecordStatus == RecordStatus.BulkUploadPending || cr.RecordStatus == RecordStatus.BulkUploadReadyToGoLive)).ToList();
vm.NumberOfCoursesInFiles = bulkUploadedCourses.SelectMany(s => s.CourseRuns.Where(cr => cr.RecordStatus == RecordStatus.BulkUploadPending || cr.RecordStatus == RecordStatus.BulkUploadReadyToGoLive)).Count();
vm.Courses = bulkUploadedCourses.OrderBy(x => x.QualificationCourseTitle);
vm.AreAllReadyToBePublished = CheckAreAllReadyToBePublished(bulkUploadedCourses, PublishMode.BulkUpload);
vm.Courses = GetErrorMessages(vm.Courses, ValidationMode.BulkUploadCourse);
vm.Venues = VenueHelper.GetVenueNames(vm.Courses, _cosmosDbQueryDispatcher).Result;
break;
case PublishMode.DataQualityIndicator:
vm.PublishMode = PublishMode.DataQualityIndicator;
var validCourses = courses.Where(x => x.IsValid && ((int)x.CourseStatus & (int)RecordStatus.Live) > 0);
var results = _courseService.CourseValidationMessages(validCourses, ValidationMode.DataQualityIndicator).Value.ToList();
var invalidCoursesResult = results.Where(c => c.RunValidationResults.Any(cr => cr.Issues.Count() > 0));
var invalidCourses = invalidCoursesResult.Select(c => (Course)c.Course).ToList();
var invalidCourseRuns = invalidCourses.Select(cr => cr.CourseRuns.Where(x => x.StartDate < DateTime.Today));
List <Course> filteredList = new List <Course>();
var allRegions = _courseService.GetRegions().RegionItems;
foreach (var course in invalidCourses)
{
var invalidRuns = course.CourseRuns.Where(x => x.StartDate < DateTime.Today);
if (invalidRuns.Any())
{
course.CourseRuns = invalidRuns;
filteredList.Add(course);
}
}
if (invalidCourseRuns.Count() == 0 && courseId != null && courseRunId != null)
{
return(BadRequest());
}
vm.NumberOfCoursesInFiles = invalidCourses.Count();
vm.Courses = filteredList.OrderBy(x => x.QualificationCourseTitle);
vm.Venues = VenueHelper.GetVenueNames(vm.Courses, _cosmosDbQueryDispatcher).Result;
vm.Regions = allRegions;
break;
}
vm.NotificationTitle = notificationTitle;
vm.CourseId = courseId;
vm.CourseRunId = courseRunId;
if (vm.AreAllReadyToBePublished)
{
if (publishMode == PublishMode.BulkUpload)
{
return(RedirectToAction("CoursesPublishFile", "Bulkupload", new { NumberOfCourses = courses.SelectMany(s => s.CourseRuns.Where(cr => cr.RecordStatus == RecordStatus.BulkUploadReadyToGoLive)).Count() })
.WithProviderContext(_providerContextProvider.GetProviderContext(withLegacyFallback: true)));
}
}
else
{
if (publishMode == PublishMode.BulkUpload)
{
var message = "";
if (fromBulkUpload)
{
var invalidCourseCount = courses.Where(x => x.IsValid == false).Count();
var bulkUploadedPendingCourses = (courses.SelectMany(c => c.CourseRuns)
.Where(x => x.RecordStatus == RecordStatus.BulkUploadPending)
.Count());
message = "Your file contained " + bulkUploadedPendingCourses + @WebHelper.GetErrorTextValueToUse(bulkUploadedPendingCourses) + ". You must resolve all errors before your courses information can be published.";
return(RedirectToAction("WhatDoYouWantToDoNext", "Bulkupload", new { message = message }));
}
}
}
return(View("Index", vm));
}
public async Task <IActionResult> Index(PublishViewModel vm)
{
PublishCompleteViewModel CompleteVM = new PublishCompleteViewModel();
int?sUKPRN = Session.GetInt32("UKPRN");
int UKPRN;
if (!sUKPRN.HasValue)
{
return(RedirectToAction("Index", "Home", new { errmsg = "Please select a Provider." }));
}
else
{
UKPRN = sUKPRN ?? 0;
}
CompleteVM.NumberOfCoursesPublished = vm.NumberOfCoursesInFiles;
switch (vm.PublishMode)
{
case PublishMode.Migration:
// Publish migrated courses directly, NO archiving
var resultPublishMigratedCourses = await _courseService.ChangeCourseRunStatusesForUKPRNSelection(UKPRN, (int)RecordStatus.MigrationReadyToGoLive, (int)RecordStatus.Live);
CompleteVM.Mode = PublishMode.Migration;
if (resultPublishMigratedCourses.IsSuccess)
{
return(View("Complete", CompleteVM));
}
else
{
return(RedirectToAction("Index", "Home", new { errmsg = "Publish All Migration-PublishCourses Error" }));
}
case PublishMode.BulkUpload:
await _courseService.ChangeCourseRunStatusesForUKPRNSelection(UKPRN, (int)RecordStatus.MigrationPending, (int)RecordStatus.Archived);
await _courseService.ChangeCourseRunStatusesForUKPRNSelection(UKPRN, (int)RecordStatus.MigrationReadyToGoLive, (int)RecordStatus.Archived);
//Archive any existing courses
var resultArchivingCourses = await _courseService.ChangeCourseRunStatusesForUKPRNSelection(UKPRN, (int)RecordStatus.Live, (int)RecordStatus.Archived);
if (resultArchivingCourses.IsSuccess)
{
// Publish courses
var resultPublishBulkUploadedCourses = await _courseService.ChangeCourseRunStatusesForUKPRNSelection(UKPRN, (int)RecordStatus.BulkUploadReadyToGoLive, (int)RecordStatus.Live);
CompleteVM.Mode = PublishMode.BulkUpload;
if (resultPublishBulkUploadedCourses.IsSuccess)
{
return(View("Complete", CompleteVM));
}
else
{
return(RedirectToAction("Index", "Home", new { errmsg = "Publish All BulkUpload-PublishCourses Error" }));
}
}
else
{
return(RedirectToAction("Index", "Home", new { errmsg = "Publish All BulkUpload-ArchiveCourses Error" }));
}
default:
return(RedirectToAction("Index", "Home", new { errmsg = "Publish All BulkUpload/Migration Error" }));
}
}
public IViewComponentResult Invoke(PublishViewModel model)
{
return(View("~/ViewComponents/PublishCourses/Publish/Default.cshtml", model));
}
public ActionResult Publish()
{
PublishViewModel model = new PublishViewModel();
return(View(model));
}
public PublishTheseus()
{
InitializeComponent();
DataContext = new PublishViewModel();
}
