public void TestUpdateCourse()
{
var course = UpdateCourse.ClassroomUpdateCourse(this.TestCourse.Id);
Assert.IsNotNull(course, "Course not returned.");
Assert.AreEqual(this.TestCourse.Id, course.Id, "Wrong course returned.");
}
public async Task <ActionResult> UpdateCourse(Guid groupId, Guid courseId, [FromBody] UpdateCourse command)
{
command.GroupId = groupId;
command.Course.Id = courseId;
command.UserId = User.GetUserId();
await _courseService.UpdateCourse(command);
return(Ok());
}
public EntityStateWrapperContainer Modify(UpdateCourse.CommandModel commandModel)
{
CourseID = commandModel.CourseID;
DepartmentID = commandModel.DepartmentID;
Credits = commandModel.Credits;
Title = commandModel.Title;
return new EntityStateWrapperContainer().ModifyEntity(this);
}
public IActionResult PutCourse(int id, UpdateCourse model)
{
var course = db.Courses.Find(id);
course.InjectFrom(model);
db.SaveChanges();
return(Ok());
}
public async Task<ActionResult> Edit(UpdateCourse.CommandModel commandModel)
{
var response = _CourseAppService.UpdateCourse(new UpdateCourse.Request(CurrentPrincipalHelper.Name, commandModel));
if (!response.HasValidationIssues)
return RedirectToAction("Index");
ModelState.AddRange(response.ValidationDetails.AllValidationMessages);
ViewBag.DepartmentID = await CreateDepartmentSelectList(commandModel.DepartmentID);
return View(commandModel);
}
public UpdateCourse.Response Handle(UpdateCourse.Request request)
{
var validationDetails = Validator.ValidateRequest(request);
if (validationDetails.HasValidationIssues)
return new UpdateCourse.Response(validationDetails);
var container = CourseFactory.CreatePartial(request.CommandModel.CourseID).Modify(request.CommandModel);
validationDetails = _Repository.Save(container);
return new UpdateCourse.Response(validationDetails);
}
public async Task UpdateCourse(UpdateCourse command)
{
await _administratorService.ValidateAtLeastModerator(command.UserId, command.GroupId);
var group = await _groupRepository.GetWithCoursesAsync(command.GroupId);
var course = _mapper.Map <Course>(command.Course);
group.UpdateCourse(course);
await _groupRepository.SaveChangesAsync();
}
public void TestInitialize()
{
updateCourse = new UpdateCourse
{
Resource = new CourseData
{
Description = "my text"
}
};
validator = new UpdateCourseIntegrity();
}
public IActionResult Edit(UpdateCourse model)
{
if (ModelState.IsValid)
{
if (courseRepository.UpdateCourse(model) > 0)
{
return(RedirectToAction("Index", "Course"));
}
ModelState.AddModelError("", "System error, please try again later!");
}
var courseEdit = new UpdateCourse();
return(View(courseEdit));
}
public IActionResult Edit(int id)
{
var course = courseRepository.GetCourse(id);
var editCourse = new UpdateCourse();
if (course != null)
{
editCourse.CourseId = course.CourseId;
editCourse.CourseName = course.CourseName;
editCourse.StartDay = course.StartDay;
editCourse.FinishDay = course.FinishDay;
}
return(View(editCourse));
}
public int UpdateCourse(UpdateCourse model)
{
var course = GetCourse(model.CourseId);
if (course == null)
{
return(-1);
}
course.CourseId = model.CourseId;
course.CourseName = model.CourseName;
course.StartDay = model.StartDay;
course.FinishDay = model.FinishDay;
context.Update(course);
return(context.SaveChanges());
}
public ActionResult <Course> Put(int id, [FromBody] UpdateCourse updateCourse)
{
var course = DbContext.Courses.FirstOrDefault(c => c.ID == id);
if (course == null)
{
return(NotFound("Sorry, no course was found with that ID."));
}
else
{
course.Code = updateCourse.Code;
course.Title = updateCourse.Title;
course.LastUpdatedOn = DateTime.Now;
DbContext.SaveChanges();
return(course);
}
}
public void DetectsConcurrencyViolationOnUpdate()
{
var course = Builder <CourseData> .CreateNew()
.With(c => c.Id = 1).And(c => c.RowVersion = new byte[] { 0x01 })
.Build();
_context.Expect(c => c.AsQueryable <Course>())
.Return(new[] { _course }.AsQueryable().TestAsync());
var request = new UpdateCourse(course);
try
{
AssertNoValidationErrors <CourseConcurency, UpdateResource <CourseData, int> >(request);
Assert.Fail("Should have thrown OptimisticConcurrencyException");
}
catch (OptimisticConcurrencyException ex)
{
Assert.AreEqual(ex.Message,
$"Concurrency exception detected for {typeof(Course).FullName} with id 1.");
}
}
public async Task <OneOf <NotFound, Success> > Execute(SqlTransaction transaction, UpdateCourse query)
{
var sql = $@"
UPDATE Pttcd.Courses SET
CourseDescription = @WhoThisCourseIsFor,
EntryRequirements = @EntryRequirements,
WhatYoullLearn = @WhatYoullLearn,
HowYoullLearn = @HowYoullLearn,
WhatYoullNeed = @WhatYoullNeed,
HowYoullBeAssessed = @HowYoullBeAssessed,
WhereNext = @WhereNext,
UpdatedBy = @UpdatedByUserId,
UpdatedOn = @UpdatedOn,
DataIsHtmlEncoded = 0
WHERE CourseId = @CourseId
AND CourseStatus <> {(int)CourseStatus.Archived}
IF @@ROWCOUNT = 0
BEGIN
SELECT 1 AS Result
RETURN
END
DECLARE @CourseRunIds Pttcd.GuidIdTable
INSERT INTO @CourseRunIds
SELECT CourseRunId FROM Pttcd.CourseRuns
WHERE CourseId = @CourseId
AND CourseRunStatus = {(int)CourseStatus.Live}
EXEC Pttcd.RefreshFindACourseIndex @CourseRunIds = @CourseRunIds, @Now = @UpdatedOn
SELECT 0 AS Result";
var paramz = new
{
query.CourseId,
query.WhoThisCourseIsFor,
query.EntryRequirements,
query.WhatYoullLearn,
query.HowYoullLearn,
query.WhatYoullNeed,
query.HowYoullBeAssessed,
query.WhereNext,
UpdatedByUserId = query.UpdatedBy.UserId,
query.UpdatedOn
};
var result = await transaction.Connection.QuerySingleAsync <Result>(sql, paramz, transaction);
if (result == Result.Success)
{
return(new Success());
}
else
{
return(new NotFound());
}
}
public async Task <IActionResult> Update([FromBody] UpdateCourse command)
{
await _mediator.Send(command);
return(NoContent());
}
public async Task <IActionResult> Put(Guid id, UpdateCourse command)
=> await SendAsync(command.Bind(c => c.Id, id),
resourceId : command.Id, resource : "course");
