public ActionResult <UpdateCourseResponse> Update([FromBody] UpdateCourseRequest request)
{
request.CommanderID = User.GetUserId();
var result = _courseService.Update(request);
return(result);
}
public async Task <ApiResult <bool> > UpdateCourse(UpdateCourseRequest request)
{
var course = await _context.Courses.FindAsync(request.Id_Course);
if (course == null)
{
return(new ApiErrorResult <bool>("Không tìm thấy "));
}
if (await _context.Teachers.FindAsync(request.Id_Teacher) == null ||
await _context.Subjects.FindAsync(request.Id_Subject) == null)
{
return(new ApiErrorResult <bool>("Không tìm thấy Giáo viên hoạc Môn học phù hợp "));
}
var subject = await _context.Subjects.FindAsync(request.Id_Subject);
course.Name = request.Name;
course.Id_Subject = request.Id_Subject;
course.Id_Teacher = request.Id_Teacher;
course.DateBegin = request.DateBegin;
course.Semester = request.Semester;
course.SchoolYear = request.SchoolYear;
course.DateEnd = request.DateBegin.AddDays(subject.Lesson * 7).Date;
course.DateUpdate = DateTime.UtcNow.AddHours(7);
await _context.SaveChangesAsync();
return(new ApiSuccessResult <bool>("Cập nhật thành công"));
}
public UpdateCourseResponse Edit(UpdateCourseRequest updateCourseRequest)
{
try
{
var currentCourse = _unitOfWork.CourseRepository.GetById(updateCourseRequest.ID);
if (currentCourse == null)
{
return(new UpdateCourseResponse()
{
IsSuccess = false,
});
}
var newCourse = _mapper.Map(updateCourseRequest, currentCourse);
_unitOfWork.CourseRepository.Update(newCourse);
_unitOfWork.Save();
var courseView = _mapper.Map <CourseView>(newCourse);
return(new UpdateCourseResponse()
{
IsSuccess = true,
CourseView = courseView,
});
}
catch
{
return(new UpdateCourseResponse()
{
IsSuccess = false,
});
}
}
public IHttpActionResult UpdateCourse([FromBody] UpdateCourseRequest request)
{
var response = _manager.UpdateCourse(request);
if (!response.IsSuccessful)
{
return(BadRequest(response.ToString()));
}
return(Ok(response));
}
public static CourseValidationData ConvertToCourseValidationData(this UpdateCourseRequest request)
{
return(new CourseValidationData
{
Id = request.Id,
Title = request.Title,
Description = request.Description,
Price = request.Price
});
}
private void ValidateUpdatedCourse(UpdateCourseRequest request)
{
_validation.NotValidId(request.Id, $"{nameof(request.Id)}");
_validation.NotValidField(request.Title, 100, $"{nameof(request.Title)}");
_validation.NotValidField(request.Description, 500, $"{nameof(request.Description)}");
_validation.NotValidPrice(request.Price, $"{nameof(request.Price)}");
}
public HttpResponseMessage UpdateCourse([FromBody] UpdateCourseRequest request)
{
var response = _service.UpdateCourse(request);
if (response)
{
return(Request.CreateResponse <bool>(HttpStatusCode.OK, response));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Cannot update course"));
}
}
public bool UpdateCourse(UpdateCourseRequest request)
{
var originalCourse = Collection.FirstOrDefault(x => x.CourseId == request.CourseId);
if (originalCourse == null)
{
return(false);
}
request.Map(originalCourse);
DataWriter.WriterData(originalCourse, nameof(Course));
return(true);
}
public void UpdateCourseWithNoExistingId()
{
var request = new UpdateCourseRequest
{
Id = 1444,
Title = "Python and Machine Learning",
Description = "A basic course with most famous machine learning libraries in Python",
Price = 11,
};
var ex = Xunit.Assert.Throws <Exception>(() => service.UpdateCourse(request));
Xunit.Assert.Equal("The Course is not updated", ex.Message);
}
public void UpdateCourse()
{
var request = new UpdateCourseRequest
{
Id = 444,
Title = "Python and Machine Learning",
Description = "A basic course with most famous machine learning libraries in Python",
Price = 11,
};
var res = service.UpdateCourse(request);
Xunit.Assert.True(res);
}
public async Task <IActionResult> Update(UpdateCourseRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _courseService.UpdateCourse(request);
if (result.IsSuccessed == false)
{
return(BadRequest(result));
}
return(Ok(result));
}
public IResult UpdateCourse(UpdateCourseRequest request)
{
ICollection <ValidationResult> results = new List <ValidationResult>();
if (!request.Validate(out results))
{
return(new Result(false, results.First().ErrorMessage));
}
if (!_uow.Courses.UpdateCourse(request))
{
return(new Result(false, "Could Not Update Course"));
}
_uow.SaveChanges();
return(new Result(true, "Course Updated Successfully"));
}
public async Task UpdateAsync(UpdateCourseRequest request)
{
if (request == null)
{
throw new ArgumentException("Request should not be empty");
}
var entity = await _coursesRepository.GetByIdAsync(request.CourseId);
if (entity == null)
{
throw new ArgumentException($"Course with id:{request.CourseId} does not exist.");
}
entity.Name = request.Name;
await _coursesRepository.UpdateAsync(entity);
}
public async Task <ActionResult> Put([FromBody] UpdateCourseRequest request, string code)
{
try {
var command = _mapper.Map <UpdateCourseCommand>(request);
command.Code = code;
await _commandHandler.HandleAsync(command);
var query = new GetCourseDetailQuery {
Code = code
};
var course = await _queryHandler.HandleAsync(query);
return(Ok(course));
} catch (EntityNotFoundException ex) {
return(NotFound(ex.Message));
} catch (Exception) {
return(BadRequest());
}
}
public async Task <IActionResult> UpdateCourseConfiguration([FromBody] UpdateCourseRequest request)
{
var settings = _settingsRepository.GetAll().Single();
var term = await _usosService.GetCurrentTerm(HttpContext.BuildOAuthRequest());
var courseExists = await _usosService.CourseExists(HttpContext.BuildOAuthRequest(), request.CourseCode, term.Id);
if (courseExists)
{
settings.CourseCode = request.CourseCode;
await _settingsRepository.UpdateAsync(settings);
return(new OkResult());
}
else
{
return(new BadRequestObjectResult("Kurs nie istnieje."));
}
}
public CourseResponse UpdateCourse(UpdateCourseRequest request)
{
var response = new UpdateCourseRequestValidator().Validate(request).ToResponse <CourseResponse>();
if (!response.IsSuccessful)
{
return(response);
}
try
{
var courseToUpdate = _coursesRepository.GetCourseById(request.OldCourseId);
if (courseToUpdate == null)
{
response.IsSuccessful = false;
response.Errors.Add("Course to update not found");
_logger.LogMessage("Course to update is null");
return(response);
}
courseToUpdate.CourseName = request.CourseName;
courseToUpdate.CourseDescription = request.CourseDescription;
courseToUpdate.Semester = request.Semester;
var requestProgramsCourses = request.Programs
.Select(x => new ProgramsCourses
{
Course = courseToUpdate,
ProgramId = x.ProgramId,
IsMandatory = x.IsMandatory,
}).ToList();
response.Course = _coursesRepository.UpdateCourse(courseToUpdate, requestProgramsCourses, request.Prerequisites);
}
catch (Exception ex)
{
response.IsSuccessful = false;
response.Errors.Add("Error while trying to update course");
_logger.LogException(ex);
}
return(response);
}
public bool UpdateCourse(UpdateCourseRequest request)
{
string sql = @"Update Course SET Title=@Title,Description=@Description,Price=@Price Where Id=@Id";
int result;
var parameters = new { request.Id, request.Title, request.Description, request.Price };
using (var con = GetSqlConnection())
{
using (var transaction = con.BeginTransaction())
{
if (!CheckIfCourseNotExists(request.Id))
{
result = con.Execute(sql, parameters, transaction: transaction);
}
else
{
throw new Exception("The Course is not updated");
}
transaction.Commit();
}
}
return(result == 1);
}
public bool UpdateCourse(UpdateCourseRequest request)
{
ValidateUpdatedCourse(request);
return(_dbService.UpdateCourse(request));
}
