public ActionResult <CourseDto> CreateCourseForAuthor(
[FromRoute] Guid authorId,
[FromBody] CreateCourseDto courseDto
)
{
if (!AuthorRepository.Exists(authorId))
{
return(NotFound());
}
if (courseDto == null)
{
return(BadRequest());
}
var course = CourseMapper.ToCourse(courseDto, authorId);
CourseRepository.Create(course);
_unitOfWork.Commit();
return(CreatedAtRoute(
"GetCourseForAuthor",
new { authorId, id = course.Id },
CourseMapper.ToCourseDto(course)
));
}
public async Task <CourseDto> GetCourse(int id)
{
var course = await _unitOfWork.CourseRepository.GetByIdAsync(id) ??
throw new EntityNotFoundException();
return(CourseMapper.ToDto(course));
}
public async Task <Course> GetCourseByTestIdAsync(int testId)
{
var courseMapper = new CourseMapper(_languageRepository, _mapper);
var dbCourse = await _courseRepository.GetCourseByTestIdAsync(testId);
return(await courseMapper.MapDbCourse(dbCourse));
}
public async Task UpdateCourse(CourseDto courseDto)
{
var course = CourseMapper.FromDto(courseDto);
_unitOfWork.CourseRepository.Update(course);
await _unitOfWork.SaveAsync();
}
public ActionResult GetSearchAndCompareCourse(string providerCode, string courseCode)
{
var name = this.User.Identity.Name;
if (string.IsNullOrWhiteSpace(providerCode) || string.IsNullOrWhiteSpace(courseCode))
{
return(BadRequest());
}
var courseMapper = new CourseMapper();
var providerData = _dataService.GetProviderForUser(name, providerCode);
var orgEnrichmentData = _enrichmentservice.GetProviderEnrichment(providerCode, name);
var courseData = _dataService.GetCourseForUser(name, providerCode, courseCode);
var courseEnrichmentData = _enrichmentservice.GetCourseEnrichment(providerCode, courseCode, name);
if (providerData == null || courseData == null)
{
return(NotFound());
}
var course = courseMapper.MapToSearchAndCompareCourse(
providerData,
courseData,
orgEnrichmentData?.EnrichmentModel,
courseEnrichmentData?.EnrichmentModel);
return(Ok(course));
}
public CourseDto GetCourseById(int id)
{
var course = _courseRepository.Find(id);
var result = CourseMapper.CourseToCourseDto(course);
return(result);
}
public IActionResult Edit(int id)
{
var model = _repository.GetCourseById(id);
var viewModel = CourseMapper.SerializeCourse(model);
return(PartialView("_CourseEditModelPartial", viewModel));
}
public async Task CreateAsync(CourseModel model)
{
Course course = CourseMapper.MapCourseModelToCourse(model);
course.Id = new Guid().ToString();
await _courseRepository.CreateAsync(course);
}
public int Add(DTOCourse dtoCourse)
{
Course entytiCourse = CourseMapper.GetEntityCourse(dtoCourse);
UnitOfWork.CourseRepository.Add(entytiCourse);
UnitOfWork.Commit();
return(entytiCourse.Id);
}
public List <CourseDto> GetCourseStudents(int id)
{
var student = _studentRepository.Find(id);
var courses = _courseStudentRepository.FindByIncluding(t => t.StudentId == student.Id, t => t.Course);
var result = courses.Select(cs => CourseMapper.CourseToCourseDto(cs.Course)).ToList();
return(result);
}
public async Task <ICollection <Course> > GetCoursesByNameAsync(string coursename)
{
var dbCourses = await _courseRepository
.GetCoursesByNameAsync(coursename);
var courseMapper = new CourseMapper(_languageRepository, _mapper);
return(await courseMapper.MapDbCourseCollection(dbCourses));
}
public async Task <ICollection <Course> > GetCoursesByLanguageCodeAsync(string known, string learning)
{
var dbCourses = await _courseRepository
.GetCoursesByLanguageCodeAsync(known, learning);
var courseMapper = new CourseMapper(_languageRepository, _mapper);
return(await courseMapper.MapDbCourseCollection(dbCourses));
}
public async Task <int> CreateCourse(CourseDto courseDto)
{
var course = CourseMapper.FromDto(courseDto);
await _unitOfWork.CourseRepository.InsertAsync(course);
await _unitOfWork.SaveAsync();
return(course.Id);
}
public int Edit(DTOCourse dtoCourse)
{
Course entityCourse = CourseMapper.GetEntityCourse(dtoCourse);
UnitOfWork.CourseRepository.Update(entityCourse);
UnitOfWork.Commit();
return(entityCourse.Id);
}
public IActionResult Edit(CourseViewModel model)
{
if (ModelState.IsValid)
{
var course = CourseMapper.SerializeCourse(model);
_repository.UpdateCourse(course);
return(PartialView("_CourseSuccessPartial"));
}
return(PartialView("_CourseEditModelPartial", model));
}
public IActionResult Create(CourseViewModel model)
{
if (ModelState.IsValid)
{
var courses = CourseMapper.SerializeCourse(model);
_repository.CreateCourse(courses);
return(PartialView("_CourseSuccessPartial"));
}
return(PartialView("_CourseCreateModelPartial", model));
}
/// <summary>
/// Lista todos los cursos incluyendo el ciclo formativo
/// al que pertenecen
/// </summary>
/// <returns>
/// Retorna una lista de objetos Course que contienen
/// cada uno un objeto Cycle
/// </returns>
public async Task <List <Course> > GetAll()
{
List <CourseEntity> courseEntities = await _courseRepository.GetAll();
List <Course> courses = courseEntities
.Select(c => CourseMapper.MapIncludingCycle(c))
.ToList();
return(courses);
}
public List <CourseDAO> getStudentSchedule(int studentid)
{
var data = new List <CourseDAO>();
foreach (var course in registrar.GetStudentSchedule(studentid))
{
data.Add(CourseMapper.MapToCourseDAO(course));
}
return(data);
}
public List <CourseDAO> GetCourses()
{
var data = new List <CourseDAO>();
foreach (var course in GetData.GetCourses())
{
data.Add(CourseMapper.MapToCourseDAO(course));
}
return(data);
}
public List <CourseDAO> GetCourses()
{
var c = new List <CourseDAO>();
foreach (var courses in ef.GetCourses())
{
c.Add(CourseMapper.MapToCourseDAO(courses));
}
return(c);
}
public List <DTOCourse> GetAll()
{
List <DTOCourse> Courses = new List <DTOCourse>();
foreach (Course item in UnitOfWork.CourseRepository.GetAll())
{
Courses.Add(CourseMapper.GetDTOCourse(item));
}
return(Courses);
}
public List <CourseDTO> getCourses()
{
List <CourseDTO> courses = new List <CourseDTO>();
foreach (var item in rsc.getCourses())
{
var temp = courseFactory.Create();
var s = new CourseMapper().mapToCourseDTO(item, temp);
courses.Add(s);
}
return(courses);
}
public List <CourseDTO> listStudentSchedule(StudentDTO student)
{
List <CourseDTO> list = new List <CourseDTO>();
foreach (var item in rsc.listStudentSchedule(new StudentMapper().mapToStudentDAO(student)))
{
var createdcourse = courseFactory.Create();
var mappedcourse = new CourseMapper().mapToCourseDTO(item, createdcourse);
list.Add(mappedcourse);
}
return(list);
}
public async Task <ICollection <Course> > GetEnrolledCoursesAsync(int userId)
{
var user = await _userRepository
.GetUserByIdAsync(userId);
var dbCourses = await _courseRepository
.GetEnrolledCoursesAsync(user);
var courseMapper = new CourseMapper(_languageRepository, _mapper);
return(await courseMapper.MapDbCourseCollection(dbCourses));
}
public async Task <ICollection <Course> > GetCoursesByEditorNameAsync(string username)
{
var editor = await _userRepository
.GetUserByNameAsync(username);
var dbCourses = await _courseRepository
.GetCoursesByEditorAsync(editor);
var courseMapper = new CourseMapper(_languageRepository, _mapper);
return(await courseMapper.MapDbCourseCollection(dbCourses));
}
public IList<CourseBEAN> GetSheffieldHallamCourses()
{
var courseList = sheffieldHalamProxy.SHUCourses();
IList<CourseBEAN> result = new List<CourseBEAN>();
if (courseList != null)
{
foreach (SheffieldHallam.SHUCourse course in courseList)
{
result.Add(CourseMapper.GetInstance().Map(course));
}
}
return result.OrderBy(x => x.Name).ToList();
}
public ActionResult PartiallyUpdateCourseForAuthor(Guid authorId, Guid id,
JsonPatchDocument <UpdateCourseDto> patchDocument)
{
if (!AuthorRepository.Exists(authorId))
{
return(NotFound());
}
var course = CourseRepository.GetAuthorCourse(authorId, id);
if (course == null)
{
var courseDto = new UpdateCourseDto();
patchDocument.ApplyTo(courseDto, ModelState);
if (!TryValidateModel(courseDto))
{
return(ValidationProblem(ModelState));
}
var courseToAdd = CourseMapper.ToCourse(courseDto, authorId);
courseToAdd.Id = id;
CourseRepository.Create(courseToAdd);
_unitOfWork.Commit();
return(CreatedAtRoute(
"GetCourseForAuthor",
new { authorId, id = courseToAdd.Id },
CourseMapper.ToCourseDto(courseToAdd)
));
}
var courseToPatch = new UpdateCourseDto()
{
Description = course.Description,
Title = course.Title,
};
patchDocument.ApplyTo(courseToPatch, ModelState);
if (!TryValidateModel(courseToPatch))
{
return(ValidationProblem(ModelState));
}
CourseMapper.ToCourse(courseToPatch, authorId, course);
CourseRepository.Update(course);
_unitOfWork.Commit();
return(NoContent());
}
public List <CourseDto> GetAll()
{
var result = new List <CourseDto>();
//var courses = _courseRepository.GetAll();
var courses = _courseRepository.FindBy(c => c.IsDeleted == false);
foreach (var c in courses)
{
var dto = CourseMapper.CourseToCourseDto(c);
result.Add(dto);
}
return(result);
}
public Course update(Course newCourse)
{
Course oldCourse = _repository.get(newCourse.IDCourse);
if (oldCourse == null)
{
return(null);
}
oldCourse = CourseMapper.mapModel(oldCourse, newCourse);
if (oldCourse == null)
{
return(null);
}
_repository.update(oldCourse);
return(oldCourse);
}
public async Task <Course> CreateCourseAsync(Course course)
{
var dbCourse = _mapper.Map <DbCourse>(course);
dbCourse.Editor = await _userRepository.GetUserByNameAsync(course.Editor);
dbCourse.LearningLanguage = course.LearningLanguage.Language.Code;
dbCourse.LearningLanguageTerritory = course.LearningLanguage.Territory.Code;
dbCourse.TeachingLanguage = course.TeachingLanguage.Language.Code;
dbCourse.TeachingLanguageTerritory = course.TeachingLanguage.Territory.Code;
dbCourse.Level = await _languageRepository.GetCourseLevelByCodeAsync(course.Level.LevelCode);
var createdCourse = await _courseRepository.CreateCourseAsync(dbCourse);
var courseMapper = new CourseMapper(_languageRepository, _mapper);
return(await courseMapper.MapDbCourse(createdCourse));
}
