public async Task <IActionResult> Update(int id, UpdateCourseCommand command)
{
command.CourseId = id;
await Mediator.Send(command);
return(NoContent());
}
public async Task <IActionResult> EditPost(UpdateCourseCommand command)
{
try
{
await Mediator.Send(command);
return(RedirectToAction(nameof(Index)));
}
catch (DbUpdateException)
{
//Log the error (uncomment ex variable name and write a log.)
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists, " +
"see your system administrator.");
await PopulateDepartmentsDropDownList(command.DepartmentID);
return(View(new EditCourseVM
{
CourseID = command.CourseID.Value,
Title = command.Title,
Credits = command.Credits,
DepartmentID = command.DepartmentID,
}));
}
}
public UpdateCourseService(UpdateCourseCommand courseCommand, ICourseRepository courseRepository)
: base(courseCommand)
{
_courseRepository = courseRepository;
_courseCommand = courseCommand;
Run();
}
public async Task WhenIUpdateAnInvalidCourse()
{
_command = new UpdateCourseCommand {
CourseId = "invalidCourseId", Title = "course title"
};
_response = await _client.PutAsync(BaseUrl, Utilities.GetRequestContent(_command));
}
public async Task <Unit> Handle(UpdateCourseCommand request, CancellationToken cancellationToken)
{
await courseWriteOnlyRepository.Update(
Course.CreateToUpdate(request.Id, request.Name, request.Description, request.Price, request.Video)
);
return(await Unit.Task);
}
public void EmptyOrNullTitle_ShouldHaveError(string name)
{
var command = new UpdateCourseCommand {
Title = name
};
_sut.ShouldHaveValidationErrorFor(x => x.Title, command);
}
public void TitleLengthOver60_ShouldHaveError()
{
var command = new UpdateCourseCommand {
Title = new string('*', 61)
};
_sut.ShouldHaveValidationErrorFor(x => x.Title, command);
}
public async Task WhenIUpdateACourseWithATitleLengthOverCharacters(int maximumTitleLength)
{
_command = new UpdateCourseCommand {
CourseId = "courseId", Title = new string('*', maximumTitleLength + 1)
};
_response = await _client.PutAsync(BaseUrl, Utilities.GetRequestContent(_command));
}
public async Task WhenIUpdateACourseWithAnEmptyOrANullTitle(string title)
{
_command = new UpdateCourseCommand {
CourseId = "courseId", Title = title
};
_response = await _client.PutAsync(BaseUrl, Utilities.GetRequestContent(_command));
}
public void EmptyOrNullCourseId_ShouldHaveError(string courseId)
{
var command = new UpdateCourseCommand {
CourseId = courseId
};
_sut.ShouldHaveValidationErrorFor(x => x.CourseId, command);
}
public void SubtitleLengthOver120_ShouldHaveError()
{
var command = new UpdateCourseCommand {
Subtitle = new string('*', 121)
};
_sut.ShouldHaveValidationErrorFor(x => x.Subtitle, command);
}
public void CourseLearnedSkillLengthOver150_ShouldHaveError()
{
var command = new UpdateCourseCommand {
CourseLearnedSkills = new List <string> {
new string('*', 151)
}
};
_sut.ShouldHaveValidationErrorFor(x => x.CourseLearnedSkills, command);
}
public async Task <IActionResult> UpdateCourse(
[FromRoute] string id,
[FromBody] UpdateCourseCommand command,
[FromServices] IMediator mediator)
{
command.AddCourseId(id);
var result = await mediator.Send(command);
return(StatusCode(200, result));
}
public async Task WhenIUpdateAPublishedCourse()
{
var course = new Course("course", _instructorId, DateTime.Now);
course.ChangeCourseStatus(PublishedStatus.Instance);
_factory.CreateCourse(course);
_command = new UpdateCourseCommand {
CourseId = course.Id, Title = "course title"
};
_response = await _client.PutAsync(BaseUrl, Utilities.GetRequestContent(_command));
}
public async Task Update(CourseDto courses)
{
var updateCourseCommand = new UpdateCourseCommand
{
Id = courses.Id,
Name = courses.Name,
Description = courses.Description,
ImageUrl = courses.ImageUrl
};
await _bus.Send(updateCourseCommand);
}
public async Task WhenIUpdateACourseWithASkillLengthOverCharacters(int maximumSkillLength)
{
_command = new UpdateCourseCommand
{
CourseId = "courseId",
Title = "Course title",
CourseLearnedSkills = new List <string> {
new string('*', maximumSkillLength + 1)
}
};
_response = await _client.PutAsync(BaseUrl, Utilities.GetRequestContent(_command));
}
public async Task <ActionResult <CourseDto> > Update(int id, UpdateCourseCommand command)
{
if (id != command.Id)
{
return(BadRequest());
}
var result = await _mediator.Send(command);
return(Ok(result));
}
public async Task <IActionResult> UpdateCourse(UpdateCourseCommand command)
{
Request.Headers.TryGetValue("Authorization", out var token);
string role = await AuthHelper.GetRoleFromTokenAsync(token);
if (role != "admin")
{
return(StatusCode(401, new { Error = "Unauthorized" }));
}
BaseResponse <int> result = (BaseResponse <int>) await Mediator.Send(command);
return(!result.Success ? StatusCode(result.Error.StatusCode, result.Error) : Ok(result));
}
public void GivenADraftCourseWith(Table table)
{
var course = new Course("old title", _instructorId, DateTime.Now);
course.UpdateSubtitle("old subtitle");
course.UpdateDescription("old description");
course.AddLearnedSkill("old skill 1");
course.AddLearnedSkill("old skill 2");
_factory.CreateCourse(course);
_command = new UpdateCourseCommand {
CourseId = course.Id
};
}
public async Task Should_throw_not_found_exception()
{
var updateCourseCommand = new UpdateCourseCommand()
{
Id = Guid.NewGuid(),
Code = 1,
Name = "Course 1",
Description = "Test"
};
var updateCourseCommandHandler = new UpdateCourseCommandHandler(this.autoMapper, this.context);
await Assert.ThrowsAsync <NotFoundException>(() => updateCourseCommandHandler.Handle(updateCourseCommand, CancellationToken.None));
}
public void SetUp()
{
_service = new Mock <IUpdateCourseService>();
_commonService = new Mock <ICoursesCommonService>();
_unitOfWork = new Mock <IUnitOfWork>();
_command = new UpdateCourseCommand()
{
CourseId = "courseId"
};
_sut = new UpdateCourseCommandHandler(_service.Object, _commonService.Object, _unitOfWork.Object);
_courseToUpdate = new Course("title", "creatorId", DateTime.Now);
_commonService.Setup(x => x.GetCourseFromRepo(_command.CourseId, default))
.ReturnsAsync(_courseToUpdate);
}
public async Task <ValidationResult> Handle(UpdateCourseCommand request, CancellationToken cancellationToken)
{
if (!request.IsValid())
{
return(request.ValidationResult);
}
var course = new Course(request.Id, request.Capacity, request.NumberOfStudents);
_courseRepository.Update(course);
await Bus.RaiseEvent(new CourseRegisteredEvent(request.Id, request.Capacity, request.NumberOfStudents));
return(await Commit(_courseRepository.UnitOfWork));
}
public async Task <GenericCommandResult> Handle(UpdateCourseCommand command, CancellationToken cancellationToken)
{
command.Validate();
if (command.Invalid)
{
return(new GenericCommandResult(false, "Ocorreu um erro", command.Notifications));
}
var course = _courseRepository.GetById(command.CourseId);
course.UpdateName(command.Name);
_courseRepository.Update(course);
return(new GenericCommandResult(true, "Curso atualizado com sucesso", (DTOs.Course)course));
}
public void ValidParameters_ShouldNotHaveErrors()
{
var command = new UpdateCourseCommand
{
CourseId = "courseId", Description = "description", Title = "course title",
Subtitle = "course subtitle",
CourseLearnedSkills = new List <string> {
"courseSkill1"
}
};
_sut.ShouldNotHaveValidationErrorFor(x => x.CourseId, command);
_sut.ShouldNotHaveValidationErrorFor(x => x.Title, command);
_sut.ShouldNotHaveValidationErrorFor(x => x.Subtitle, command);
_sut.ShouldNotHaveValidationErrorFor(x => x.Description, command);
_sut.ShouldNotHaveValidationErrorFor(x => x.CourseLearnedSkills, command);
}
public ICommandResult Handle(UpdateCourseCommand command)
{
//Fail Fast Validation
command.Validate();
if (command.Invalid)
{
return(new GenericCommandResult(false, Messages.Ex_ExceptionGeneric, command.Notifications));
}
var course = _repository.GetById(command.Id);
course.UpdateCourse(command.Title, command.Url, command.Value, command.Stars, command.RecomendedByEid);
_repository.Update(course);
return(new GenericCommandResult(true, Messages.Act_Update, course));
}
public async Task WhenIUpdateACourseBelongingToAnOtherOrganization()
{
var otherOrganization = new Organization("other organization", SubscriptionPlans.Free);
_factory.CreateOrganization(otherOrganization);
var otherInstructor = new User("*****@*****.**", otherOrganization.Id);
_factory.CreateUser(otherInstructor);
var course = new Course("course", otherInstructor.Id, DateTime.Now);
_factory.CreateCourse(course);
_command = new UpdateCourseCommand {
CourseId = course.Id, Title = "course title"
};
_response = await _client.PutAsync(BaseUrl, Utilities.GetRequestContent(_command));
}
public async Task UpdateCourseTest_Should_Return_Id()
{
//Arrange
var request = new UpdateCourseCommand
{
Id = 1,
Name = "Math",
Price = 5000,
StartTime = new DateTime(2021, 02, 02, 10, 00, 00),
EndTime = new DateTime(2021, 02, 04, 12, 00, 00),
};
var handler = new UpdateCourseHandler(_mapper, _fakeRepository);
//Act
var id = await handler.Handle(request, new CancellationToken());
//Assert
Assert.AreEqual(id, 1);
}
public async Task HandleAsync(UpdateCourseCommand command)
{
var course = await _repository.GetByCode(command.Code);
if (course == null)
{
throw new EntityNotFoundException($"Course with code '{command.Code}' Not Found.");
}
if (!string.IsNullOrEmpty(command.Name))
{
course.Name = command.Name;
}
if (!string.IsNullOrEmpty(command.Description))
{
course.Description = command.Description;
}
await _repository.Update(course);
await _commandStoreService.PushAsync(command);
}
protected void Reg_Mat(object sender, EventArgs e)
{
grades = new Grade();
grades.Id = Int32.Parse(list_grades.SelectedValue);
grades.Name = list_grades.DataTextField;
string oldid = Session["Id_mat"].ToString();
course = new Course();
course.Id = name.Value.Substring(0, 4) + list_grades.SelectedValue + DateTime.Now.Year.ToString();
course.Name = name.Value;
course.Description = desc.Value;
course.Grade = grades;
UpdateCourseCommand cmd = new UpdateCourseCommand(course, oldid);
cmd.Execute();
if (course.Code == 201)
{
ClientScript.RegisterClientScriptBlock(this.GetType(), "random", "alertme_succ()", true);
}
else
{
ClientScript.RegisterClientScriptBlock(this.GetType(), "random", "alertme()", true);
}
}
public async Task Should_update_student()
{
// create course
var createCourseCommand = new CreateCourseCommand()
{
Id = Guid.NewGuid(),
Code = 1,
Name = "Course 1",
Description = "Test"
};
var createCourseCommandHandler = new CreateCourseCommandHandler(this.autoMapper, this.context);
var result = await createCourseCommandHandler.Handle(createCourseCommand, CancellationToken.None);
result.ShouldBe(true);
var updateCourseCommand = new UpdateCourseCommand()
{
Id = createCourseCommand.Id,
Code = 1,
Name = "Course 2",
Description = "Test"
};
var updateCourseCommandHandler = new UpdateCourseCommandHandler(this.autoMapper, this.context);
result = await updateCourseCommandHandler.Handle(updateCourseCommand, CancellationToken.None);
result.ShouldBe(true);
var dbCourse = await this.context.Course.FirstOrDefaultAsync(s => s.Id == updateCourseCommand.Id);
dbCourse.ShouldNotBeNull();
dbCourse.Name.ShouldBe(updateCourseCommand.Name);
}